@open-core/framework 0.1.0-alpha.1 → 0.2.0-beta.1

package/dist/kernel/shared/logger/transports/simple-console.transport.d.ts

@@ -0,0 +1,38 @@
+import { type LogEntry, LogLevel } from '../logger.types';
+import { LogTransport } from './transport.interface';
+export interface SimpleConsoleTransportOptions {
+    /**
+     * Minimum log level to output. Defaults to INFO.
+     */
+    minLevel?: LogLevel;
+    /**
+     * Whether to include timestamp in output. Defaults to true.
+     */
+    timestamps?: boolean;
+    /**
+     * Whether to show context data. Defaults to false for cleaner output.
+     */
+    showContext?: boolean;
+}
+/**
+ * Simple console transport without ANSI color codes.
+ * Designed for FiveM client console which doesn't support ANSI formatting.
+ *
+ * Output format: [HH:MM:SS.mmm] [DOMAIN] LEVEL [Source] Message
+ *
+ * @example
+ * ```typescript
+ * const transport = new SimpleConsoleTransport({
+ *   minLevel: LogLevel.INFO,
+ *   timestamps: true
+ * })
+ * ```
+ */
+export declare class SimpleConsoleTransport implements LogTransport {
+    readonly name = "simple-console";
+    minLevel: LogLevel;
+    private timestamps;
+    private showContext;
+    constructor(options?: SimpleConsoleTransportOptions);
+    write(entry: LogEntry): void;
+}

package/dist/kernel/shared/logger/transports/simple-console.transport.js

@@ -0,0 +1,93 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleConsoleTransport = void 0;
+const logger_types_1 = require("../logger.types");
+/**
+ * Simple console transport without ANSI color codes.
+ * Designed for FiveM client console which doesn't support ANSI formatting.
+ *
+ * Output format: [HH:MM:SS.mmm] [DOMAIN] LEVEL [Source] Message
+ *
+ * @example
+ * ```typescript
+ * const transport = new SimpleConsoleTransport({
+ *   minLevel: LogLevel.INFO,
+ *   timestamps: true
+ * })
+ * ```
+ */
+class SimpleConsoleTransport {
+    constructor(options = {}) {
+        var _a, _b, _c;
+        this.name = 'simple-console';
+        this.minLevel = (_a = options.minLevel) !== null && _a !== void 0 ? _a : logger_types_1.LogLevel.INFO;
+        this.timestamps = (_b = options.timestamps) !== null && _b !== void 0 ? _b : true;
+        this.showContext = (_c = options.showContext) !== null && _c !== void 0 ? _c : false;
+    }
+    write(entry) {
+        var _a, _b;
+        const { level, domain, message, timestamp, context, error } = entry;
+        const levelLabel = logger_types_1.LogLevelLabels[level].padEnd(5);
+        const domainLabel = logger_types_1.LogDomainLabels[domain];
+        // Build the log line without ANSI codes
+        const parts = [];
+        if (this.timestamps) {
+            const time = (_b = (_a = timestamp.split('T')[1]) === null || _a === void 0 ? void 0 : _a.slice(0, 12)) !== null && _b !== void 0 ? _b : timestamp;
+            parts.push(`[${time}]`);
+        }
+        // Domain tag
+        parts.push(`[${domainLabel}]`);
+        // Level
+        parts.push(levelLabel);
+        // Source module/controller
+        if (context === null || context === void 0 ? void 0 : context.source) {
+            parts.push(`[${context.source}]`);
+        }
+        parts.push(message);
+        // Output the main log line
+        const logLine = parts.join(' ');
+        // Choose the appropriate console method
+        switch (level) {
+            case logger_types_1.LogLevel.TRACE:
+            case logger_types_1.LogLevel.DEBUG:
+                console.debug(logLine);
+                break;
+            case logger_types_1.LogLevel.INFO:
+                console.info(logLine);
+                break;
+            case logger_types_1.LogLevel.WARN:
+                console.warn(logLine);
+                break;
+            case logger_types_1.LogLevel.ERROR:
+            case logger_types_1.LogLevel.FATAL:
+                console.error(logLine);
+                break;
+            default:
+                console.log(logLine);
+        }
+        // Output context only if enabled and present
+        if (this.showContext && context) {
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { source, domain: _ } = context, rest = __rest(context, ["source", "domain"]);
+            if (Object.keys(rest).length > 0) {
+                console.debug('  context:', JSON.stringify(rest));
+            }
+        }
+        // Output error stack if present
+        if (error === null || error === void 0 ? void 0 : error.stack) {
+            console.error('  stack:', error.stack);
+        }
+    }
+}
+exports.SimpleConsoleTransport = SimpleConsoleTransport;

package/dist/{shared → kernel/shared}/logger/transports/transport.interface.d.ts

@@ -1,4 +1,4 @@
-import type { LogEntry, LogLevel } from '../logger.types';
+import { LogEntry, LogLevel } from '../logger.types';
 /**
  * Contract that all log transports must implement.
  *

package/dist/kernel/shared/logger/transports/websocket.transport.d.ts

@@ -0,0 +1,69 @@
+import { type LogEntry, LogLevel } from '../logger.types';
+import { LogTransport } from './transport.interface';
+/**
+ * Configuration for WebSocket log transport.
+ */
+export interface WebSocketTransportOptions {
+    /** WebSocket server URL */
+    url: string;
+    /** Auto-reconnect on disconnect */
+    reconnect?: boolean;
+    /** Reconnect interval in milliseconds */
+    reconnectInterval?: number;
+    /** Maximum buffer size when disconnected */
+    bufferSize?: number;
+}
+/**
+ * WebSocket-based log transport for streaming logs to external tools.
+ *
+ * Used during development to stream logs to the CLI or other monitoring tools.
+ * Buffers messages when disconnected and flushes on reconnection.
+ *
+ * @example
+ * ```typescript
+ * const transport = new WebSocketLogTransport({
+ *   url: 'ws://localhost:3848',
+ *   reconnect: true,
+ * })
+ * await transport.connect()
+ * logger.addTransport(transport)
+ * ```
+ */
+export declare class WebSocketLogTransport implements LogTransport {
+    readonly name = "websocket";
+    minLevel: LogLevel;
+    private ws;
+    private buffer;
+    private options;
+    private connected;
+    private reconnectTimer;
+    private messageHandlers;
+    constructor(options: WebSocketTransportOptions, minLevel?: LogLevel);
+    /**
+     * Connects to the WebSocket server.
+     */
+    connect(): Promise<void>;
+    /**
+     * Writes a log entry to the WebSocket or buffer.
+     */
+    write(entry: LogEntry): void;
+    /**
+     * Sends a raw message through the WebSocket.
+     */
+    send(message: unknown): void;
+    /**
+     * Registers a handler for incoming messages.
+     */
+    onMessage(handler: (data: unknown) => void): void;
+    /**
+     * Checks if currently connected.
+     */
+    isConnected(): boolean;
+    /**
+     * Disconnects and cleans up resources.
+     */
+    destroy(): void;
+    private bufferEntry;
+    private flushBuffer;
+    private scheduleReconnect;
+}

package/dist/kernel/shared/logger/transports/websocket.transport.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketLogTransport = void 0;
+const logger_types_1 = require("../logger.types");
+/**
+ * WebSocket-based log transport for streaming logs to external tools.
+ *
+ * Used during development to stream logs to the CLI or other monitoring tools.
+ * Buffers messages when disconnected and flushes on reconnection.
+ *
+ * @example
+ * ```typescript
+ * const transport = new WebSocketLogTransport({
+ *   url: 'ws://localhost:3848',
+ *   reconnect: true,
+ * })
+ * await transport.connect()
+ * logger.addTransport(transport)
+ * ```
+ */
+class WebSocketLogTransport {
+    constructor(options, minLevel = logger_types_1.LogLevel.DEBUG) {
+        var _a, _b, _c;
+        this.name = 'websocket';
+        this.ws = null;
+        this.buffer = [];
+        this.connected = false;
+        this.reconnectTimer = null;
+        this.messageHandlers = [];
+        this.minLevel = minLevel;
+        this.options = {
+            url: options.url,
+            reconnect: (_a = options.reconnect) !== null && _a !== void 0 ? _a : true,
+            reconnectInterval: (_b = options.reconnectInterval) !== null && _b !== void 0 ? _b : 5000,
+            bufferSize: (_c = options.bufferSize) !== null && _c !== void 0 ? _c : 100,
+        };
+    }
+    /**
+     * Connects to the WebSocket server.
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            try {
+                this.ws = new WebSocket(this.options.url);
+                this.ws.onopen = () => {
+                    this.connected = true;
+                    this.flushBuffer();
+                    resolve();
+                };
+                this.ws.onclose = () => {
+                    this.connected = false;
+                    this.ws = null;
+                    if (this.options.reconnect) {
+                        this.scheduleReconnect();
+                    }
+                };
+                this.ws.onerror = (error) => {
+                    if (!this.connected) {
+                        reject(error);
+                    }
+                };
+                this.ws.onmessage = (event) => {
+                    try {
+                        const data = JSON.parse(event.data);
+                        for (const handler of this.messageHandlers) {
+                            handler(data);
+                        }
+                    }
+                    catch (_a) {
+                        // Ignore parse errors
+                    }
+                };
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Writes a log entry to the WebSocket or buffer.
+     */
+    write(entry) {
+        var _a;
+        const message = {
+            type: 'log',
+            payload: {
+                level: entry.level,
+                domain: entry.domain,
+                message: entry.message,
+                timestamp: entry.timestamp,
+                context: entry.context,
+                error: entry.error
+                    ? {
+                        name: entry.error.name,
+                        message: entry.error.message,
+                        stack: entry.error.stack,
+                    }
+                    : undefined,
+            },
+        };
+        if (this.connected && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            this.bufferEntry(entry);
+        }
+    }
+    /**
+     * Sends a raw message through the WebSocket.
+     */
+    send(message) {
+        var _a;
+        if (this.connected && ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Registers a handler for incoming messages.
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Checks if currently connected.
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Disconnects and cleans up resources.
+     */
+    destroy() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.onclose = null;
+            this.ws.close();
+            this.ws = null;
+        }
+        this.connected = false;
+        this.buffer = [];
+        this.messageHandlers = [];
+    }
+    bufferEntry(entry) {
+        this.buffer.push(entry);
+        if (this.buffer.length > this.options.bufferSize) {
+            this.buffer.shift();
+        }
+    }
+    flushBuffer() {
+        for (const entry of this.buffer) {
+            this.write(entry);
+        }
+        this.buffer = [];
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect().catch(() => {
+                // Will retry via onclose handler
+            });
+        }, this.options.reconnectInterval);
+    }
+}
+exports.WebSocketLogTransport = WebSocketLogTransport;

package/dist/kernel/utils/error/app.error.d.ts

@@ -0,0 +1,9 @@
+import { ErrorOrigin } from './types/common.error-codes';
+import { FrameworkErrorCode } from './types/framework.error-codes';
+export declare class AppError extends Error {
+    readonly code: FrameworkErrorCode;
+    readonly details?: unknown;
+    readonly origin: ErrorOrigin;
+    constructor(code: FrameworkErrorCode, message: string, origin: ErrorOrigin, details?: unknown);
+}
+export declare function isAppError(error: unknown): error is AppError;

package/dist/{utils/errors.js → kernel/utils/error/app.error.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecurityError = exports.AppError = void 0;
+exports.AppError = void 0;
 exports.isAppError = isAppError;
 class AppError extends Error {
     constructor(code, message, origin, details) {
@@ -15,11 +15,3 @@ exports.AppError = AppError;
 function isAppError(error) {
     return error instanceof AppError;
 }
-class SecurityError extends AppError {
-    constructor(action, message, details) {
-        super('NETWORK_ERROR', message, 'core', details);
-        this.action = action;
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-}
-exports.SecurityError = SecurityError;

package/dist/kernel/utils/error/security.error.d.ts

@@ -0,0 +1,6 @@
+import { SecurityAction } from '../../../runtime/server/types/security.types';
+import { AppError } from './app.error';
+export declare class SecurityError extends AppError {
+    readonly action: SecurityAction;
+    constructor(action: SecurityAction, message: string, details?: unknown);
+}

package/dist/kernel/utils/error/security.error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityError = void 0;
+const app_error_1 = require("./app.error");
+class SecurityError extends app_error_1.AppError {
+    constructor(action, message, details) {
+        super('NETWORK:ERROR', message, 'core', details);
+        this.action = action;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.SecurityError = SecurityError;

package/dist/{utils → kernel/utils}/index.d.ts

@@ -1,4 +1,5 @@
-export * from './errors';
+export * from './error/app.error';
+export * from './error/security.error';
 export * from './result';
-export * from './vector3';
 export * from './rgb';
+export * from './vector3';

package/dist/{utils → kernel/utils}/index.js

@@ -14,7 +14,8 @@ 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 });
-__exportStar(require("./errors"), exports);
+__exportStar(require("./error/app.error"), exports);
+__exportStar(require("./error/security.error"), exports);
 __exportStar(require("./result"), exports);
-__exportStar(require("./vector3"), exports);
 __exportStar(require("./rgb"), exports);
+__exportStar(require("./vector3"), exports);

package/dist/{utils → kernel/utils}/result.d.ts

@@ -1,4 +1,4 @@
-import type { AppError } from './errors';
+import { AppError } from './error/app.error';
 export interface Ok<T> {
     ok: true;
     value: T;

package/dist/runtime/client/client-bootstrap.d.ts

@@ -0,0 +1,7 @@
+import { type ClientInitOptions } from './client-runtime';
+/**
+ * Initialize the client core framework
+ *
+ * @param options - Client initialization options
+ */
+export declare function initClientCore(options?: ClientInitOptions): Promise<void>;

package/dist/runtime/client/client-bootstrap.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initClientCore = initClientCore;
+const register_client_capabilities_1 = require("../../adapters/register-client-capabilities");
+const metadata_scanner_1 = require("../../kernel/di/metadata.scanner");
+const logger_1 = require("../../kernel/shared/logger");
+const client_container_1 = require("./client-container");
+const client_runtime_1 = require("./client-runtime");
+const decorators_1 = require("./decorators");
+const player_loader_1 = require("./player/player.loader");
+const services_1 = require("./services");
+const processors_register_1 = require("./system/processors.register");
+const ui_bridge_1 = require("./ui-bridge");
+/**
+ * Services that have an init() method which registers global FiveM event listeners.
+ *
+ * These services are:
+ * - Registered in DI for ALL modes (so they can be injected and used)
+ * - Only initialized (.init() called) in CORE mode to avoid duplicate event handlers
+ */
+const SERVICES_WITH_GLOBAL_LISTENERS = [services_1.SpawnService];
+/**
+ * All client services that should be available in the DI container
+ */
+// const ALL_CLIENT_SERVICES = [
+//   SpawnService,
+//   NuiBridge,
+//   NotificationService,
+//   TextUIService,
+//   ProgressService,
+//   MarkerService,
+//   BlipService,
+//   VehicleClientService,
+//   VehicleService,
+//   PedService,
+//   StreamingService,
+// ] as const
+/**
+ * Get current resource name safely
+ */
+function getCurrentResourceNameSafe() {
+    const fn = globalThis.GetCurrentResourceName;
+    if (typeof fn === 'function') {
+        const name = fn();
+        if (typeof name === 'string' && name.trim())
+            return name;
+    }
+    return 'default';
+}
+/**
+ * Register singleton services in the DI container
+ *
+ * @remarks
+ * All services are registered in ALL modes so they can be injected and used.
+ * However, only CORE mode will call .init() on services with global listeners.
+ */
+function registerServices() {
+    // Register all client services in DI (available in all modes)
+    client_container_1.di.registerSingleton(services_1.SpawnService, services_1.SpawnService);
+    client_container_1.di.registerSingleton(ui_bridge_1.NuiBridge, ui_bridge_1.NuiBridge);
+    client_container_1.di.registerSingleton(services_1.NotificationService, services_1.NotificationService);
+    client_container_1.di.registerSingleton(services_1.TextUIService, services_1.TextUIService);
+    client_container_1.di.registerSingleton(services_1.ProgressService, services_1.ProgressService);
+    client_container_1.di.registerSingleton(services_1.MarkerService, services_1.MarkerService);
+    client_container_1.di.registerSingleton(services_1.BlipService, services_1.BlipService);
+    client_container_1.di.registerSingleton(services_1.VehicleClientService, services_1.VehicleClientService);
+    client_container_1.di.registerSingleton(services_1.VehicleService, services_1.VehicleService);
+    client_container_1.di.registerSingleton(services_1.PedService, services_1.PedService);
+    client_container_1.di.registerSingleton(services_1.StreamingService, services_1.StreamingService);
+}
+/**
+ * Bootstrap services that need initialization
+ *
+ * @remarks
+ * Only called in CORE mode to initialize services that register global event listeners.
+ * This prevents duplicate event handlers when multiple resources use the framework.
+ *
+ * @param mode - The client initialization mode
+ */
+async function bootstrapServices(mode) {
+    if (mode === 'CORE') {
+        // Initialize services with global listeners (only in CORE mode)
+        for (const Service of SERVICES_WITH_GLOBAL_LISTENERS) {
+            const instance = client_container_1.di.resolve(Service);
+            if (typeof instance.init === 'function') {
+                await instance.init();
+            }
+        }
+        // Instantiate VehicleClientService to register its event handlers
+        client_container_1.di.resolve(services_1.VehicleClientService);
+    }
+}
+/**
+ * Initialize the client core framework
+ *
+ * @param options - Client initialization options
+ */
+async function initClientCore(options = {}) {
+    var _a;
+    const mode = (_a = options.mode) !== null && _a !== void 0 ? _a : 'CORE';
+    const resourceName = getCurrentResourceNameSafe();
+    // Register system processors early (needed for MetadataScanner)
+    // These processors are safe - they just process metadata, they don't register event handlers
+    // Each resource bundle needs its own copy registered in its DI container
+    (0, processors_register_1.registerSystemClient)();
+    // Check if already initialized
+    const existingContext = (0, client_runtime_1.getClientRuntimeContext)();
+    if (existingContext === null || existingContext === void 0 ? void 0 : existingContext.isInitialized) {
+        // If already initialized, only scan controllers for this resource
+        if (mode === 'RESOURCE' || mode === 'STANDALONE') {
+            const scanner = client_container_1.di.resolve(metadata_scanner_1.MetadataScanner);
+            scanner.scan((0, decorators_1.getClientControllerRegistry)(resourceName));
+            logger_1.loggers.bootstrap.info(`Resource "${resourceName}" controllers registered`);
+            return;
+        }
+        // If trying to initialize CORE mode twice, throw error
+        throw new Error(`Client already initialized in ${existingContext.mode} mode by resource "${existingContext.resourceName}". Cannot initialize again in ${mode} mode.`);
+    }
+    // Set runtime context
+    (0, client_runtime_1.setClientRuntimeContext)({
+        mode,
+        resourceName,
+        isInitialized: true,
+    });
+    // Register client-side adapters (IPedAppearanceClient, IHasher)
+    await (0, register_client_capabilities_1.registerClientCapabilities)();
+    // Register all services in DI (available in all modes)
+    registerServices();
+    // Bootstrap services (only in CORE mode)
+    // This is where services that register global event handlers are initialized
+    await bootstrapServices(mode);
+    // Player loader (only in CORE mode)
+    if (mode === 'CORE') {
+        (0, player_loader_1.playerClientLoader)();
+    }
+    // Import framework controllers (only in CORE mode)
+    // These controllers listen to global events and should only be registered once
+    if (mode === 'CORE') {
+        await Promise.resolve().then(() => __importStar(require('./controllers/spawner.controller')));
+        await Promise.resolve().then(() => __importStar(require('./controllers/appearance.controller')));
+        await Promise.resolve().then(() => __importStar(require('./controllers/player-sync.controller')));
+    }
+    // Scan and register controllers
+    const scanner = client_container_1.di.resolve(metadata_scanner_1.MetadataScanner);
+    scanner.scan((0, decorators_1.getClientControllerRegistry)(resourceName));
+    logger_1.loggers.bootstrap.info(`Client initialized in ${mode} mode`, { resourceName });
+}

package/dist/runtime/client/client-core.d.ts

@@ -0,0 +1,19 @@
+import { ClientInitOptions } from './client-runtime';
+/**
+ * Initialize the OpenCore client framework
+ *
+ * @param options - Client initialization options
+ *
+ * @example
+ * ```ts
+ * // Core resource (initializes all services)
+ * await Client.init({ mode: 'CORE' })
+ *
+ * // Resource mode (only registers controllers)
+ * await Client.init({ mode: 'RESOURCE' })
+ *
+ * // Standalone mode (only registers controllers)
+ * await Client.init({ mode: 'STANDALONE' })
+ * ```
+ */
+export declare function init(options?: ClientInitOptions): Promise<void>;