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

package/dist/runtime/server/contracts/security/command-error-observer.contract.d.ts

@@ -0,0 +1,73 @@
+import { AppError } from '../../../../kernel/error';
+import type { CommandMetadata } from '../../decorators/command';
+import type { Player } from '../../entities/player';
+import type { FeatureScope, FrameworkMode } from '../../runtime';
+/**
+ * High-level stage where a command error happened.
+ *
+ * @remarks
+ * Useful to drive decisions (e.g. show usage on validation errors).
+ */
+export type CommandErrorStage = 'dispatch' | 'auth' | 'security' | 'validation' | 'handler' | 'unknown';
+/**
+ * Public-facing command info intended for error reporting.
+ */
+export interface CommandErrorCommandInfo {
+    command: string;
+    description?: string;
+    usage?: string;
+    isPublic?: boolean;
+    methodName?: string;
+    expectsPlayer?: boolean;
+    paramNames?: string[];
+}
+/**
+ * Minimal player identity for error reporting.
+ */
+export interface CommandErrorPlayerInfo {
+    clientId: number;
+    accountId?: string;
+    name?: string;
+}
+/**
+ * Rich context emitted whenever command execution fails.
+ *
+ * @remarks
+ * The framework does not notify players directly. Consumers can implement
+ * {@link CommandErrorObserverContract} to decide how to report errors.
+ */
+export interface CommandErrorContext {
+    mode: FrameworkMode;
+    scope: FeatureScope;
+    stage: CommandErrorStage;
+    error: AppError;
+    commandName: string;
+    args: string[];
+    player: CommandErrorPlayerInfo;
+    /**
+     * Optional reference to the Player entity. Useful for custom
+     * (e.g. sending a chat message).
+     */
+    playerRef?: Player;
+    /**
+     * Best-effort command info (usage/description/etc.) to support.
+     */
+    command?: CommandErrorCommandInfo;
+    /**
+     * Raw metadata from the decorator, when available in the current runtime.
+     */
+    commandMeta?: CommandMetadata;
+    /**
+     * If the command is owned by a resource (remote command), indicates the owner.
+     */
+    ownerResourceName?: string;
+}
+/**
+ * Global observer contract for command execution errors.
+ */
+export declare abstract class CommandErrorObserverContract {
+    /**
+     * Called whenever command execution fails.
+     */
+    abstract onError(ctx: CommandErrorContext): Promise<void>;
+}

package/dist/runtime/server/contracts/security/command-error-observer.contract.js

@@ -0,0 +1,5 @@
+/**
+ * Global observer contract for command execution errors.
+ */
+export class CommandErrorObserverContract {
+}

package/dist/runtime/server/contracts/security/net-event-security-observer.contract.d.ts

@@ -0,0 +1,15 @@
+import { Player } from '../../entities/player';
+export type NetEventInvalidPayloadReason = 'zod' | 'arg_count' | 'security_error' | 'unknown';
+export interface NetEventInvalidPayloadContext {
+    event: string;
+    reason: NetEventInvalidPayloadReason;
+    playerId: number;
+    accountId?: string;
+    invalidCount: number;
+    zodSummary?: string[];
+    receivedArgsCount?: number;
+    expectedArgsCount?: number;
+}
+export declare abstract class NetEventSecurityObserverContract {
+    abstract onInvalidPayload(player: Player, ctx: NetEventInvalidPayloadContext): Promise<void>;
+}

package/dist/runtime/server/contracts/security/net-event-security-observer.contract.js

@@ -0,0 +1,2 @@
+export class NetEventSecurityObserverContract {
+}

package/dist/runtime/server/contracts/security/principal-provider.contract.d.ts

@@ -0,0 +1,43 @@
+import { LinkedID } from '../../types/linked-id';
+import { Principal } from '../../types/principal.type';
+import { Player } from '../../entities/player';
+/**
+ * **Authorization**
+ *
+ * This abstract class defines how the Security Layer retrieves user permissions.
+ * The Framework does not know about your persistence layer (SQL, Mongo, JSON or API); it relies on
+ * your implementation of this provider to resolve a `Principal`.
+ *
+ * @example
+ * ```ts
+ * // In your game resource:
+ * class MyPrincipal implements PrincipalProviderContract { ... }
+ * ```
+ */
+export declare abstract class PrincipalProviderContract {
+    /**
+     * Retrieves the security principal (Role/Permissions) for a connected player.
+     *
+     * **Performance Note:** This method is called frequently (on every guarded interaction).
+     * It is highly recommended to cache the result in memory (e.g., in `Player.session`).
+     *
+     * @param player - The active Server Player entity.
+     * @returns A Promise resolving to the `Principal` data, or `null` if the player is not authenticated.
+     */
+    abstract getPrincipal(player: Player): Promise<Principal | null>;
+    /**
+     * Forces a refresh of the player's permissions from the persistence layer.
+     * Useful when a player is promoted/demoted while online.
+     *
+     * @param player - The active Server Player entity to refresh.
+     */
+    abstract refreshPrincipal(player: Player): Promise<void>;
+    /**
+     * Retrieves a principal by their Account ID, even if they are offline.
+     * Useful for web panels, discord bots, or offline bans.
+     *
+     * @param linkedID - The unique linked ID (Account ID).
+     * @returns The Principal data or null.
+     */
+    abstract getPrincipalByLinkedID(linkedID: LinkedID): Promise<Principal | null>;
+}

package/dist/runtime/server/contracts/security/principal-provider.contract.js

@@ -0,0 +1,15 @@
+/**
+ * **Authorization**
+ *
+ * This abstract class defines how the Security Layer retrieves user permissions.
+ * The Framework does not know about your persistence layer (SQL, Mongo, JSON or API); it relies on
+ * your implementation of this provider to resolve a `Principal`.
+ *
+ * @example
+ * ```ts
+ * // In your game resource:
+ * class MyPrincipal implements PrincipalProviderContract { ... }
+ * ```
+ */
+export class PrincipalProviderContract {
+}

package/dist/runtime/server/contracts/security/security-handler.contract.d.ts

@@ -0,0 +1,5 @@
+import { SecurityError } from '../../../../kernel/error/security.error';
+import { Player } from '../../entities/player';
+export declare abstract class SecurityHandlerContract {
+    abstract handleViolation(player: Player, error: SecurityError): Promise<void>;
+}

package/dist/runtime/server/contracts/security/security-handler.contract.js

@@ -0,0 +1,2 @@
+export class SecurityHandlerContract {
+}

package/dist/runtime/server/controllers/channel.controller.d.ts

@@ -0,0 +1,115 @@
+import { RGB } from '../../../kernel/utils/rgb';
+import { Channels } from '../api';
+import { Players } from '../ports/players.api-port';
+import { ChannelMetadata, ChannelType } from '../types/channel.types';
+/**
+ * Export controller for channel system (CORE mode only).
+ *
+ * @remarks
+ * Exposes channel management to RESOURCE mode instances.
+ * Maintains a centralized registry of channels across all resources,
+ * allowing cross-resource communication via channels.
+ */
+export declare class ChannelExportController {
+    private channels;
+    private playerDirectory;
+    private remoteChannels;
+    constructor(channels: Channels, playerDirectory: Players);
+    /**
+     * Creates a channel in CORE from any resource.
+     *
+     * @remarks
+     * The channel is stored centrally in CORE and accessible from all resources.
+     *
+     * Exported as: `exports[coreResourceName].createChannel`
+     */
+    createChannel(channelId: string, metadata: ChannelMetadata, maxSubscribers?: number, resourceName?: string): boolean;
+    /**
+     * Deletes a channel from CORE.
+     *
+     * Exported as: `exports[coreResourceName].deleteChannel`
+     */
+    deleteChannel(channelId: string): boolean;
+    /**
+     * Checks if a channel exists in CORE.
+     *
+     * Exported as: `exports[coreResourceName].channelExists`
+     */
+    channelExists(channelId: string): boolean;
+    /**
+     * Subscribes a player to a channel.
+     *
+     * Exported as: `exports[coreResourceName].subscribeToChannel`
+     */
+    subscribeToChannel(channelId: string, clientID: number, metadata?: Record<string, unknown>): boolean;
+    /**
+     * Unsubscribes a player from a channel.
+     *
+     * Exported as: `exports[coreResourceName].unsubscribeFromChannel`
+     */
+    unsubscribeFromChannel(channelId: string, clientID: number): boolean;
+    /**
+     * Checks if a player is subscribed to a channel.
+     *
+     * Exported as: `exports[coreResourceName].isSubscribedToChannel`
+     */
+    isSubscribedToChannel(channelId: string, clientID: number): boolean;
+    /**
+     * Gets subscriber count for a channel.
+     *
+     * Exported as: `exports[coreResourceName].getChannelSubscriberCount`
+     */
+    getChannelSubscriberCount(channelId: string): number;
+    /**
+     * Gets all subscriber client IDs for a channel.
+     *
+     * Exported as: `exports[coreResourceName].getChannelSubscribers`
+     */
+    getChannelSubscribers(channelId: string): number[];
+    /**
+     * Broadcasts a message to all subscribers of a channel.
+     *
+     * Exported as: `exports[coreResourceName].broadcastToChannel`
+     */
+    broadcastToChannel(channelId: string, senderClientID: number, message: string, author?: string, color?: RGB): boolean;
+    /**
+     * Broadcasts a system message to all subscribers of a channel.
+     *
+     * Exported as: `exports[coreResourceName].broadcastSystemToChannel`
+     */
+    broadcastSystemToChannel(channelId: string, message: string, author?: string, color?: RGB): boolean;
+    /**
+     * Creates a proximity channel around a player.
+     *
+     * Exported as: `exports[coreResourceName].createProximityChannel`
+     */
+    createProximityChannel(originClientID: number, radius: number, channelId?: string): string | null;
+    /**
+     * Creates a private channel for specific players.
+     *
+     * Exported as: `exports[coreResourceName].createPrivateChannel`
+     */
+    createPrivateChannel(clientIDs: number[], metadata: ChannelMetadata): string | null;
+    /**
+     * Gets all channel IDs by type.
+     *
+     * Exported as: `exports[coreResourceName].getChannelsByType`
+     */
+    getChannelsByType(type: ChannelType): string[];
+    /**
+     * Gets all channel IDs a player is subscribed to.
+     *
+     * Exported as: `exports[coreResourceName].getPlayerChannels`
+     */
+    getPlayerChannels(clientID: number): string[];
+    /**
+     * Gets all channel IDs.
+     *
+     * Exported as: `exports[coreResourceName].getAllChannels`
+     */
+    getAllChannels(): string[];
+    /**
+     * Cleans up channels owned by a resource when it stops.
+     */
+    onResourceStop(resourceName: string): void;
+}

package/dist/runtime/server/controllers/channel.controller.js

@@ -0,0 +1,373 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AppError } from '../../../kernel/error';
+import { loggers } from '../../../kernel/logger';
+import { Channels } from '../api';
+import { Controller, Export } from '../decorators';
+import { OnRuntimeEvent } from '../decorators/onRuntimeEvent';
+import { Players } from '../ports/players.api-port';
+import { ChannelType } from '../types/channel.types';
+/**
+ * Export controller for channel system (CORE mode only).
+ *
+ * @remarks
+ * Exposes channel management to RESOURCE mode instances.
+ * Maintains a centralized registry of channels across all resources,
+ * allowing cross-resource communication via channels.
+ */
+let ChannelExportController = class ChannelExportController {
+    channels;
+    playerDirectory;
+    remoteChannels = new Map();
+    constructor(channels, playerDirectory) {
+        this.channels = channels;
+        this.playerDirectory = playerDirectory;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Channel Creation & Management
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Creates a channel in CORE from any resource.
+     *
+     * @remarks
+     * The channel is stored centrally in CORE and accessible from all resources.
+     *
+     * Exported as: `exports[coreResourceName].createChannel`
+     */
+    createChannel(channelId, metadata, maxSubscribers, resourceName) {
+        try {
+            this.channels.create(channelId, metadata, maxSubscribers);
+            if (resourceName) {
+                this.remoteChannels.set(channelId, {
+                    channelId,
+                    resourceName,
+                    metadata,
+                });
+                loggers.api.debug(`Channel '${channelId}' created by resource '${resourceName}'`);
+            }
+            else {
+                loggers.api.debug(`Channel '${channelId}' created locally`);
+            }
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            loggers.api.warn(`Failed to create channel '${channelId}': ${message}`);
+            return false;
+        }
+    }
+    /**
+     * Deletes a channel from CORE.
+     *
+     * Exported as: `exports[coreResourceName].deleteChannel`
+     */
+    deleteChannel(channelId) {
+        const deleted = this.channels.delete(channelId);
+        if (deleted) {
+            this.remoteChannels.delete(channelId);
+            loggers.api.debug(`Channel '${channelId}' deleted`);
+        }
+        return deleted;
+    }
+    /**
+     * Checks if a channel exists in CORE.
+     *
+     * Exported as: `exports[coreResourceName].channelExists`
+     */
+    channelExists(channelId) {
+        return this.channels.exists(channelId);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Subscription Management
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Subscribes a player to a channel.
+     *
+     * Exported as: `exports[coreResourceName].subscribeToChannel`
+     */
+    subscribeToChannel(channelId, clientID, metadata) {
+        try {
+            const player = this.playerDirectory.getByClient(clientID);
+            if (!player) {
+                throw new AppError('GAME:PLAYER_NOT_FOUND', `Player not found: ${clientID}`, 'core');
+            }
+            return this.channels.subscribe(channelId, player, metadata);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            loggers.api.warn(`Failed to subscribe player ${clientID} to channel '${channelId}': ${message}`);
+            return false;
+        }
+    }
+    /**
+     * Unsubscribes a player from a channel.
+     *
+     * Exported as: `exports[coreResourceName].unsubscribeFromChannel`
+     */
+    unsubscribeFromChannel(channelId, clientID) {
+        const player = this.playerDirectory.getByClient(clientID);
+        if (!player)
+            return false;
+        return this.channels.unsubscribe(channelId, player);
+    }
+    /**
+     * Checks if a player is subscribed to a channel.
+     *
+     * Exported as: `exports[coreResourceName].isSubscribedToChannel`
+     */
+    isSubscribedToChannel(channelId, clientID) {
+        const player = this.playerDirectory.getByClient(clientID);
+        if (!player)
+            return false;
+        return this.channels.isSubscribed(channelId, player);
+    }
+    /**
+     * Gets subscriber count for a channel.
+     *
+     * Exported as: `exports[coreResourceName].getChannelSubscriberCount`
+     */
+    getChannelSubscriberCount(channelId) {
+        const channel = this.channels.get(channelId);
+        return channel ? channel.getSubscriberCount() : 0;
+    }
+    /**
+     * Gets all subscriber client IDs for a channel.
+     *
+     * Exported as: `exports[coreResourceName].getChannelSubscribers`
+     */
+    getChannelSubscribers(channelId) {
+        const subscribers = this.channels.getSubscribers(channelId);
+        return subscribers.map((p) => p.clientID);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Broadcasting
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Broadcasts a message to all subscribers of a channel.
+     *
+     * Exported as: `exports[coreResourceName].broadcastToChannel`
+     */
+    broadcastToChannel(channelId, senderClientID, message, author, color) {
+        try {
+            const sender = this.playerDirectory.getByClient(senderClientID);
+            if (!sender) {
+                throw new AppError('GAME:PLAYER_NOT_FOUND', `Sender not found: ${senderClientID}`, 'core');
+            }
+            this.channels.broadcast(channelId, sender, message, author, color);
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            loggers.api.warn(`Failed to broadcast to channel '${channelId}': ${message}`);
+            return false;
+        }
+    }
+    /**
+     * Broadcasts a system message to all subscribers of a channel.
+     *
+     * Exported as: `exports[coreResourceName].broadcastSystemToChannel`
+     */
+    broadcastSystemToChannel(channelId, message, author, color) {
+        try {
+            this.channels.broadcastSystem(channelId, message, author, color);
+            return true;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            loggers.api.warn(`Failed to broadcast system message to channel '${channelId}': ${message}`);
+            return false;
+        }
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Specialized Channel Creation
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Creates a proximity channel around a player.
+     *
+     * Exported as: `exports[coreResourceName].createProximityChannel`
+     */
+    createProximityChannel(originClientID, radius, channelId) {
+        const originPlayer = this.playerDirectory.getByClient(originClientID);
+        if (!originPlayer)
+            return null;
+        const channel = this.channels.createProximityChannel(originPlayer, radius, channelId);
+        return channel ? channel.id : null;
+    }
+    /**
+     * Creates a private channel for specific players.
+     *
+     * Exported as: `exports[coreResourceName].createPrivateChannel`
+     */
+    createPrivateChannel(clientIDs, metadata) {
+        const players = clientIDs
+            .map((id) => this.playerDirectory.getByClient(id))
+            .filter((p) => p !== undefined);
+        if (players.length === 0)
+            return null;
+        const channel = this.channels.createPrivate(players, metadata);
+        return channel.id;
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Query & Introspection
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Gets all channel IDs by type.
+     *
+     * Exported as: `exports[coreResourceName].getChannelsByType`
+     */
+    getChannelsByType(type) {
+        const channels = this.channels.getChannelsByType(type);
+        return channels.map((c) => c.id);
+    }
+    /**
+     * Gets all channel IDs a player is subscribed to.
+     *
+     * Exported as: `exports[coreResourceName].getPlayerChannels`
+     */
+    getPlayerChannels(clientID) {
+        const player = this.playerDirectory.getByClient(clientID);
+        if (!player)
+            return [];
+        const channels = this.channels.getChannelsByPlayer(player);
+        return channels.map((c) => c.id);
+    }
+    /**
+     * Gets all channel IDs.
+     *
+     * Exported as: `exports[coreResourceName].getAllChannels`
+     */
+    getAllChannels() {
+        const channels = this.channels.getAllChannels();
+        return channels.map((c) => c.id);
+    }
+    // ═══════════════════════════════════════════════════════════════
+    // Resource Cleanup
+    // ═══════════════════════════════════════════════════════════════
+    /**
+     * Cleans up channels owned by a resource when it stops.
+     */
+    onResourceStop(resourceName) {
+        const channelsToDelete = [];
+        for (const [channelId, entry] of this.remoteChannels.entries()) {
+            if (entry.resourceName === resourceName) {
+                channelsToDelete.push(channelId);
+            }
+        }
+        if (channelsToDelete.length > 0) {
+            loggers.api.info(`Cleaning up ${channelsToDelete.length} channels from stopped resource '${resourceName}'`);
+            for (const channelId of channelsToDelete) {
+                this.channels.delete(channelId);
+                this.remoteChannels.delete(channelId);
+            }
+        }
+    }
+};
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Number, String]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "createChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "deleteChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "channelExists", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number, Object]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "subscribeToChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "unsubscribeFromChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "isSubscribedToChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Number)
+], ChannelExportController.prototype, "getChannelSubscriberCount", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Array)
+], ChannelExportController.prototype, "getChannelSubscribers", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Number, String, String, Object]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "broadcastToChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, String, Object]),
+    __metadata("design:returntype", Boolean)
+], ChannelExportController.prototype, "broadcastSystemToChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number, Number, String]),
+    __metadata("design:returntype", Object)
+], ChannelExportController.prototype, "createProximityChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Object)
+], ChannelExportController.prototype, "createPrivateChannel", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Array)
+], ChannelExportController.prototype, "getChannelsByType", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Number]),
+    __metadata("design:returntype", Array)
+], ChannelExportController.prototype, "getPlayerChannels", null);
+__decorate([
+    Export(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Array)
+], ChannelExportController.prototype, "getAllChannels", null);
+__decorate([
+    OnRuntimeEvent('onServerResourceStop'),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", void 0)
+], ChannelExportController.prototype, "onResourceStop", null);
+ChannelExportController = __decorate([
+    Controller(),
+    __metadata("design:paramtypes", [Channels,
+        Players])
+], ChannelExportController);
+export { ChannelExportController };

package/dist/runtime/server/controllers/chat.controller.d.ts

@@ -0,0 +1,11 @@
+import { RGB } from '../../../kernel/utils/rgb';
+import { Chat } from '../apis/chat.api';
+import { Players } from '../ports/players.api-port';
+export declare class ChatController {
+    private readonly chat;
+    private readonly players;
+    constructor(chat: Chat, players: Players);
+    coreBroadcast(message: string, author?: string, color?: RGB): void;
+    coreSendPrivate(targetId: number, message: string, author?: string): void;
+    coreSendToGroupOfPlayers(targets: number[], message: string, author?: string, color?: RGB): void;
+}