@jsprismarine/prismarine/dist/Server.d.ts

Dedicated Minecraft Bedrock Edition server written in TypeScript

import { RakNetListener, ServerName } from '../../raknet/src/index.ts';
import { default as Console } from './Console';
import { default as SessionManager } from './SessionManager';
import { default as BanManager } from './ban/BanManager';
import { default as BlockManager } from './block/BlockManager';
import { ChatManager } from './chat/ChatManager';
import { CommandManager } from './command/CommandManager';
import { EventEmitter } from './events/EventEmitter';
import { default as ItemManager } from './item/ItemManager';
import { default as Identifiers } from './network/Identifiers';
import { default as PacketRegistry } from './network/PacketRegistry';
import { DataPacket } from './network/Packets';
import { PermissionManager } from './permission/PermissionManager';
import { QueryManager } from './query/QueryManager';
import { default as WorldManager } from './world/WorldManager';
import { Config } from './config/Config';
import { Logger } from '../../logger/src/index.ts';
/**
 * JSPrismarine's main server class.
 * @public
 */
export default class Server extends EventEmitter {
    private raknet;
    private readonly logger;
    private readonly config;
    private readonly console;
    private readonly packetRegistry;
    private readonly sessionManager;
    private readonly commandManager;
    private readonly worldManager;
    private readonly itemManager;
    private readonly blockManager;
    private readonly queryManager;
    private readonly chatManager;
    private readonly permissionManager;
    private readonly banManager;
    /**
     * If the server is stopping.
     * @internal
     */
    private stopping;
    /**
     * The current ticker timer.
     * @internal
     */
    private tickerTimer;
    /**
     * The current TPS.
     * @internal
     */
    private tps;
    /**
     * The current tick.
     * @internal
     */
    private currentTick;
    /**
     * If the server is headless.
     * @internal
     */
    private readonly headless;
    private static readonly MINECRAFT_TICK_TIME_MS;
    /**
     * Creates a new server instance.
     * @param {object} options - The options.
     * @param {LoggerBuilder} options.logger - The logger.
     * @param {Config} options.config - The config.
     * @returns {Server} The server instance.
     */
    constructor({ logger, config, headless }: {
        logger: Logger;
        config: Config;
        headless?: boolean;
    });
    /**
     * Enables the server.
     * @returns {Promise<void>} A promise that resolves when the server is enabled.
     * @internal
     */
    private enable;
    /**
     * Disables the server.
     * @returns {Promise<void>} A promise that resolves when the server is disabled.
     * @internal
     */
    private disable;
    getMetadata(): ServerName;
    /**
     * Reloads the server.
     * @returns {Promise<void>} A promise that resolves when the server is reloaded.
     * @remarks This method is equivalent to calling {@link Server#disable} and {@link Server#enable}.
     * @remarks This method and functionality is unsupported and should ideally be completely avoided.
     */
    reload(): Promise<void>;
    /**
     * Starts the server.
     * @param {string} [serverIp='0.0.0.0'] - The server IP.
     * @param {number} [port=19132] - The server port.
     * @returns {Promise<void>} A promise that resolves when the server is started.
     */
    bootstrap(serverIp?: string, port?: number): Promise<void>;
    /**
     * Kills the server asynchronously.
     * @param {object} [options] - The options.
     * @param {boolean} [options.crash] - If the server should crash.
     * @param {boolean} [options.stayAlive] - If we should let the process stay alive.
     * @returns {Promise<void>} A promise that resolves when the server is killed.
     */
    shutdown(options?: {
        crash?: boolean;
        stayAlive?: boolean;
    }): Promise<void>;
    broadcastPacket<T extends DataPacket>(dataPacket: T): Promise<void>;
    /**
     * Returns the server version.
     * @returns {string} The server version.
     * @example
     * ```typescript
     * console.log(server.getVersion());
     * ```
     */
    getVersion(): string;
    /**
     * Returns the identifiers.
     * @returns {Identifiers} The identifiers.
     */
    getIdentifiers(): typeof Identifiers;
    /**
     * Returns the query manager.
     * @returns {QueryManager} The query manager.
     */
    getQueryManager(): QueryManager;
    /**
     * Returns the command manager.
     * @returns {CommandManager} The command manager.
     */
    getCommandManager(): CommandManager;
    /**
     * Returns the player manager.
     * @returns {SessionManager} The player manager.
     */
    getSessionManager(): SessionManager;
    /**
     * Returns the world manager.
     * @returns {WorldManager} The world manager.
     */
    getWorldManager(): WorldManager;
    /**
     * Returns the item manager.
     * @returns {ItemManager} The item manager.
     */
    getItemManager(): ItemManager;
    /**
     * Returns the block manager.
     * @returns {BlockManager} The block manager.
     */
    getBlockManager(): BlockManager;
    /**
     * Returns the logger.
     * @returns {LoggerBuilder} The logger.
     * @example
     * ```typescript
     * // Normal log:
     * server.getLogger().info('Hello, world!');
     * // Debug log:
     * server.getLogger().debug('Hello, world!');
     * // Error log:
     * server.getLogger().error(new Error('Hello World'));
     * ```
     */
    getLogger(): Logger;
    /**
     * Returns the packet registry.
     * @returns {PacketRegistry} The packet registry.
     */
    getPacketRegistry(): PacketRegistry;
    /**
     * Returns the raknet instance.
     * @returns {RakNetListener | undefined} The raknet instance.
     */
    getRaknet(): RakNetListener | undefined;
    /**
     * Returns the chat manager.
     * @returns {ChatManager} The chat manager.
     */
    getChatManager(): ChatManager;
    /**
     * Returns the config.
     * @returns {Config} The config.
     * @example
     * ```typescript
     * console.log(server.getConfig().getMaxPlayers()); // 20
     * ```
     */
    getConfig(): Config;
    /**
     * Returns the console instance.
     * @returns {Console | undefined} The console instance.
     */
    getConsole(): Console | undefined;
    /**
     * Returns the permission manager.
     * @returns {PermissionManager} The permission manager.
     */
    getPermissionManager(): PermissionManager;
    /**
     * Returns the ban manager.
     * @returns {BanManager} The ban manager.
     */
    getBanManager(): BanManager;
    /**
     * Returns this Prismarine instance.
     * @returns {Server} The Prismarine instance.
     */
    getServer(): Server;
    /**
     * Returns the current Tick.
     * @returns {number} The current Tick.
     */
    getTick(): number;
    /**
     * Returns the current TPS.
     * @returns {number} The current TPS.
     */
    getTPS(): number;
}
//# sourceMappingURL=Server.d.ts.map