@nice2dev/game-engine 1.3.13 → 1.3.14

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

@@ -1,350 +0,0 @@
-/**
- * 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

@@ -1,215 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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;