@nice2dev/game-engine 1.1.5 → 1.1.7

package/dist/types/systems/NiceAnimation.d.ts

@@ -0,0 +1,350 @@
+/**
+ * NiceAnimation - Game Engine Animation System
+ *
+ * Comprehensive animation system supporting:
+ * - Sprite/frame animations
+ * - Skeletal animations
+ * - Animation blending
+ * - Animation state machines
+ * - Animation events and callbacks
+ * - Animation layers with weights
+ * - IK (Inverse Kinematics) support
+ * - Animation compression and optimization
+ *
+ * @packageDocumentation
+ */
+import { EventEmitter } from 'events';
+export type AnimationId = string;
+export type ClipId = string;
+export type TrackId = string;
+export type BoneId = string;
+export type LayerId = string;
+export type StateId = string;
+export type PlaybackState = 'stopped' | 'playing' | 'paused';
+export type LoopType = 'none' | 'loop' | 'pingpong' | 'clamp-forever';
+export type BlendMode = 'override' | 'additive' | 'multiply';
+export interface Vec2 {
+    x: number;
+    y: number;
+}
+export interface Vec3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface Quaternion {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+}
+export interface Transform {
+    position: Vec3;
+    rotation: Quaternion;
+    scale: Vec3;
+}
+export interface Keyframe<T = number> {
+    time: number;
+    value: T;
+    inTangent?: T;
+    outTangent?: T;
+    interpolation?: 'linear' | 'step' | 'bezier' | 'hermite';
+}
+export interface AnimationTrack<T = number> {
+    id: TrackId;
+    property: string;
+    target?: string;
+    keyframes: Keyframe<T>[];
+}
+export interface AnimationClip {
+    id: ClipId;
+    name: string;
+    duration: number;
+    frameRate: number;
+    loopType: LoopType;
+    tracks: AnimationTrack[];
+    events?: AnimationEvent[];
+    tags?: string[];
+}
+export interface AnimationEvent {
+    time: number;
+    name: string;
+    data?: Record<string, unknown>;
+}
+export interface SpriteFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    pivotX?: number;
+    pivotY?: number;
+    duration?: number;
+}
+export interface SpriteSheet {
+    id: string;
+    imageUrl: string;
+    frameWidth: number;
+    frameHeight: number;
+    frames: SpriteFrame[];
+    animations: SpriteAnimation[];
+}
+export interface SpriteAnimation {
+    id: AnimationId;
+    name: string;
+    frames: number[];
+    frameRate: number;
+    loopType: LoopType;
+    events?: AnimationEvent[];
+}
+export interface Bone {
+    id: BoneId;
+    name: string;
+    parentId?: BoneId;
+    localTransform: Transform;
+    bindPose: Transform;
+    length?: number;
+    children: BoneId[];
+}
+export interface Skeleton {
+    id: string;
+    name: string;
+    bones: Map<BoneId, Bone>;
+    rootBoneId: BoneId;
+}
+export interface BoneAnimation {
+    boneId: BoneId;
+    positionTrack?: AnimationTrack<Vec3>;
+    rotationTrack?: AnimationTrack<Quaternion>;
+    scaleTrack?: AnimationTrack<Vec3>;
+}
+export interface SkeletalClip extends AnimationClip {
+    skeletonId: string;
+    boneAnimations: BoneAnimation[];
+}
+export interface AnimationLayer {
+    id: LayerId;
+    name: string;
+    weight: number;
+    blendMode: BlendMode;
+    mask?: Set<BoneId>;
+    currentClip?: ClipId;
+    currentTime: number;
+    speed: number;
+    state: PlaybackState;
+}
+export interface BlendNode {
+    type: 'clip' | 'blend1d' | 'blend2d' | 'additive';
+    clipId?: ClipId;
+    param?: string;
+    children?: BlendNode[];
+    weights?: number[];
+    thresholds?: number[];
+}
+export interface AnimationBlendTree {
+    id: string;
+    name: string;
+    parameters: Map<string, number>;
+    root: BlendNode;
+}
+export interface AnimatorCondition {
+    parameter: string;
+    mode: 'greater' | 'less' | 'equals' | 'notEquals' | 'true' | 'false';
+    value?: number | boolean;
+}
+export interface AnimatorTransition {
+    from: StateId;
+    to: StateId;
+    conditions: AnimatorCondition[];
+    exitTime?: number;
+    hasExitTime: boolean;
+    blendDuration: number;
+    offset?: number;
+}
+export interface AnimatorState {
+    id: StateId;
+    name: string;
+    clipId?: ClipId;
+    blendTree?: AnimationBlendTree;
+    speed: number;
+    speedParameter?: string;
+    mirror?: boolean;
+    events?: AnimationEvent[];
+}
+export interface AnimatorStateMachine {
+    id: string;
+    name: string;
+    states: Map<StateId, AnimatorState>;
+    transitions: AnimatorTransition[];
+    entryState: StateId;
+    anyStateTransitions: AnimatorTransition[];
+    parameters: Map<string, number | boolean>;
+    subMachines?: Map<StateId, AnimatorStateMachine>;
+}
+export interface IKTarget {
+    boneId: BoneId;
+    position: Vec3;
+    weight: number;
+    hintPosition?: Vec3;
+    iterations?: number;
+}
+export interface IKChain {
+    id: string;
+    name: string;
+    endBoneId: BoneId;
+    chainLength: number;
+    target?: IKTarget;
+}
+export interface AnimationInstance {
+    id: string;
+    clipId: ClipId;
+    currentTime: number;
+    speed: number;
+    state: PlaybackState;
+    loop: LoopType;
+    weight: number;
+    blendMode: BlendMode;
+    startTime?: number;
+    endTime?: number;
+    pingPongDirection?: 1 | -1;
+}
+export interface AnimatorInstance {
+    id: string;
+    stateMachineId: string;
+    currentState: StateId;
+    previousState?: StateId;
+    transitionProgress: number;
+    isTransitioning: boolean;
+    parameters: Map<string, number | boolean>;
+    layers: AnimationLayer[];
+}
+export type AnimationEventType = 'started' | 'stopped' | 'paused' | 'resumed' | 'completed' | 'looped' | 'event' | 'transition-start' | 'transition-end' | 'state-enter' | 'state-exit';
+export interface AnimationSystemEvent {
+    type: AnimationEventType;
+    animationId?: AnimationId;
+    clipId?: ClipId;
+    stateId?: StateId;
+    eventName?: string;
+    eventData?: Record<string, unknown>;
+    time: number;
+}
+export type AnimationEventCallback = (event: AnimationSystemEvent) => void;
+export interface AnimationConfig {
+    defaultFrameRate: number;
+    defaultBlendDuration: number;
+    maxLayers: number;
+    ikIterations: number;
+    enableCompression: boolean;
+    compressionThreshold: number;
+    enableCaching: boolean;
+    cacheSize: number;
+}
+export declare const DEFAULT_ANIMATION_CONFIG: AnimationConfig;
+export declare class NiceAnimation extends EventEmitter {
+    private config;
+    private clips;
+    private spriteSheets;
+    private skeletons;
+    private stateMachines;
+    private blendTrees;
+    private instances;
+    private animatorInstances;
+    private ikChains;
+    private evaluationCache;
+    private destroyed;
+    constructor(config?: Partial<AnimationConfig>);
+    registerClip(clip: AnimationClip): void;
+    getClip(clipId: ClipId): AnimationClip | undefined;
+    removeClip(clipId: ClipId): boolean;
+    createClip(id: ClipId, name: string, duration: number, frameRate?: number): AnimationClip;
+    addTrack<T>(clipId: ClipId, track: AnimationTrack<T>): void;
+    addKeyframe<T>(clipId: ClipId, trackId: TrackId, keyframe: Keyframe<T>): void;
+    addAnimationEvent(clipId: ClipId, time: number, name: string, data?: Record<string, unknown>): void;
+    registerSpriteSheet(sheet: SpriteSheet): void;
+    getSpriteSheet(id: string): SpriteSheet | undefined;
+    getSpriteFrame(sheetId: string, frameIndex: number): SpriteFrame | undefined;
+    registerSkeleton(skeleton: Skeleton): void;
+    getSkeleton(id: string): Skeleton | undefined;
+    createBone(skeletonId: string, id: BoneId, name: string, parentId?: BoneId): Bone | undefined;
+    getBoneWorldTransform(skeletonId: string, boneId: BoneId): Transform | undefined;
+    private multiplyQuaternions;
+    play(animationId: string, clipId: ClipId, options?: {
+        speed?: number;
+        loop?: LoopType;
+        startTime?: number;
+        endTime?: number;
+        weight?: number;
+        blendMode?: BlendMode;
+    }): AnimationInstance;
+    stop(animationId: string): void;
+    pause(animationId: string): void;
+    resume(animationId: string): void;
+    setSpeed(animationId: string, speed: number): void;
+    setWeight(animationId: string, weight: number): void;
+    seek(animationId: string, time: number): void;
+    getInstance(animationId: string): AnimationInstance | undefined;
+    removeInstance(animationId: string): void;
+    evaluateTrack<T>(track: AnimationTrack<T>, time: number): T | undefined;
+    private interpolateValue;
+    private isVec3;
+    private isQuaternion;
+    evaluateClip(clipId: ClipId, time: number): Map<string, unknown>;
+    registerStateMachine(stateMachine: AnimatorStateMachine): void;
+    createAnimatorInstance(instanceId: string, stateMachineId: string): AnimatorInstance;
+    setAnimatorParameter(instanceId: string, parameter: string, value: number | boolean): void;
+    getAnimatorParameter(instanceId: string, parameter: string): number | boolean | undefined;
+    private checkTransitionConditions;
+    registerIKChain(chain: IKChain): void;
+    setIKTarget(chainId: string, position: Vec3, weight?: number): void;
+    solveIK(skeletonId: string, chainId: string): void;
+    private normalizeVec3;
+    update(deltaTime: number): void;
+    private updateAnimator;
+    private startTransition;
+    private completeTransition;
+    registerBlendTree(tree: AnimationBlendTree): void;
+    evaluateBlendTree(treeId: string, parameters: Map<string, number>): Map<ClipId, number>;
+    private evaluateBlendNode;
+    private calculate1DBlendWeights;
+    getAllInstances(): AnimationInstance[];
+    getPlayingInstances(): AnimationInstance[];
+    stopAll(): void;
+    pauseAll(): void;
+    resumeAll(): void;
+    clearCache(): void;
+    getStats(): {
+        clips: number;
+        spriteSheets: number;
+        skeletons: number;
+        stateMachines: number;
+        instances: number;
+        animatorInstances: number;
+        cacheSize: number;
+    };
+    on(event: 'animation', callback: AnimationEventCallback): this;
+    off(event: 'animation', callback: AnimationEventCallback): this;
+    destroy(): void;
+}
+export declare function createAnimationSystem(config?: Partial<AnimationConfig>): NiceAnimation;
+export declare class ClipBuilder {
+    private clip;
+    constructor(id: ClipId, name: string);
+    duration(d: number): this;
+    frameRate(fps: number): this;
+    loop(type: LoopType): this;
+    addTrack<T>(id: TrackId, property: string, keyframes: Keyframe<T>[], target?: string): this;
+    addEvent(time: number, name: string, data?: Record<string, unknown>): this;
+    build(): AnimationClip;
+}
+export declare function buildClip(id: ClipId, name: string): ClipBuilder;
+export declare class StateMachineBuilder {
+    private machine;
+    private currentStateId?;
+    constructor(id: string, name: string);
+    addParameter(name: string, defaultValue: number | boolean): this;
+    addState(id: StateId, name: string, clipId?: ClipId): this;
+    setEntryState(id: StateId): this;
+    addTransition(from: StateId, to: StateId, conditions: AnimatorCondition[], blendDuration?: number): this;
+    addAnyStateTransition(to: StateId, conditions: AnimatorCondition[], blendDuration?: number): this;
+    build(): AnimatorStateMachine;
+}
+export declare function buildStateMachine(id: string, name: string): StateMachineBuilder;

package/dist/types/systems/NiceArena.d.ts

@@ -0,0 +1,215 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type ArenaId = string;
+export type MatchId = string;
+export type TeamId = string;
+export type TournamentId = string;
+export type GameMode = 'deathmatch' | 'team_deathmatch' | 'capture_the_flag' | 'king_of_the_hill' | 'last_man_standing' | 'conquest' | 'elimination' | 'free_for_all' | 'custom';
+export interface ArenaDefinition {
+    id: ArenaId;
+    name: string;
+    description: string;
+    mapId: string;
+    minPlayers: number;
+    maxPlayers: number;
+    supportedModes: GameMode[];
+    spawnPoints: {
+        teamId?: string;
+        position: Vector3;
+    }[];
+    objectives?: ArenaObjective[];
+}
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface ArenaObjective {
+    id: string;
+    type: 'zone' | 'flag' | 'point' | 'target';
+    position: Vector3;
+    radius?: number;
+    teamId?: string;
+}
+export type MatchStatus = 'waiting' | 'countdown' | 'in_progress' | 'paused' | 'finished' | 'cancelled';
+export interface Match {
+    id: MatchId;
+    arenaId: ArenaId;
+    mode: GameMode;
+    status: MatchStatus;
+    teams: Map<TeamId, MatchTeam>;
+    participants: Map<EntityId, MatchParticipant>;
+    spectators: Set<EntityId>;
+    scores: Map<TeamId, number>;
+    settings: MatchSettings;
+    startedAt?: number;
+    endedAt?: number;
+    duration: number;
+    winnerId?: TeamId | EntityId;
+    events: MatchEvent[];
+}
+export interface MatchTeam {
+    id: TeamId;
+    name: string;
+    color: string;
+    members: Set<EntityId>;
+    score: number;
+    objective?: ObjectiveProgress;
+}
+export interface ObjectiveProgress {
+    objectiveId: string;
+    progress: number;
+    maxProgress: number;
+}
+export interface MatchParticipant {
+    entityId: EntityId;
+    teamId?: TeamId;
+    kills: number;
+    deaths: number;
+    assists: number;
+    damage: number;
+    healing: number;
+    score: number;
+    isAlive: boolean;
+    respawnAt?: number;
+    streak: number;
+}
+export interface MatchSettings {
+    timeLimit: number;
+    scoreLimit?: number;
+    respawnEnabled: boolean;
+    respawnDelay: number;
+    friendlyFire: boolean;
+    maxRounds?: number;
+    currentRound?: number;
+    teamAutoBalance: boolean;
+    allowLateJoin: boolean;
+}
+export interface MatchEvent {
+    type: string;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+export type TournamentFormat = 'single_elimination' | 'double_elimination' | 'round_robin' | 'swiss';
+export interface Tournament {
+    id: TournamentId;
+    name: string;
+    arenaId: ArenaId;
+    mode: GameMode;
+    format: TournamentFormat;
+    participants: Set<EntityId | TeamId>;
+    maxParticipants: number;
+    brackets: TournamentBracket[];
+    currentRound: number;
+    status: 'registration' | 'in_progress' | 'completed';
+    prizes: TournamentPrize[];
+    startTime?: number;
+    endTime?: number;
+}
+export interface TournamentBracket {
+    round: number;
+    matches: TournamentMatch[];
+}
+export interface TournamentMatch {
+    id: string;
+    participant1?: EntityId | TeamId;
+    participant2?: EntityId | TeamId;
+    winnerId?: EntityId | TeamId;
+    score1?: number;
+    score2?: number;
+    matchId?: MatchId;
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface TournamentPrize {
+    place: number;
+    rewards: {
+        type: string;
+        id?: string;
+        amount?: number;
+    }[];
+}
+export interface MatchmakingQueue {
+    id: string;
+    arenaId: ArenaId;
+    mode: GameMode;
+    entries: QueueEntry[];
+    settings: MatchSettings;
+}
+export interface QueueEntry {
+    entityId: EntityId;
+    teamId?: TeamId;
+    queuedAt: number;
+    rating?: number;
+}
+export type ArenaEventType = 'match-created' | 'match-started' | 'match-ended' | 'match-cancelled' | 'player-joined' | 'player-left' | 'player-killed' | 'player-respawned' | 'team-scored' | 'objective-captured' | 'round-started' | 'round-ended' | 'spectator-joined' | 'spectator-left' | 'tournament-started' | 'tournament-match-started' | 'tournament-match-ended' | 'tournament-ended' | 'queue-joined' | 'queue-left' | 'queue-popped';
+export interface ArenaEvent {
+    type: ArenaEventType;
+    matchId?: MatchId;
+    entityId?: EntityId;
+    data?: Record<string, unknown>;
+}
+export interface ArenaSystemConfig {
+    maxConcurrentMatches?: number;
+    defaultTimeLimit?: number;
+    defaultRespawnDelay?: number;
+    countdownDuration?: number;
+    minimumPlayersToStart?: number;
+    matchmakingInterval?: number;
+    ratingRange?: number;
+}
+export declare const DEFAULT_ARENA_CONFIG: ArenaSystemConfig;
+export declare class NiceArena extends EventEmitter {
+    private arenas;
+    private matches;
+    private tournaments;
+    private queues;
+    private entityToMatch;
+    private entityRatings;
+    private nextMatchId;
+    private nextTournamentId;
+    private config;
+    private matchmakingTimer?;
+    constructor(config?: Partial<ArenaSystemConfig>);
+    defineArena(arena: ArenaDefinition): void;
+    getArena(id: ArenaId): ArenaDefinition | undefined;
+    getAllArenas(): ArenaDefinition[];
+    createMatch(arenaId: ArenaId, mode: GameMode, settings?: Partial<MatchSettings>): MatchId | null;
+    private isTeamMode;
+    joinMatch(entityId: EntityId, matchId: MatchId, teamId?: TeamId): boolean;
+    leaveMatch(entityId: EntityId): boolean;
+    private getSmallestTeam;
+    private startCountdown;
+    startMatch(matchId: MatchId): void;
+    private startMatchTimer;
+    endMatch(matchId: MatchId): void;
+    private determineWinner;
+    cancelMatch(matchId: MatchId): void;
+    recordKill(matchId: MatchId, killerId: EntityId, victimId: EntityId, assistIds?: EntityId[]): void;
+    recordDamage(matchId: MatchId, attackerId: EntityId, targetId: EntityId, amount: number): void;
+    recordHealing(matchId: MatchId, healerId: EntityId, amount: number): void;
+    respawnPlayer(matchId: MatchId, entityId: EntityId): void;
+    private checkVictoryCondition;
+    captureObjective(matchId: MatchId, entityId: EntityId, objectiveId: string): void;
+    addSpectator(matchId: MatchId, entityId: EntityId): boolean;
+    removeSpectator(matchId: MatchId, entityId: EntityId): void;
+    private updateRatings;
+    getRating(entityId: EntityId): number;
+    joinQueue(entityId: EntityId, arenaId: ArenaId, mode: GameMode): boolean;
+    leaveQueue(entityId: EntityId): void;
+    private tryMatchmaking;
+    createTournament(name: string, arenaId: ArenaId, mode: GameMode, format: TournamentFormat, maxParticipants: number, prizes?: TournamentPrize[]): TournamentId;
+    registerForTournament(tournamentId: TournamentId, participantId: EntityId | TeamId): boolean;
+    startTournament(tournamentId: TournamentId): boolean;
+    private generateBrackets;
+    reportTournamentMatchResult(tournamentId: TournamentId, matchId: string, winnerId: EntityId | TeamId): void;
+    private advanceTournamentWinner;
+    private isTournamentComplete;
+    getMatch(id: MatchId): Match | undefined;
+    getEntityMatch(entityId: EntityId): Match | undefined;
+    getActiveMatches(): Match[];
+    getTournament(id: TournamentId): Tournament | undefined;
+    getActiveTournaments(): Tournament[];
+}
+export declare function createArenaSystem(config?: Partial<ArenaSystemConfig>): NiceArena;
+export declare function defineArena(options: ArenaDefinition): ArenaDefinition;
+export default NiceArena;

package/dist/types/systems/NiceAssetLoader.d.ts

@@ -0,0 +1,136 @@
+import { EventEmitter } from 'events';
+export type AssetId = string;
+export type AssetType = 'image' | 'audio' | 'json' | 'text' | 'binary' | 'spritesheet' | 'font' | 'video';
+export interface AssetDefinition {
+    id: AssetId;
+    url: string;
+    type: AssetType;
+    priority?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface LoadedAsset<T = unknown> {
+    id: AssetId;
+    type: AssetType;
+    url: string;
+    data: T;
+    size?: number;
+    loadTime: number;
+    metadata?: Record<string, unknown>;
+}
+export interface LoadProgress {
+    loaded: number;
+    total: number;
+    percent: number;
+    currentAsset?: AssetId;
+    bytesLoaded: number;
+    bytesTotal: number;
+}
+export interface AssetBundle {
+    id: string;
+    name: string;
+    assets: AssetDefinition[];
+    preload?: boolean;
+}
+export type AssetEventType = 'load-start' | 'load-progress' | 'load-complete' | 'load-error' | 'bundle-start' | 'bundle-complete' | 'cache-clear';
+export interface AssetEvent {
+    type: AssetEventType;
+    assetId?: AssetId;
+    bundleId?: string;
+    progress?: LoadProgress;
+    error?: Error;
+}
+export interface AssetLoaderConfig {
+    baseUrl?: string;
+    maxConcurrent?: number;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+    cacheEnabled?: boolean;
+    maxCacheSize?: number;
+}
+export declare const DEFAULT_ASSET_LOADER_CONFIG: AssetLoaderConfig;
+export interface AssetTypeLoader<T> {
+    type: AssetType;
+    load(url: string, onProgress?: (loaded: number, total: number) => void): Promise<T>;
+    getSize?(asset: T): number;
+}
+export declare class ImageLoader implements AssetTypeLoader<HTMLImageElement> {
+    type: AssetType;
+    load(url: string): Promise<HTMLImageElement>;
+    getSize(asset: HTMLImageElement): number;
+}
+export declare class AudioLoader implements AssetTypeLoader<HTMLAudioElement> {
+    type: AssetType;
+    load(url: string): Promise<HTMLAudioElement>;
+}
+export declare class JsonLoader implements AssetTypeLoader<unknown> {
+    type: AssetType;
+    load(url: string): Promise<unknown>;
+    getSize(asset: unknown): number;
+}
+export declare class TextLoader implements AssetTypeLoader<string> {
+    type: AssetType;
+    load(url: string): Promise<string>;
+    getSize(asset: string): number;
+}
+export declare class BinaryLoader implements AssetTypeLoader<ArrayBuffer> {
+    type: AssetType;
+    load(url: string, onProgress?: (loaded: number, total: number) => void): Promise<ArrayBuffer>;
+    getSize(asset: ArrayBuffer): number;
+}
+export interface SpritesheetFrame {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    name?: string;
+}
+export interface SpritesheetData {
+    image: HTMLImageElement;
+    frames: SpritesheetFrame[];
+    animations?: Record<string, number[]>;
+}
+export declare class SpritesheetLoader implements AssetTypeLoader<SpritesheetData> {
+    type: AssetType;
+    private imageLoader;
+    private jsonLoader;
+    load(url: string): Promise<SpritesheetData>;
+}
+export declare class NiceAssetLoader extends EventEmitter {
+    private cache;
+    private loaders;
+    private bundles;
+    private loadQueue;
+    private loading;
+    private currentCacheSize;
+    private config;
+    constructor(config?: Partial<AssetLoaderConfig>);
+    private registerDefaultLoaders;
+    registerLoader<T>(loader: AssetTypeLoader<T>): void;
+    registerBundle(bundle: AssetBundle): void;
+    getBundle(id: string): AssetBundle | undefined;
+    loadBundle(bundleId: string, onProgress?: (progress: LoadProgress) => void): Promise<Map<AssetId, LoadedAsset>>;
+    load<T>(asset: AssetDefinition): Promise<LoadedAsset<T>>;
+    private loadAsset;
+    private loadWithTimeout;
+    private resolveUrl;
+    private delay;
+    private addToCache;
+    private removeFromCache;
+    get<T>(id: AssetId): LoadedAsset<T> | undefined;
+    has(id: AssetId): boolean;
+    unload(id: AssetId): boolean;
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        count: number;
+        maxSize: number;
+    };
+    preload(assets: AssetDefinition[], onProgress?: (progress: LoadProgress) => void): Promise<Map<AssetId, LoadedAsset>>;
+    getLoadedAssets(): AssetId[];
+    getPendingLoads(): AssetId[];
+}
+export declare function createAssetLoader(config?: Partial<AssetLoaderConfig>): NiceAssetLoader;
+export declare function createAssetBundle(id: string, name: string, assets: AssetDefinition[]): AssetBundle;
+export declare function defineAsset(id: AssetId, url: string, type: AssetType, metadata?: Record<string, unknown>): AssetDefinition;
+export default NiceAssetLoader;