@nice2dev/game-engine 0.1.0

package/dist/types/legendary/index.d.ts

@@ -0,0 +1,57 @@
+export { I18nManager, getI18n, initI18n, t, registerEngineTranslations, ENGINE_TRANSLATIONS_EN, ENGINE_TRANSLATIONS_PL, ENGINE_TRANSLATIONS_DE, SUPPORTED_LOCALES, LOCALE_NAMES, RTL_LOCALES, } from '../i18n/I18n';
+export type { Locale, TranslationDict, TranslationNamespace, InterpolationValues, PluralCategory, PluralRule, I18nConfig, } from '../i18n/I18n';
+export { TutorialEngine, getBuiltInTutorials, TUTORIAL_FIRST_GAME, TUTORIAL_SPACE_SHOOTER, TUTORIAL_DATAGRID_BASICS, } from '../tutorials/TutorialEngine';
+export type { TutorialStepType, TutorialDifficulty, TutorialCategory, QuizOption, CodeValidation, TutorialStep, TutorialDefinition, TutorialProgress, TutorialEvents, CodeValidatorFn, } from '../tutorials/TutorialEngine';
+export { useTranslation, I18nProvider, TranslatedText, LocaleSelect, } from '../i18n/useTranslation';
+export type { UseTranslationResult } from '../i18n/useTranslation';
+export { KidModeManager, DEFAULT_KID_MODE_CONFIG, KID_DIFFICULTY_PRESETS, VISUAL_BLOCKS, KID_BADGES, KID_SPRITES, } from '../kids/KidMode';
+export type { AgeGroup, KidDifficulty, BlockCategory, VisualBlock, BlockParam, KidSprite, KidBadge, BadgeCondition, KidProfile, ParentConfig, ClassroomConfig, KidModeConfig, KidDifficultySettings, } from '../kids/KidMode';
+export { getEngineError, formatEngineError, throwEngineError, warnEngine, searchAPIHints, API_HINTS, createPerfDashboard, recordPerfSnapshot, getAverageFPS, getPerfSummary, runHealthCheck, renderDebugOverlay, DEFAULT_DEBUG_OVERLAY, QUICK_START_TEMPLATES, } from '../devtools/DeveloperExperience';
+export type { EngineError, APIHint, PerfSnapshot, PerfDashboard, HealthCheckResult, DebugOverlayConfig, QuickStartTemplate, } from '../devtools/DeveloperExperience';
+export { TUTORIAL_ANIMATIONS, TUTORIAL_TILEMAPS, TUTORIAL_VISUAL_SCRIPTING, TUTORIAL_LOCAL_MULTIPLAYER, getTutorials_T05_T08, } from '../tutorials/content/Tutorials_T05_T08';
+export { clamp, clampPositive, assertFinite, assertPositive, assertNonNegative, assertInRange, assertNonEmpty, assertCanvasElement, validateGameSettings, validatePhysicsSettings, } from '../core/Validation';
+export type { ValidationResult } from '../core/Validation';
+export { PluginManager, PluginMarketplace, PLUGIN_TEMPLATES, } from '../plugins/PluginSDK';
+export type { PluginState, PluginType, PluginManifest, PluginContext, PluginDefinition, ExtensionPoint, PluginStorage, PluginInstance, PluginTemplate, MarketplaceEntry, MarketplaceSearchResult, } from '../plugins/PluginSDK';
+export { TestPluginStorage, TestPluginContext, PluginAssertionError, pluginAssert, PluginTestRunner, createTestManifest, testPluginLifecycle, formatTestResults, } from '../plugins/PluginTestKit';
+export type { TestStatus, TestResult, TestSuiteResult, PluginTestCase, } from '../plugins/PluginTestKit';
+export { TUTORIAL_MULTIPLAYER_ONLINE, TUTORIAL_PROCEDURAL_WORLD, TUTORIAL_PLATFORMER, getTutorials_T09_T11, } from '../tutorials/content/Tutorials_T09_T11';
+export { TUTORIAL_RPG, TUTORIAL_TOWER_DEFENSE, TUTORIAL_3D_GAME, TUTORIAL_PUBLISHING, getTutorials_T12_T15, } from '../tutorials/content/Tutorials_T12_T15';
+export { FrameBudgetManager, MemoryLeakDetector, AutoLODManager, WorkerPool, PerfTimer, ObjectPool, QUALITY_PRESETS, } from '../performance/PerformanceAdvanced';
+export type { FrameBudgetConfig, BudgetReport, FrameBudgetSnapshot, MemoryTracker, MemorySnapshot, LeakSuspect, QualityLevel, AutoLODConfig, QualitySettings, WorkerTaskStatus, WorkerTask, WorkerPoolConfig, } from '../performance/PerformanceAdvanced';
+export { TutorialOverlay } from '../tutorials/TutorialOverlay';
+export type { OverlayConfig, TooltipPosition, OverlayAction, } from '../tutorials/TutorialOverlay';
+export { DocRegistry, DOCS_ECS, DOCS_RENDERING, } from '../docs/DocGenerator';
+export type { DocCategory, DocMemberKind, DocParam, DocMember, DocModule, DocSearchResult, } from '../docs/DocGenerator';
+export { BranchingEngine, AchievementEngine, BUILT_IN_ACHIEVEMENTS, } from '../tutorials/TutorialBranching';
+export type { BranchConditionType, BranchCondition, BranchRule, BranchingStep, BranchingConfig, BranchContext, AchievementTier, AchievementCondition, AchievementDefinition, AchievementProgress, } from '../tutorials/TutorialBranching';
+export { HotModuleReplacer, AssetPipeline, DeployManager, CollaborationManager, } from '../devtools/DevTools';
+export type { HMRModule, HMRUpdate, AssetType, AssetMeta, AssetProcessorOptions, DeployTarget, DeployConfig, DeployResult, CollaboratorCursor, } from '../devtools/DevTools';
+export { GuidedWizard, BlockEditor, KID_BLOCK_PALETTES, } from '../kids/KidTools';
+export type { WizardChoice, WizardStep, WizardResult, BlockShape, DragBlock, BlockPalette, DragDropState, } from '../kids/KidTools';
+export { BenchmarkRunner, BUILTIN_BENCHMARKS, } from '../performance/BenchmarkSuite';
+export type { BenchmarkScenario, BenchmarkTimings, BenchmarkMemory, BenchmarkResult, BenchmarkReport, RegressionResult, } from '../performance/BenchmarkSuite';
+export type { BuiltInComponentType, ComponentTypeMap, AnyBuiltInComponent, EngineEventName, EngineEventMap, TimeDelta, StrictRecord, JsonValue, EventCallback, StrictPartial, AtLeastOne, } from '../core/TypeSafety';
+export { isVec2, isVec3, isRect, isColor, isComponent, isEntityId, isComponentOfType, getTypedComponent, requireComponent, assertNever, } from '../core/TypeSafety';
+export { NiceTutorialEditor } from '../tutorials/TutorialEditor';
+export type { TutorialEditorStep, TutorialEditorState } from '../tutorials/TutorialEditor';
+export { TUTORIAL_SOUNDS_AND_MUSIC } from '../tutorials/content/Tutorials_T04';
+export { TUTORIAL_UI_DATAGRID, TUTORIAL_UI_FORM, TUTORIAL_UI_CHART, TUTORIAL_UI_TREEVIEW, TUTORIAL_UI_SCHEDULER, TUTORIAL_UI_GANTT, TUTORIAL_UI_PIVOTGRID, TUTORIAL_UI_HTMLEDITOR, TUTORIAL_UI_NAVIGATION, TUTORIAL_UI_OVERLAYS, TUTORIAL_UI_THEMES, TUTORIAL_UI_RESPONSIVE, getAllUITutorials, } from '../tutorials/content/UITutorials';
+export { VoiceNarrator, useVoiceNarration } from '../tutorials/VoiceNarration';
+export type { VoiceNarrationConfig, NarrationEvent } from '../tutorials/VoiceNarration';
+export { AssetStore, BUILTIN_FREE_ASSETS, compareProjects, formatDiff, PluginMarketplaceUI, } from '../devtools/AssetStore';
+export type { AssetCategory, StoreAsset, StoreSearchParams, StoreSearchResult, ProjectDiff, } from '../devtools/AssetStore';
+export { NiceAPIPlayground, PLAYGROUND_EXAMPLES } from '../docs/APIPlayground';
+export type { PlaygroundExample } from '../docs/APIPlayground';
+export { COOKBOOK_RECIPES, searchRecipes, getRecipesByCategory, getRecipeCategories, } from '../docs/Cookbook';
+export type { Recipe, RecipeCategory } from '../docs/Cookbook';
+export { GUIDE_ARCHITECTURE, GUIDE_MIGRATION, GUIDE_PERFORMANCE, GUIDE_TROUBLESHOOTING, ALL_GUIDES, getGuide, searchGuides, } from '../docs/Guides';
+export type { Guide, GuideSection } from '../docs/Guides';
+export { WebGPUContext, GPUPhysicsBroadphase, GPUParticleSystem, GPUPathfinder, isWebGPUAvailable, getWebGPUShaders, } from '../performance/WebGPUCompute';
+export type { WebGPUConfig, ComputeBuffer, ComputePipeline, PhysicsBroadphaseResult, } from '../performance/WebGPUCompute';
+export { WASMAccelerator, benchmarkWASMvsJS, } from '../performance/WASMModules';
+export type { WASMModuleConfig, WASMExports, CollisionResult, PathResult, } from '../performance/WASMModules';
+export { TextureCompressor, AudioCompressor, MeshCompressor, AssetStreamer, AssetPipeline as CompressionPipeline, } from '../performance/AssetCompression';
+export type { TextureCompressionConfig, AudioCompressionConfig, MeshCompressionConfig, StreamingConfig, AssetManifest, AssetEntry, CompressionStats, } from '../performance/AssetCompression';
+export { generateContributing, generateCodeOfConduct, GameJamPlatform, ShowcaseGallery, CERTIFICATION_LEVELS, checkCertification, SECURITY_AUDIT_CHECKLIST, runSecurityAudit, generateGitHubActionsCI, V2_ROADMAP, getRoadmapByMilestone, getRoadmapProgress, } from '../community/Community';
+export type { CommunityConfig, GameJamEntry, ShowcaseProject, CertificationLevel, SecurityCheckItem, RoadmapItem, } from '../community/Community';

package/dist/types/monetization/Monetization.d.ts

@@ -0,0 +1,224 @@
+export type ProductType = 'consumable' | 'non-consumable' | 'subscription';
+export type SubscriptionPeriod = 'weekly' | 'monthly' | 'quarterly' | 'yearly';
+export interface IAPProduct {
+    id: string;
+    name: string;
+    description: string;
+    type: ProductType;
+    price: number;
+    currency: string;
+    storeProductId: string;
+    icon?: string;
+    category: string;
+    subscriptionPeriod?: SubscriptionPeriod;
+    trialDays?: number;
+    contents: IAPContent[];
+}
+export interface IAPContent {
+    type: 'currency' | 'item' | 'bundle' | 'cosmetic' | 'boost' | 'unlock';
+    itemId: string;
+    amount: number;
+}
+export type PurchaseState = 'pending' | 'purchased' | 'failed' | 'refunded' | 'cancelled';
+export interface PurchaseRecord {
+    id: string;
+    productId: string;
+    userId: string;
+    state: PurchaseState;
+    platform: 'ios' | 'android' | 'web' | 'steam';
+    transactionId: string;
+    purchaseDate: number;
+    expiresAt?: number;
+    receipt?: string;
+    verified: boolean;
+}
+export interface IAPStore {
+    products: IAPProduct[];
+    purchaseHistory: PurchaseRecord[];
+}
+export declare function getActiveSubscriptions(store: IAPStore, now: number): PurchaseRecord[];
+export declare function hasProduct(store: IAPStore, productId: string): boolean;
+export interface VirtualCurrency {
+    id: string;
+    name: string;
+    icon: string;
+    soft: boolean;
+    maxBalance: number;
+}
+export interface WalletEntry {
+    currencyId: string;
+    balance: number;
+}
+export interface Wallet {
+    userId: string;
+    entries: WalletEntry[];
+}
+export declare function getBalance(wallet: Wallet, currencyId: string): number;
+export declare function modifyBalance(wallet: Wallet, currencyId: string, amount: number, maxBalance?: number): boolean;
+export type AnalyticsEventType = 'session_start' | 'session_end' | 'level_start' | 'level_complete' | 'level_fail' | 'purchase' | 'ad_watched' | 'tutorial_step' | 'achievement' | 'custom';
+export interface AnalyticsEvent {
+    type: AnalyticsEventType;
+    name: string;
+    timestamp: number;
+    sessionId: string;
+    userId?: string;
+    params: Record<string, string | number | boolean>;
+}
+export interface AnalyticsConfig {
+    enabled: boolean;
+    providers: AnalyticsProvider[];
+    batchSize: number;
+    flushInterval: number;
+    sampleRate: number;
+    respectDNT: boolean;
+    anonymizeIP: boolean;
+    retentionDays: number;
+    customDimensions: string[];
+}
+export interface AnalyticsProvider {
+    name: string;
+    apiKey: string;
+    endpoint: string;
+    enabled: boolean;
+}
+export declare class AnalyticsBuffer {
+    private events;
+    private config;
+    private flushCallback;
+    constructor(config: AnalyticsConfig);
+    onFlush(callback: (events: AnalyticsEvent[]) => void): void;
+    track(type: AnalyticsEventType, name: string, params?: Record<string, string | number | boolean>): void;
+    flush(): void;
+    getBufferSize(): number;
+}
+export interface ABTest {
+    id: string;
+    name: string;
+    description: string;
+    variants: ABVariant[];
+    startDate: number;
+    endDate?: number;
+    targetAudience: string;
+    status: 'draft' | 'running' | 'paused' | 'completed';
+    winnerVariant?: string;
+}
+export interface ABVariant {
+    id: string;
+    name: string;
+    weight: number;
+    config: Record<string, unknown>;
+}
+export interface ABAssignment {
+    testId: string;
+    variantId: string;
+    userId: string;
+    assignedAt: number;
+}
+/** Deterministic assignment based on userId hash. */
+export declare function assignVariant(test: ABTest, userId: string): ABVariant;
+export type LeaderboardSort = 'highest' | 'lowest' | 'latest';
+export type LeaderboardPeriod = 'alltime' | 'daily' | 'weekly' | 'monthly' | 'seasonal';
+export interface LeaderboardDef {
+    id: string;
+    name: string;
+    sort: LeaderboardSort;
+    period: LeaderboardPeriod;
+    maxEntries: number;
+    scoreFormat: 'integer' | 'decimal' | 'time' | 'custom';
+    metadata: string[];
+    antiCheat: LeaderboardAntiCheat;
+}
+export interface LeaderboardAntiCheat {
+    maxScorePerSubmission: number;
+    maxSubmissionsPerDay: number;
+    requireServerValidation: boolean;
+    banThreshold: number;
+}
+export interface LeaderboardEntry {
+    rank: number;
+    userId: string;
+    displayName: string;
+    score: number;
+    metadata: Record<string, string | number>;
+    submittedAt: number;
+    verified: boolean;
+}
+export interface LeaderboardPage {
+    leaderboardId: string;
+    entries: LeaderboardEntry[];
+    total: number;
+    page: number;
+    pageSize: number;
+    userEntry?: LeaderboardEntry;
+}
+export declare function insertScore(entries: LeaderboardEntry[], newEntry: LeaderboardEntry, sort: LeaderboardSort, maxEntries: number): LeaderboardEntry[];
+export declare function formatLeaderboardScore(score: number, format: LeaderboardDef['scoreFormat']): string;
+export interface CloudSaveConfig {
+    provider: 'firebase' | 'aws' | 'azure' | 'custom';
+    autoSync: boolean;
+    syncInterval: number;
+    maxSaveSlots: number;
+    maxSaveSize: number;
+    compression: boolean;
+    encryption: boolean;
+    conflictResolution: 'latest' | 'largest' | 'manual';
+}
+export interface CloudSaveSlot {
+    slotId: number;
+    userId: string;
+    name: string;
+    data: string;
+    checksum: string;
+    createdAt: number;
+    updatedAt: number;
+    size: number;
+    version: number;
+    metadata: Record<string, string>;
+    thumbnail?: string;
+}
+export interface CloudSyncResult {
+    success: boolean;
+    slot: CloudSaveSlot;
+    conflict: boolean;
+    localVersion: number;
+    remoteVersion: number;
+    resolution?: 'local' | 'remote' | 'merged';
+}
+/** Simple checksum for save integrity. */
+export declare function computeChecksum(data: string): string;
+export interface AchievementDef {
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+    lockedIcon: string;
+    category: string;
+    points: number;
+    hidden: boolean;
+    progressive: boolean;
+    maxProgress?: number;
+    reward?: {
+        type: string;
+        amount: number;
+        itemId?: string;
+    };
+    prerequisites?: string[];
+}
+export interface AchievementProgress {
+    achievementId: string;
+    unlocked: boolean;
+    progress: number;
+    unlockedAt?: number;
+}
+export declare class AchievementTracker {
+    private definitions;
+    private progress;
+    registerAchievement(def: AchievementDef): void;
+    incrementProgress(achievementId: string, amount?: number): boolean;
+    unlock(achievementId: string): boolean;
+    isUnlocked(achievementId: string): boolean;
+    getProgress(achievementId: string): AchievementProgress | undefined;
+    getUnlockedCount(): number;
+    getTotalPoints(): number;
+    getAllProgress(): AchievementProgress[];
+}

package/dist/types/monetization/index.d.ts

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

package/dist/types/multiplayer/LocalMultiplayer.d.ts

@@ -0,0 +1,61 @@
+import type { Color, ScreenMode, PlayerConfig, Rect } from '../core/types';
+import { EventBus } from '../core/EventBus';
+export interface Player {
+    index: number;
+    name: string;
+    color: Color;
+    inputDevice: 'keyboard' | 'gamepad';
+    gamepadIndex: number;
+    score: number;
+    lives: number;
+    active: boolean;
+    /** Entity ID of the player character in the world. */
+    entityId: number | null;
+}
+export declare class PlayerManager {
+    readonly events: EventBus;
+    readonly maxPlayers: number;
+    private players;
+    constructor(maxPlayers?: number);
+    get activeCount(): number;
+    getPlayer(index: number): Player | undefined;
+    get allPlayers(): Player[];
+    get activePlayers(): Player[];
+    join(config: PlayerConfig): Player | null;
+    leave(index: number): void;
+    /** Quick setup for single player (keyboard). */
+    setupSingle(): Player;
+    /** Quick setup for local multiplayer. */
+    setupLocal(count: number): Player[];
+    clear(): void;
+}
+export interface Viewport {
+    playerIndex: number;
+    rect: Rect;
+    pixelRect: Rect;
+}
+export declare class SplitScreenManager {
+    private _mode;
+    private _canvasWidth;
+    private _canvasHeight;
+    private viewports;
+    get mode(): ScreenMode;
+    /** Set screen dimensions (usually from canvas). */
+    setCanvasSize(w: number, h: number): void;
+    /** Configure split mode for N active players. */
+    configure(players: Player[], preferredMode?: ScreenMode): void;
+    private buildGrid;
+    private rebuildViewports;
+    getViewports(): Readonly<Viewport>[];
+    getViewportForPlayer(playerIndex: number): Viewport | undefined;
+    /** Apply viewport clip/transform to Canvas 2D context before rendering a player's view. */
+    applyViewport(ctx: CanvasRenderingContext2D, viewport: Viewport): void;
+    /** Restore context after rendering a viewport. */
+    restoreViewport(ctx: CanvasRenderingContext2D): void;
+    /** Render divider lines between viewports. */
+    renderDividers(ctx: CanvasRenderingContext2D, lineColor?: string, lineWidth?: number): void;
+    /** Get cols/rows for grid-based layouts. */
+    private getGridSpec;
+}
+declare const PLAYER_COLORS: Color[];
+export { PLAYER_COLORS };

package/dist/types/multiplayer/MiniGameTypes.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Mini-game types and registry for couch/online mini-game collections.
+ */
+export interface PlayerSlot {
+    index: number;
+    name: string;
+    color: string;
+    input: InputSource;
+    joined: boolean;
+    ready: boolean;
+    profilePlayerId?: number;
+}
+export type InputSource = {
+    type: "keyboard";
+    group: number;
+} | {
+    type: "gamepad";
+    padIndex: number;
+} | {
+    type: "remote";
+    windowId: string;
+};
+export declare const MINI_PLAYER_COLORS: readonly ["#e74c3c", "#3498db", "#2ecc71", "#f1c40f", "#9b59b6", "#e67e22", "#1abc9c", "#e91e63"];
+export declare const MINI_PLAYER_NAMES: readonly ["Player 1", "Player 2", "Player 3", "Player 4", "Player 5", "Player 6", "Player 7", "Player 8"];
+export type Dir = {
+    dx: number;
+    dy: number;
+};
+export declare const DIR_UP: Dir;
+export declare const DIR_DOWN: Dir;
+export declare const DIR_LEFT: Dir;
+export declare const DIR_RIGHT: Dir;
+export interface KeyboardGroup {
+    up: string;
+    down: string;
+    left: string;
+    right: string;
+    action: string;
+}
+export declare const KEYBOARD_GROUPS: KeyboardGroup[];
+export interface MiniGameMeta {
+    id: string;
+    title: string;
+    description: string;
+    minPlayers: number;
+    maxPlayers: number;
+    icon: string;
+    /** Optional tags for filtering (genre, difficulty, etc.) */
+    tags?: string[];
+}
+export type MiniGameConfig = Record<string, unknown>;
+/**
+ * GameRegistry — typed registry of available mini-games.
+ *
+ * Call `registry.register(meta)` to add games.
+ * Call `registry.all()` or `registry.find(id)` to query.
+ */
+export declare class GameRegistry {
+    private games;
+    register(meta: MiniGameMeta): void;
+    registerAll(metas: MiniGameMeta[]): void;
+    unregister(id: string): void;
+    find(id: string): MiniGameMeta | undefined;
+    all(): MiniGameMeta[];
+    filter(predicate: (m: MiniGameMeta) => boolean): MiniGameMeta[];
+    /** Games that support the given player count. */
+    forPlayerCount(n: number): MiniGameMeta[];
+}
+/** Default singleton registry */
+export declare const gameRegistry: GameRegistry;

package/dist/types/multiplayer/index.d.ts

@@ -0,0 +1,3 @@
+export { PlayerManager, SplitScreenManager, PLAYER_COLORS } from './LocalMultiplayer';
+export type { Player, Viewport } from './LocalMultiplayer';
+export { GameRegistry, gameRegistry, MINI_PLAYER_COLORS, MINI_PLAYER_NAMES, KEYBOARD_GROUPS, DIR_UP, DIR_DOWN, DIR_LEFT, DIR_RIGHT, type PlayerSlot, type InputSource, type Dir, type KeyboardGroup, type MiniGameMeta, type MiniGameConfig, } from './MiniGameTypes';

package/dist/types/network/MultiplayerTransport.d.ts

@@ -0,0 +1,71 @@
+/**
+ * MultiplayerTransport — abstract transport layer for game multiplayer.
+ *
+ * Multiple implementations can be plugged in:
+ *  - LocalTransport  (in-memory, couch co-op / testing)
+ *  - SignalRTransport (real-time via ASP.NET SignalR)
+ *  - WebRTCTransport  (peer-to-peer via PeerManager from ./network)
+ *
+ * For raw WebRTC, see PeerManager in network/Networking.ts.
+ */
+export type TransportState = "disconnected" | "connecting" | "connected" | "reconnecting";
+export interface TransportMessage {
+    type: string;
+    payload: unknown;
+    timestamp: number;
+    senderId?: string;
+}
+export interface IMultiplayerTransport {
+    readonly state: TransportState;
+    connect(url: string, options?: Record<string, unknown>): Promise<void>;
+    disconnect(): void;
+    send(msg: TransportMessage): void;
+    on(type: string, handler: (msg: TransportMessage) => void): void;
+    off(type: string, handler: (msg: TransportMessage) => void): void;
+    onStateChange(handler: (state: TransportState) => void): void;
+}
+export declare class LocalTransport implements IMultiplayerTransport {
+    state: TransportState;
+    private bus;
+    private stateListeners;
+    connect(): Promise<void>;
+    disconnect(): void;
+    send(msg: TransportMessage): void;
+    on(type: string, handler: (msg: TransportMessage) => void): void;
+    off(type: string, handler: (msg: TransportMessage) => void): void;
+    onStateChange(handler: (state: TransportState) => void): void;
+    private setState;
+}
+/**
+ * SignalR-based transport.
+ *
+ * Requires `@microsoft/signalr` to be installed as a peer dependency.
+ * Connection is established to `url` (e.g. `/hubs/game`).
+ *
+ * Hub server methods expected:
+ *   CreateRoom, JoinRoom, LeaveRoom, SendGameMessage,
+ *   StartMatchmaking, CancelMatchmaking
+ *
+ * Client-invoked events:
+ *   GameMessage, RoomJoined, RoomLeft, PlayerJoined, PlayerLeft,
+ *   MatchFound, Error
+ */
+export declare class SignalRTransport implements IMultiplayerTransport {
+    state: TransportState;
+    private connection;
+    private bus;
+    private stateListeners;
+    private tokenFactory?;
+    constructor(options?: {
+        accessTokenFactory?: () => string | Promise<string>;
+    });
+    connect(url: string): Promise<void>;
+    disconnect(): void;
+    send(msg: TransportMessage): void;
+    /** Hub server invocations */
+    invoke(method: string, ...args: unknown[]): Promise<unknown>;
+    on(type: string, handler: (msg: TransportMessage) => void): void;
+    off(type: string, handler: (msg: TransportMessage) => void): void;
+    onStateChange(handler: (state: TransportState) => void): void;
+    private setState;
+}