@open-core/framework 1.0.4-beta.1 → 1.0.5-beta.2

package/dist/adapters/node/node-player-server.d.ts

@@ -0,0 +1,45 @@
+import { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { type PlayerIdentifier } from '../contracts/types/identifier';
+/**
+ * Node.js mock implementation of server-side player operations.
+ * Used for testing and standalone mode.
+ */
+export declare class NodePlayerServer extends IPlayerServer {
+    private players;
+    private droppedPlayers;
+    getPed(playerSrc: string): number;
+    drop(playerSrc: string, _reason: string): void;
+    setModel(playerSrc: string, model: string): void;
+    getIdentifier(playerSrc: string, identifierType: string): string | undefined;
+    /**
+     * @deprecated Use getPlayerIdentifiers() for structured identifier data.
+     */
+    getIdentifiers(playerSrc: string): string[];
+    getPlayerIdentifiers(playerSrc: string): PlayerIdentifier[];
+    getNumIdentifiers(playerSrc: string): number;
+    getName(playerSrc: string): string;
+    getPing(playerSrc: string): number;
+    getEndpoint(playerSrc: string): string;
+    setDimension(playerSrc: string, bucket: number): void;
+    getDimension(playerSrc: string): number;
+    getConnectedPlayers(): string[];
+    /**
+     * Add a mock player for testing.
+     */
+    _addMockPlayer(playerSrc: string, data: {
+        ped?: number;
+        name?: string;
+        identifiers?: string[];
+        ping?: number;
+        endpoint?: string;
+        routingBucket?: number;
+    }): void;
+    /**
+     * Check if a player was dropped.
+     */
+    _wasDropped(playerSrc: string): boolean;
+    /**
+     * Clear all mock data.
+     */
+    _clear(): void;
+}

package/dist/adapters/node/node-player-server.js

@@ -0,0 +1,111 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IPlayerServer } from '../contracts/server/IPlayerServer';
+import { parseIdentifier } from '../contracts/types/identifier';
+/**
+ * Node.js mock implementation of server-side player operations.
+ * Used for testing and standalone mode.
+ */
+let NodePlayerServer = class NodePlayerServer extends IPlayerServer {
+    players = new Map();
+    droppedPlayers = [];
+    getPed(playerSrc) {
+        return this.players.get(playerSrc)?.ped ?? 0;
+    }
+    drop(playerSrc, _reason) {
+        this.droppedPlayers.push(playerSrc);
+        this.players.delete(playerSrc);
+    }
+    setModel(playerSrc, model) {
+        const player = this.players.get(playerSrc);
+        if (player) {
+            player.model = model;
+        }
+    }
+    getIdentifier(playerSrc, identifierType) {
+        const player = this.players.get(playerSrc);
+        if (!player)
+            return undefined;
+        const prefix = `${identifierType}:`;
+        return player.identifiers.find((id) => id.startsWith(prefix));
+    }
+    /**
+     * @deprecated Use getPlayerIdentifiers() for structured identifier data.
+     */
+    getIdentifiers(playerSrc) {
+        return this.players.get(playerSrc)?.identifiers ?? [];
+    }
+    getPlayerIdentifiers(playerSrc) {
+        const rawIdentifiers = this.getIdentifiers(playerSrc);
+        const identifiers = [];
+        for (const raw of rawIdentifiers) {
+            const parsed = parseIdentifier(raw);
+            if (parsed) {
+                identifiers.push(parsed);
+            }
+        }
+        return identifiers;
+    }
+    getNumIdentifiers(playerSrc) {
+        return this.players.get(playerSrc)?.identifiers.length ?? 0;
+    }
+    getName(playerSrc) {
+        return this.players.get(playerSrc)?.name ?? 'Unknown';
+    }
+    getPing(playerSrc) {
+        return this.players.get(playerSrc)?.ping ?? 0;
+    }
+    getEndpoint(playerSrc) {
+        return this.players.get(playerSrc)?.endpoint ?? '';
+    }
+    setDimension(playerSrc, bucket) {
+        const player = this.players.get(playerSrc);
+        if (player) {
+            player.routingBucket = bucket;
+        }
+    }
+    getDimension(playerSrc) {
+        return this.players.get(playerSrc)?.routingBucket ?? 0;
+    }
+    getConnectedPlayers() {
+        return Array.from(this.players.keys());
+    }
+    // ─────────────────────────────────────────────────────────────────
+    // Test Helpers
+    // ─────────────────────────────────────────────────────────────────
+    /**
+     * Add a mock player for testing.
+     */
+    _addMockPlayer(playerSrc, data) {
+        this.players.set(playerSrc, {
+            ped: data.ped ?? 0,
+            name: data.name ?? 'TestPlayer',
+            identifiers: data.identifiers ?? [],
+            ping: data.ping ?? 50,
+            endpoint: data.endpoint ?? '127.0.0.1:30120',
+            routingBucket: data.routingBucket ?? 0,
+        });
+    }
+    /**
+     * Check if a player was dropped.
+     */
+    _wasDropped(playerSrc) {
+        return this.droppedPlayers.includes(playerSrc);
+    }
+    /**
+     * Clear all mock data.
+     */
+    _clear() {
+        this.players.clear();
+        this.droppedPlayers = [];
+    }
+};
+NodePlayerServer = __decorate([
+    injectable()
+], NodePlayerServer);
+export { NodePlayerServer };

package/dist/adapters/node/node-playerinfo.d.ts

@@ -0,0 +1,6 @@
+import { Vector3 } from '../../kernel';
+import { IPlayerInfo } from '../contracts/IPlayerInfo';
+export declare class NodePlayerInfo extends IPlayerInfo {
+    getPlayerName(clientId: number): string | null;
+    getPlayerPosition(_clientId: number): Vector3;
+}

package/dist/adapters/node/node-playerinfo.js

@@ -0,0 +1,20 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IPlayerInfo } from '../contracts/IPlayerInfo';
+let NodePlayerInfo = class NodePlayerInfo extends IPlayerInfo {
+    getPlayerName(clientId) {
+        return `Player${clientId.toString()}`;
+    }
+    getPlayerPosition(_clientId) {
+        return { x: 0, y: 0, z: 0 };
+    }
+};
+NodePlayerInfo = __decorate([
+    injectable()
+], NodePlayerInfo);
+export { NodePlayerInfo };

package/dist/adapters/node/node-resourceinfo.d.ts

@@ -0,0 +1,13 @@
+import { IResourceInfo } from '../contracts/IResourceInfo';
+/**
+ * Node.js implementation of IResourceInfo.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Resource name is determined by:
+ * 1. RESOURCE_NAME environment variable
+ * 2. Fallback to 'default'
+ */
+export declare class NodeResourceInfo implements IResourceInfo {
+    getCurrentResourceName(): string;
+    getCurrentResourcePath(): string;
+}

package/dist/adapters/node/node-resourceinfo.js

@@ -0,0 +1,27 @@
+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;
+};
+import { injectable } from 'tsyringe';
+/**
+ * Node.js implementation of IResourceInfo.
+ * Suitable for testing and non-FiveM runtime environments.
+ *
+ * Resource name is determined by:
+ * 1. RESOURCE_NAME environment variable
+ * 2. Fallback to 'default'
+ */
+let NodeResourceInfo = class NodeResourceInfo {
+    getCurrentResourceName() {
+        return process.env.RESOURCE_NAME || 'default';
+    }
+    getCurrentResourcePath() {
+        return process.env.RESOURCE_PATH || process.cwd();
+    }
+};
+NodeResourceInfo = __decorate([
+    injectable()
+], NodeResourceInfo);
+export { NodeResourceInfo };

package/dist/adapters/node/node-tick.d.ts

@@ -0,0 +1,10 @@
+import { ITick } from '../contracts/ITick';
+/**
+ * Node.js implementation of ITick using setInterval.
+ * Default tick interval: 0ms (next tick via setImmediate for high frequency)
+ */
+export declare class NodeTick implements ITick {
+    private tickInterval;
+    constructor(tickInterval?: number);
+    setTick(handler: () => void | Promise<void>): void;
+}

package/dist/adapters/node/node-tick.js

@@ -0,0 +1,41 @@
+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 { injectable } from 'tsyringe';
+/**
+ * Node.js implementation of ITick using setInterval.
+ * Default tick interval: 0ms (next tick via setImmediate for high frequency)
+ */
+let NodeTick = class NodeTick {
+    tickInterval;
+    constructor(tickInterval = 0) {
+        this.tickInterval = tickInterval;
+    }
+    setTick(handler) {
+        if (this.tickInterval === 0) {
+            // High-frequency tick using setImmediate (similar to FiveM's every-frame tick)
+            const tick = async () => {
+                await handler();
+                setImmediate(tick);
+            };
+            setImmediate(tick);
+        }
+        else {
+            // Interval-based tick
+            setInterval(async () => {
+                await handler();
+            }, this.tickInterval);
+        }
+    }
+};
+NodeTick = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [Number])
+], NodeTick);
+export { NodeTick };

package/dist/adapters/node/node-vehicle-server.d.ts

@@ -0,0 +1,21 @@
+import { IVehicleServer } from '../contracts/server/IVehicleServer';
+/**
+ * Node.js mock implementation of server-side vehicle operations.
+ * Used for testing and standalone mode.
+ */
+export declare class NodeVehicleServer extends IVehicleServer {
+    private vehicles;
+    private nextHandle;
+    private nextNetworkId;
+    createServerSetter(modelHash: number, _vehicleType: string, _x: number, _y: number, _z: number, _heading: number): number;
+    getColours(handle: number): [number, number];
+    setColours(handle: number, primary: number, secondary: number): void;
+    getNumberPlateText(handle: number): string;
+    setNumberPlateText(handle: number, text: string): void;
+    setDoorsLocked(handle: number, state: number): void;
+    getNetworkIdFromEntity(handle: number): number;
+    getEntityFromNetworkId(networkId: number): number;
+    networkIdExists(networkId: number): boolean;
+    _deleteVehicle(handle: number): void;
+    _vehicleExists(handle: number): boolean;
+}

package/dist/adapters/node/node-vehicle-server.js

@@ -0,0 +1,84 @@
+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;
+};
+import { injectable } from 'tsyringe';
+import { IVehicleServer } from '../contracts/server/IVehicleServer';
+/**
+ * Node.js mock implementation of server-side vehicle operations.
+ * Used for testing and standalone mode.
+ */
+let NodeVehicleServer = class NodeVehicleServer extends IVehicleServer {
+    vehicles = new Map();
+    nextHandle = 1000;
+    nextNetworkId = 1;
+    createServerSetter(modelHash, _vehicleType, _x, _y, _z, _heading) {
+        const handle = this.nextHandle++;
+        const networkId = this.nextNetworkId++;
+        this.vehicles.set(handle, {
+            model: modelHash,
+            colors: [0, 0],
+            plate: '',
+            doorsLocked: 1,
+            networkId,
+        });
+        return handle;
+    }
+    getColours(handle) {
+        return this.vehicles.get(handle)?.colors ?? [0, 0];
+    }
+    setColours(handle, primary, secondary) {
+        const vehicle = this.vehicles.get(handle);
+        if (vehicle) {
+            vehicle.colors = [primary, secondary];
+        }
+    }
+    getNumberPlateText(handle) {
+        return this.vehicles.get(handle)?.plate ?? '';
+    }
+    setNumberPlateText(handle, text) {
+        const vehicle = this.vehicles.get(handle);
+        if (vehicle) {
+            vehicle.plate = text.substring(0, 8);
+        }
+    }
+    setDoorsLocked(handle, state) {
+        const vehicle = this.vehicles.get(handle);
+        if (vehicle) {
+            vehicle.doorsLocked = state;
+        }
+    }
+    getNetworkIdFromEntity(handle) {
+        return this.vehicles.get(handle)?.networkId ?? 0;
+    }
+    getEntityFromNetworkId(networkId) {
+        for (const [handle, vehicle] of this.vehicles) {
+            if (vehicle.networkId === networkId) {
+                return handle;
+            }
+        }
+        return 0;
+    }
+    networkIdExists(networkId) {
+        for (const vehicle of this.vehicles.values()) {
+            if (vehicle.networkId === networkId) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // Test helper: delete vehicle
+    _deleteVehicle(handle) {
+        this.vehicles.delete(handle);
+    }
+    // Test helper: check if vehicle exists
+    _vehicleExists(handle) {
+        return this.vehicles.has(handle);
+    }
+};
+NodeVehicleServer = __decorate([
+    injectable()
+], NodeVehicleServer);
+export { NodeVehicleServer };

package/dist/adapters/node/transport/adapter.d.ts

@@ -0,0 +1,10 @@
+import { MessagingTransport } from '../../contracts/transport/messaging.transport';
+import type { RuntimeContext } from '../../contracts/transport/context';
+import { NodeEvents } from './node.events';
+import { NodeRpc } from './node.rpc';
+export declare class NodeMessagingTransport extends MessagingTransport {
+    readonly context: RuntimeContext;
+    readonly events: NodeEvents;
+    readonly rpc: NodeRpc;
+    constructor(context?: RuntimeContext);
+}

package/dist/adapters/node/transport/adapter.js

@@ -0,0 +1,14 @@
+import { MessagingTransport } from '../../contracts/transport/messaging.transport';
+import { NodeEvents } from './node.events';
+import { NodeRpc } from './node.rpc';
+export class NodeMessagingTransport extends MessagingTransport {
+    context;
+    events;
+    rpc;
+    constructor(context = 'server') {
+        super();
+        this.context = context;
+        this.events = new NodeEvents();
+        this.rpc = new NodeRpc(this.context);
+    }
+}

package/dist/adapters/node/transport/node.events.d.ts

@@ -0,0 +1,14 @@
+import { EventsAPI } from '../../contracts/transport/events.api';
+import { RuntimeContext } from '../../contracts/transport/context';
+type NodeTarget = number | number[] | 'all';
+export declare class NodeEvents extends EventsAPI<RuntimeContext> {
+    private readonly emitter;
+    on(event: string, handler: (ctx: {
+        clientId?: number;
+        raw?: unknown;
+    }, ...args: any[]) => any): void;
+    emit(event: string, targetOrArg?: NodeTarget | any, ...args: any[]): void;
+    simulateClientEvent(event: string, clientId: number, ...args: any[]): void;
+    clearHandlers(): void;
+}
+export {};

package/dist/adapters/node/transport/node.events.js

@@ -0,0 +1,38 @@
+import { EventEmitter } from 'node:events';
+import { EventsAPI } from '../../contracts/transport/events.api';
+import { loggers } from '../../../kernel/logger';
+export class NodeEvents extends EventsAPI {
+    emitter = new EventEmitter();
+    on(event, handler) {
+        this.emitter.on(event, (ctx, ...args) => {
+            void Promise.resolve(handler(ctx, ...args)).catch((err) => {
+                loggers.netEvent.error(`handler error for '${event}'`, {}, err);
+            });
+        });
+    }
+    emit(event, targetOrArg, ...args) {
+        if (targetOrArg === 'all' || typeof targetOrArg === 'number' || Array.isArray(targetOrArg)) {
+            const target = (targetOrArg ?? 'all');
+            const payloadArgs = args;
+            if (target === 'all') {
+                this.emitter.emit(event, { clientId: -1, raw: -1 }, ...payloadArgs);
+                return;
+            }
+            if (Array.isArray(target)) {
+                for (const clientId of target) {
+                    this.emitter.emit(event, { clientId, raw: clientId }, ...payloadArgs);
+                }
+                return;
+            }
+            this.emitter.emit(event, { clientId: target, raw: target }, ...payloadArgs);
+            return;
+        }
+        this.emitter.emit(event, { clientId: -1, raw: -1 }, targetOrArg, ...args);
+    }
+    simulateClientEvent(event, clientId, ...args) {
+        this.emitter.emit(event, { clientId, raw: clientId }, ...args);
+    }
+    clearHandlers() {
+        this.emitter.removeAllListeners();
+    }
+}

package/dist/adapters/node/transport/node.rpc.d.ts

@@ -0,0 +1,18 @@
+import { RpcAPI } from '../../contracts/transport/rpc.api';
+import type { RuntimeContext } from '../../contracts/transport/context';
+export declare class NodeRpc<C extends RuntimeContext = RuntimeContext> extends RpcAPI<C> {
+    private readonly context;
+    private readonly handlers;
+    constructor(context: C);
+    on<TArgs extends any[], TResult>(name: string, handler: (ctx: {
+        requestId: string;
+        clientId?: number;
+        raw?: unknown;
+    }, ...args: TArgs) => TResult | Promise<TResult>): void;
+    call<TResult = unknown>(name: string, ...args: any[]): Promise<TResult>;
+    notify(name: string, ...args: any[]): Promise<void>;
+    private normalizeInvocation;
+    private isValidTarget;
+    private executeCall;
+    private executeNotify;
+}

package/dist/adapters/node/transport/node.rpc.js

@@ -0,0 +1,71 @@
+import { randomUUID } from 'node:crypto';
+import { RpcAPI } from '../../contracts/transport/rpc.api';
+export class NodeRpc extends RpcAPI {
+    context;
+    handlers = new Map();
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    on(name, handler) {
+        this.handlers.set(name, handler);
+    }
+    call(name, ...args) {
+        const { target, payload } = this.normalizeInvocation(name, 'call', args);
+        return this.executeCall(name, payload, target);
+    }
+    notify(name, ...args) {
+        const { target, payload } = this.normalizeInvocation(name, 'notify', args);
+        return this.executeNotify(name, payload, target);
+    }
+    normalizeInvocation(name, kind, args) {
+        if (this.context === 'server') {
+            if (args.length === 0) {
+                throw new Error(`NodeRpc: missing target for '${kind}' '${name}' in server context`);
+            }
+            const [target, ...payload] = args;
+            if (!this.isValidTarget(target)) {
+                throw new Error(`NodeRpc: invalid target for '${kind}' '${name}'`);
+            }
+            if (kind === 'call' && target === 'all') {
+                throw new Error(`NodeRpc: target=all is not supported for call '${name}'`);
+            }
+            return { target, payload };
+        }
+        return { target: undefined, payload: args };
+    }
+    isValidTarget(value) {
+        if (value === 'all')
+            return true;
+        if (typeof value === 'number')
+            return true;
+        if (Array.isArray(value))
+            return value.every((item) => typeof item === 'number');
+        return false;
+    }
+    async executeCall(name, payload, _target) {
+        const handler = this.handlers.get(name);
+        if (!handler) {
+            throw new Error(`NodeRpc: no handler registered for '${name}'`);
+        }
+        const requestId = randomUUID();
+        const result = await Promise.resolve(handler({
+            requestId,
+            clientId: this.context === 'server' ? undefined : undefined,
+            raw: undefined,
+        }, ...(payload ?? [])));
+        return result;
+    }
+    async executeNotify(name, payload, _target) {
+        const handler = this.handlers.get(name);
+        if (!handler) {
+            return;
+        }
+        const requestId = randomUUID();
+        await Promise.resolve(handler({
+            requestId,
+            clientId: undefined,
+            raw: undefined,
+        }, ...(payload ?? [])));
+    }
+}

package/dist/adapters/platform/index.d.ts

@@ -0,0 +1 @@
+export * from './platform-registry';

package/dist/adapters/platform/index.js

@@ -0,0 +1 @@
+export * from './platform-registry';

package/dist/adapters/platform/platform-registry.d.ts

@@ -0,0 +1,101 @@
+import type { DependencyContainer } from 'tsyringe';
+/**
+ * Platform adapter interface for registering platform-specific implementations.
+ *
+ * @remarks
+ * Each supported platform (FiveM, RageMP, alt:V, etc.) should implement this
+ * interface to provide automatic detection and dependency registration.
+ */
+export interface PlatformAdapter {
+    /**
+     * Unique platform identifier.
+     * @example 'cfx', 'ragemp', 'altv', 'node'
+     */
+    readonly name: string;
+    /**
+     * Priority for platform detection (higher = checked first).
+     * Useful when multiple platforms might match.
+     * @default 0
+     */
+    readonly priority?: number;
+    /**
+     * Detect if the current runtime is this platform.
+     * @returns true if running on this platform
+     */
+    detect(): boolean;
+    /**
+     * Register all platform-specific adapters in the DI container.
+     * @param container - The dependency injection container
+     */
+    register(container: DependencyContainer): Promise<void>;
+}
+/**
+ * Registry for platform adapters.
+ * Allows dynamic registration and detection of platforms.
+ */
+declare class PlatformRegistry {
+    private adapters;
+    private currentPlatform;
+    /**
+     * Register a platform adapter.
+     * @param adapter - Platform adapter to register
+     */
+    register(adapter: PlatformAdapter): void;
+    /**
+     * Unregister a platform adapter.
+     * @param name - Platform name to unregister
+     */
+    unregister(name: string): void;
+    /**
+     * Get all registered platform adapters.
+     */
+    getAll(): readonly PlatformAdapter[];
+    /**
+     * Get a specific platform adapter by name.
+     * @param name - Platform name
+     */
+    get(name: string): PlatformAdapter | undefined;
+    /**
+     * Detect the current platform from registered adapters.
+     * @returns The detected platform adapter or undefined
+     */
+    detect(): PlatformAdapter | undefined;
+    /**
+     * Detect and register platform capabilities in the container.
+     *
+     * @param container - DI container to register adapters in
+     * @param forcePlatform - Optional platform name to force (skip detection)
+     * @returns The registered platform adapter
+     * @throws Error if no platform is detected
+     */
+    detectAndRegister(container: DependencyContainer, forcePlatform?: string): Promise<PlatformAdapter>;
+    /**
+     * Get the currently active platform.
+     * Only available after detectAndRegister has been called.
+     */
+    getCurrent(): PlatformAdapter | null;
+    /**
+     * Check if a specific platform is currently active.
+     * @param name - Platform name to check
+     */
+    isCurrentPlatform(name: string): boolean;
+    /**
+     * Clear all registered adapters (mainly for testing).
+     */
+    clear(): void;
+}
+/**
+ * Global platform registry instance.
+ */
+export declare const platformRegistry: PlatformRegistry;
+/**
+ * Convenience function to register a platform adapter.
+ * @param adapter - Platform adapter to register
+ */
+export declare function registerPlatform(adapter: PlatformAdapter): void;
+/**
+ * Get the current platform name.
+ * @returns Platform name or 'unknown' if not detected
+ */
+export declare function getCurrentPlatformName(): string;
+export {};