@nice2dev/game-engine 1.3.12 → 1.3.14

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

@@ -1,191 +0,0 @@
-export type PlayerId = string;
-export type LeaderboardId = string;
-export type EntryId = string;
-export type TimePeriod = 'hourly' | 'daily' | 'weekly' | 'monthly' | 'all-time';
-export interface LeaderboardEntry {
-    id: EntryId;
-    playerId: PlayerId;
-    playerName: string;
-    playerAvatar?: string;
-    score: number;
-    rank?: number;
-    timestamp: number;
-    metadata?: Record<string, unknown>;
-    /** Verified by server */
-    verified?: boolean;
-}
-export type ScoreOrder = 'ascending' | 'descending';
-export interface LeaderboardDefinition {
-    id: LeaderboardId;
-    name: string;
-    description?: string;
-    icon?: string;
-    /** Score sorting (descending = higher is better) */
-    scoreOrder: ScoreOrder;
-    /** Score format */
-    scoreFormat?: 'number' | 'time' | 'percentage' | 'custom';
-    /** Score suffix (e.g., "pts", "s") */
-    scoreSuffix?: string;
-    /** Time periods supported */
-    timePeriods: TimePeriod[];
-    /** Max entries to keep per period */
-    maxEntries: number;
-    /** Allow multiple entries per player */
-    allowMultipleEntries: boolean;
-    /** Keep only best score per player */
-    keepBestOnly: boolean;
-    /** Require verification */
-    requiresVerification: boolean;
-    /** Is public */
-    isPublic: boolean;
-    /** Tags for filtering */
-    tags: string[];
-}
-export interface PlayerProfile {
-    id: PlayerId;
-    name: string;
-    avatar?: string;
-    country?: string;
-    level?: number;
-    joinDate: number;
-    totalScore: number;
-    gamesPlayed: number;
-    bestRanks: Record<LeaderboardId, number>;
-    achievements?: string[];
-    customData?: Record<string, unknown>;
-}
-export interface LeaderboardQuery {
-    leaderboardId: LeaderboardId;
-    timePeriod?: TimePeriod;
-    /** Starting rank (1-based) */
-    startRank?: number;
-    /** Number of entries */
-    limit?: number;
-    /** Filter by country */
-    country?: string;
-    /** Filter by friends */
-    friendIds?: PlayerId[];
-    /** Include player's rank */
-    includePlayerRank?: PlayerId;
-    /** Search by name */
-    searchName?: string;
-}
-export interface LeaderboardResult {
-    leaderboardId: LeaderboardId;
-    timePeriod: TimePeriod;
-    entries: LeaderboardEntry[];
-    totalEntries: number;
-    playerEntry?: LeaderboardEntry;
-    hasMore: boolean;
-}
-export interface ScoreSubmission {
-    leaderboardId: LeaderboardId;
-    playerId: PlayerId;
-    playerName: string;
-    score: number;
-    metadata?: Record<string, unknown>;
-    /** Replay data for verification */
-    replayData?: unknown;
-}
-export interface SubmissionResult {
-    success: boolean;
-    entry?: LeaderboardEntry;
-    previousBest?: number;
-    isNewBest: boolean;
-    newRank?: number;
-    previousRank?: number;
-    error?: string;
-}
-export type LeaderboardEventType = 'score-submitted' | 'new-high-score' | 'rank-changed' | 'leaderboard-updated' | 'profile-updated' | 'sync-completed' | 'sync-failed';
-export interface LeaderboardEvent {
-    type: LeaderboardEventType;
-    timestamp: number;
-    data: unknown;
-}
-export type LeaderboardEventCallback = (event: LeaderboardEvent) => void;
-export interface LeaderboardStorage {
-    submitScore(submission: ScoreSubmission): Promise<SubmissionResult>;
-    getEntries(query: LeaderboardQuery): Promise<LeaderboardResult>;
-    getPlayerProfile(playerId: PlayerId): Promise<PlayerProfile | null>;
-    updatePlayerProfile(profile: Partial<PlayerProfile> & {
-        id: PlayerId;
-    }): Promise<boolean>;
-}
-export interface LeaderboardConfig {
-    /** Use local storage fallback */
-    useLocalStorage: boolean;
-    /** Local storage key prefix */
-    storagePrefix: string;
-    /** Auto-sync interval (ms, 0 = disabled) */
-    syncInterval: number;
-    /** Max local entries per board */
-    maxLocalEntries: number;
-    /** Remote storage adapter */
-    remoteStorage?: LeaderboardStorage;
-    /** Default time period */
-    defaultTimePeriod: TimePeriod;
-}
-export declare const DEFAULT_LEADERBOARD_CONFIG: LeaderboardConfig;
-export declare class NiceLeaderboard {
-    private config;
-    private leaderboards;
-    private entries;
-    private profiles;
-    private syncTimer?;
-    private pendingSubmissions;
-    private idCounter;
-    private eventListeners;
-    constructor(config?: Partial<LeaderboardConfig>);
-    on(event: LeaderboardEventType, callback: LeaderboardEventCallback): () => void;
-    private emit;
-    registerLeaderboard(definition: LeaderboardDefinition): void;
-    unregisterLeaderboard(leaderboardId: LeaderboardId): void;
-    getLeaderboard(leaderboardId: LeaderboardId): LeaderboardDefinition | undefined;
-    getAllLeaderboards(): LeaderboardDefinition[];
-    private getKey;
-    submitScore(submission: ScoreSubmission): Promise<SubmissionResult>;
-    private submitScoreLocal;
-    private sortEntries;
-    private assignRanks;
-    getEntries(query: LeaderboardQuery): Promise<LeaderboardResult>;
-    getEntriesLocal(query: LeaderboardQuery): LeaderboardResult;
-    getPlayerRank(leaderboardId: LeaderboardId, playerId: PlayerId, period?: TimePeriod): number | undefined;
-    getPlayerBestScore(leaderboardId: LeaderboardId, playerId: PlayerId, period?: TimePeriod): number | undefined;
-    getTopScores(leaderboardId: LeaderboardId, count?: number, period?: TimePeriod): LeaderboardEntry[];
-    getAroundPlayer(leaderboardId: LeaderboardId, playerId: PlayerId, count?: number, period?: TimePeriod): LeaderboardEntry[];
-    registerPlayer(profile: PlayerProfile): void;
-    updatePlayer(playerId: PlayerId, updates: Partial<PlayerProfile>): void;
-    getPlayer(playerId: PlayerId): PlayerProfile | undefined;
-    getPlayerFromRemote(playerId: PlayerId): Promise<PlayerProfile | null>;
-    getLeaderboardStats(leaderboardId: LeaderboardId, period?: TimePeriod): {
-        totalEntries: number;
-        averageScore: number;
-        medianScore: number;
-        topScore: number;
-        lowestScore: number;
-    } | null;
-    getPlayerStats(playerId: PlayerId): {
-        totalGames: number;
-        totalScore: number;
-        averageScore: number;
-        bestRanks: Record<LeaderboardId, number>;
-        recentScores: {
-            leaderboardId: LeaderboardId;
-            score: number;
-            rank: number;
-            timestamp: number;
-        }[];
-    };
-    resetPeriod(leaderboardId: LeaderboardId, period: TimePeriod): void;
-    private getPeriodStartTime;
-    cleanupExpiredEntries(): void;
-    private startSync;
-    sync(): Promise<void>;
-    private updateLocalFromRemote;
-    private loadFromLocalStorage;
-    private saveToLocalStorage;
-    formatScore(leaderboardId: LeaderboardId, score: number): string;
-    clear(): void;
-    destroy(): void;
-}
-export declare function createLeaderboardSystem(config?: Partial<LeaderboardConfig>): NiceLeaderboard;

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

@@ -1,304 +0,0 @@
-export type LevelId = string;
-export type LayerId = string;
-export type TileId = number;
-export type TilesetId = string;
-export type ZoneId = string;
-export type SpawnPointId = string;
-export type CheckpointId = string;
-export interface Vector2 {
-    x: number;
-    y: number;
-}
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface Bounds {
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-}
-export interface TileDefinition {
-    id: TileId;
-    name?: string;
-    solid: boolean;
-    friction?: number;
-    animation?: {
-        frames: TileId[];
-        frameDuration: number;
-    };
-    properties?: Record<string, unknown>;
-}
-export interface TilesetDefinition {
-    id: TilesetId;
-    name: string;
-    imageUrl: string;
-    tileWidth: number;
-    tileHeight: number;
-    columns: number;
-    rows: number;
-    tiles: TileDefinition[];
-    margin?: number;
-    spacing?: number;
-}
-export type LayerType = 'tile' | 'object' | 'image' | 'collision';
-export interface TileLayerData {
-    width: number;
-    height: number;
-    tiles: TileId[];
-    tilesetId: TilesetId;
-}
-export interface ObjectInstance {
-    id: string;
-    type: string;
-    x: number;
-    y: number;
-    width?: number;
-    height?: number;
-    rotation?: number;
-    properties?: Record<string, unknown>;
-}
-export interface ObjectLayerData {
-    objects: ObjectInstance[];
-}
-export interface ImageLayerData {
-    imageUrl: string;
-    x: number;
-    y: number;
-    parallaxX?: number;
-    parallaxY?: number;
-    repeatX?: boolean;
-    repeatY?: boolean;
-}
-export interface LayerDefinition {
-    id: LayerId;
-    name: string;
-    type: LayerType;
-    visible: boolean;
-    opacity: number;
-    offsetX: number;
-    offsetY: number;
-    /** Render order (higher = on top) */
-    zIndex: number;
-    /** Tile layer data */
-    tileData?: TileLayerData;
-    /** Object layer data */
-    objectData?: ObjectLayerData;
-    /** Image layer data */
-    imageData?: ImageLayerData;
-    /** Collision data for collision layers */
-    collisionData?: TileId[];
-    properties?: Record<string, unknown>;
-}
-export type ZoneShape = 'rectangle' | 'circle' | 'polygon';
-export interface ZoneDefinition {
-    id: ZoneId;
-    name?: string;
-    shape: ZoneShape;
-    /** For rectangle */
-    bounds?: Bounds;
-    /** For circle */
-    center?: Vector2;
-    radius?: number;
-    /** For polygon */
-    points?: Vector2[];
-    /** Trigger type */
-    triggerType?: 'enter' | 'exit' | 'stay' | 'enter-exit';
-    /** Action on trigger */
-    action?: {
-        type: string;
-        data?: unknown;
-    };
-    /** Only specific entities */
-    filterTags?: string[];
-    enabled: boolean;
-    properties?: Record<string, unknown>;
-}
-export interface SpawnPointDefinition {
-    id: SpawnPointId;
-    name?: string;
-    position: Vector3;
-    rotation?: number;
-    type: 'player' | 'enemy' | 'item' | 'npc' | 'custom';
-    /** Entity type to spawn */
-    entityType?: string;
-    /** Initial if this is default spawn */
-    isInitial?: boolean;
-    /** Respawn after death */
-    respawnDelay?: number;
-    properties?: Record<string, unknown>;
-}
-export interface CheckpointDefinition {
-    id: CheckpointId;
-    name?: string;
-    position: Vector3;
-    bounds?: Bounds;
-    /** Save game on activation */
-    autoSave?: boolean;
-    order?: number;
-    properties?: Record<string, unknown>;
-}
-export interface LevelTransition {
-    id: string;
-    targetLevelId: LevelId;
-    targetSpawnId?: SpawnPointId;
-    zone: ZoneDefinition;
-    /** Transition effect */
-    transition?: 'fade' | 'slide' | 'none';
-    /** Transition duration */
-    transitionDuration?: number;
-    /** Load message */
-    loadingMessage?: string;
-    /** Requirements to use */
-    requirements?: string[];
-}
-export interface LevelDefinition {
-    id: LevelId;
-    name: string;
-    description?: string;
-    /** Thumbnail image */
-    thumbnail?: string;
-    /** Level size in tiles */
-    width: number;
-    height: number;
-    /** Tile size in pixels */
-    tileWidth: number;
-    tileHeight: number;
-    /** Tilesets used */
-    tilesets: TilesetId[];
-    /** Layers */
-    layers: LayerDefinition[];
-    /** Zones */
-    zones: ZoneDefinition[];
-    /** Spawn points */
-    spawnPoints: SpawnPointDefinition[];
-    /** Checkpoints */
-    checkpoints: CheckpointDefinition[];
-    /** Level transitions */
-    transitions: LevelTransition[];
-    /** Background color */
-    backgroundColor?: string;
-    /** Ambient lighting */
-    ambientLight?: {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    };
-    /** Level-specific properties */
-    properties?: Record<string, unknown>;
-    /** Music to play */
-    music?: string;
-    /** Time limit (seconds, 0 = none) */
-    timeLimit?: number;
-    /** Prerequisites */
-    requirements?: string[];
-    /** Order in world map */
-    order?: number;
-    /** Tags */
-    tags?: string[];
-}
-export interface LevelState {
-    levelId: LevelId;
-    loadedAt: number;
-    activeZones: Set<ZoneId>;
-    entitiesInZones: Map<ZoneId, Set<string>>;
-    activatedCheckpoints: Set<CheckpointId>;
-    currentCheckpoint?: CheckpointId;
-    timeElapsed: number;
-    completed: boolean;
-    customState: Record<string, unknown>;
-}
-export type LevelEventType = 'level-loading' | 'level-loaded' | 'level-unloaded' | 'level-transition-start' | 'level-transition-end' | 'zone-enter' | 'zone-exit' | 'zone-stay' | 'checkpoint-activated' | 'spawn-point-used' | 'level-completed' | 'level-failed';
-export interface LevelEvent {
-    type: LevelEventType;
-    timestamp: number;
-    levelId?: LevelId;
-    data?: unknown;
-}
-export type LevelEventCallback = (event: LevelEvent) => void;
-export interface LevelConfig {
-    /** Auto-load first level */
-    autoLoad: boolean;
-    /** Level streaming enabled */
-    enableStreaming: boolean;
-    /** Streaming load distance */
-    streamingLoadDistance: number;
-    /** Streaming unload distance */
-    streamingUnloadDistance: number;
-    /** Preload adjacent levels */
-    preloadAdjacent: boolean;
-    /** Default transition effect */
-    defaultTransition: 'fade' | 'slide' | 'none';
-    /** Default transition duration (ms) */
-    defaultTransitionDuration: number;
-    /** Persist zone states */
-    persistZoneStates: boolean;
-    /** Storage key for persistence */
-    storageKey: string;
-}
-export declare const DEFAULT_LEVEL_CONFIG: LevelConfig;
-export declare class NiceLevel {
-    private config;
-    private levels;
-    private tilesets;
-    private currentLevel?;
-    private levelState?;
-    private loadedLevels;
-    private preloadedAssets;
-    private isTransitioning;
-    private eventListeners;
-    constructor(config?: Partial<LevelConfig>);
-    on(event: LevelEventType, callback: LevelEventCallback): () => void;
-    private emit;
-    registerLevel(level: LevelDefinition): void;
-    unregisterLevel(levelId: LevelId): void;
-    registerTileset(tileset: TilesetDefinition): void;
-    getLevel(levelId: LevelId): LevelDefinition | undefined;
-    getAllLevels(): LevelDefinition[];
-    getLevelsByTag(tag: string): LevelDefinition[];
-    getTileset(tilesetId: TilesetId): TilesetDefinition | undefined;
-    loadLevel(levelId: LevelId, spawnPointId?: SpawnPointId): Promise<boolean>;
-    private loadLevelAssets;
-    private preloadAdjacentLevels;
-    unloadLevel(levelId: LevelId): void;
-    getCurrentLevel(): LevelDefinition | undefined;
-    getLevelState(): LevelState | undefined;
-    transitionToLevel(levelId: LevelId, spawnPointId?: SpawnPointId, transition?: 'fade' | 'slide' | 'none', duration?: number): Promise<boolean>;
-    private delay;
-    updateZones(entityId: string, position: Vector2, tags?: string[]): void;
-    private isPointInZone;
-    private isPointInPolygon;
-    getActiveZones(): ZoneDefinition[];
-    getZone(zoneId: ZoneId): ZoneDefinition | undefined;
-    activateCheckpoint(checkpointId: CheckpointId, entityId?: string): void;
-    getCurrentCheckpoint(): CheckpointDefinition | undefined;
-    getCheckpointPosition(): Vector3 | undefined;
-    getInitialSpawnPoint(): SpawnPointDefinition | undefined;
-    getSpawnPoint(spawnPointId: SpawnPointId): SpawnPointDefinition | undefined;
-    getSpawnPointsByType(type: string): SpawnPointDefinition[];
-    useSpawnPoint(spawnPointId: SpawnPointId, entityId?: string): Vector3 | undefined;
-    getTileAt(layerId: LayerId, x: number, y: number): TileId | undefined;
-    setTileAt(layerId: LayerId, x: number, y: number, tileId: TileId): boolean;
-    getTileDefinition(tileId: TileId, tilesetId: TilesetId): TileDefinition | undefined;
-    isTileSolid(tileId: TileId, tilesetId: TilesetId): boolean;
-    getCollisionTiles(): Array<{
-        x: number;
-        y: number;
-        tileId: TileId;
-    }>;
-    isPositionSolid(x: number, y: number): boolean;
-    completeLevel(data?: unknown): void;
-    failLevel(reason?: string): void;
-    update(deltaTime: number): void;
-    worldToTile(worldX: number, worldY: number): Vector2;
-    tileToWorld(tileX: number, tileY: number): Vector2;
-    getLevelBounds(): Bounds | undefined;
-    setCustomState(key: string, value: unknown): void;
-    getCustomState<T>(key: string): T | undefined;
-    clear(): void;
-    destroy(): void;
-}
-export declare function createLevelSystem(config?: Partial<LevelConfig>): NiceLevel;

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

@@ -1,214 +0,0 @@
-import { EventEmitter } from 'events';
-export type LightId = string;
-export type LightGroupId = string;
-export type ProbeId = string;
-export interface Vector3 {
-    x: number;
-    y: number;
-    z: number;
-}
-export interface ColorRGB {
-    r: number;
-    g: number;
-    b: number;
-}
-export type LightType = 'directional' | 'point' | 'spot' | 'area' | 'ambient' | 'hemisphere';
-export type ShadowType = 'none' | 'hard' | 'soft' | 'pcf' | 'vsm' | 'cascade';
-export type FalloffType = 'linear' | 'quadratic' | 'inverse_square' | 'custom';
-export interface Light {
-    id: LightId;
-    type: LightType;
-    enabled: boolean;
-    position: Vector3;
-    direction: Vector3;
-    color: ColorRGB;
-    intensity: number;
-    range: number;
-    group?: LightGroupId;
-    shadow: ShadowSettings;
-    attenuation: AttenuationSettings;
-    spotlight?: SpotlightSettings;
-    areaLight?: AreaLightSettings;
-    cookies?: LightCookie;
-    animation?: LightAnimation;
-    priority: number;
-    tags: string[];
-}
-export interface ShadowSettings {
-    enabled: boolean;
-    type: ShadowType;
-    resolution: number;
-    bias: number;
-    normalBias: number;
-    nearPlane: number;
-    farPlane: number;
-    cascadeCount?: number;
-    cascadeDistribution?: number[];
-    softness?: number;
-}
-export interface AttenuationSettings {
-    type: FalloffType;
-    constant: number;
-    linear: number;
-    quadratic: number;
-    cutoffAngle?: number;
-}
-export interface SpotlightSettings {
-    innerConeAngle: number;
-    outerConeAngle: number;
-    falloffExponent: number;
-}
-export interface AreaLightSettings {
-    width: number;
-    height: number;
-    shape: 'rectangle' | 'disc' | 'line';
-    twoSided: boolean;
-}
-export interface LightCookie {
-    textureId: string;
-    scale: number;
-    offset: {
-        u: number;
-        v: number;
-    };
-}
-export interface LightAnimation {
-    type: 'flicker' | 'pulse' | 'strobe' | 'custom';
-    frequency: number;
-    amplitude: number;
-    phase: number;
-    enabled: boolean;
-}
-export interface LightProbe {
-    id: ProbeId;
-    position: Vector3;
-    radius: number;
-    resolution: number;
-    priority: number;
-    isDirty: boolean;
-    sh?: SphericalHarmonics;
-    cubemapTextureId?: string;
-    blendDistance: number;
-}
-export interface SphericalHarmonics {
-    coefficients: number[][];
-    bands: number;
-}
-export interface LightGroup {
-    id: LightGroupId;
-    name: string;
-    enabled: boolean;
-    intensityMultiplier: number;
-    colorTint: ColorRGB;
-    lights: LightId[];
-}
-export interface AmbientSettings {
-    mode: 'color' | 'gradient' | 'skybox' | 'probe';
-    color: ColorRGB;
-    groundColor?: ColorRGB;
-    skyColor?: ColorRGB;
-    intensity: number;
-    skyboxTextureId?: string;
-}
-export interface TimeOfDaySettings {
-    enabled: boolean;
-    currentTime: number;
-    sunLightId?: LightId;
-    moonLightId?: LightId;
-    sunriseTime: number;
-    sunsetTime: number;
-    transitionDuration: number;
-    dayAmbient: AmbientSettings;
-    nightAmbient: AmbientSettings;
-    sunColor: ColorRGB;
-    sunsetColor: ColorRGB;
-    moonColor: ColorRGB;
-}
-export type LightingEventType = 'light-added' | 'light-removed' | 'light-updated' | 'light-enabled' | 'light-disabled' | 'group-created' | 'group-removed' | 'group-updated' | 'probe-added' | 'probe-removed' | 'probe-updated' | 'ambient-changed' | 'time-changed' | 'sunrise' | 'sunset';
-export interface LightingEvent {
-    type: LightingEventType;
-    lightId?: LightId;
-    groupId?: LightGroupId;
-    probeId?: ProbeId;
-    data?: Record<string, unknown>;
-}
-export interface LightingSystemConfig {
-    maxLights?: number;
-    maxShadowCasters?: number;
-    maxProbes?: number;
-    defaultShadowResolution?: number;
-    shadowDistance?: number;
-    probeUpdateInterval?: number;
-    enableGlobalIllumination?: boolean;
-}
-export declare const DEFAULT_LIGHTING_CONFIG: LightingSystemConfig;
-export declare class NiceLighting extends EventEmitter {
-    private lights;
-    private groups;
-    private probes;
-    private ambient;
-    private timeOfDay;
-    private config;
-    private lightIdCounter;
-    private probeIdCounter;
-    private probeUpdateTimer;
-    constructor(config?: Partial<LightingSystemConfig>);
-    createLight(options: Partial<Light> & {
-        type: LightType;
-    }): LightId;
-    removeLight(lightId: LightId): void;
-    getLight(lightId: LightId): Light | undefined;
-    updateLight(lightId: LightId, updates: Partial<Light>): void;
-    enableLight(lightId: LightId): void;
-    disableLight(lightId: LightId): void;
-    setLightPosition(lightId: LightId, position: Vector3): void;
-    setLightDirection(lightId: LightId, direction: Vector3): void;
-    setLightColor(lightId: LightId, color: ColorRGB): void;
-    setLightIntensity(lightId: LightId, intensity: number): void;
-    setLightRange(lightId: LightId, range: number): void;
-    enableShadow(lightId: LightId, type?: ShadowType): void;
-    disableShadow(lightId: LightId): void;
-    setShadowSettings(lightId: LightId, settings: Partial<ShadowSettings>): void;
-    getShadowCasters(): Light[];
-    createGroup(id: LightGroupId, name: string): LightGroup;
-    removeGroup(groupId: LightGroupId): void;
-    getGroup(groupId: LightGroupId): LightGroup | undefined;
-    setGroupEnabled(groupId: LightGroupId, enabled: boolean): void;
-    setGroupIntensity(groupId: LightGroupId, intensity: number): void;
-    setGroupTint(groupId: LightGroupId, tint: ColorRGB): void;
-    addLightToGroup(lightId: LightId, groupId: LightGroupId): void;
-    createProbe(position: Vector3, options?: Partial<LightProbe>): ProbeId;
-    removeProbe(probeId: ProbeId): void;
-    getProbe(probeId: ProbeId): LightProbe | undefined;
-    markProbeDirty(probeId: ProbeId): void;
-    markAllProbesDirty(): void;
-    getProbeAtPosition(position: Vector3): LightProbe | undefined;
-    setAmbient(settings: Partial<AmbientSettings>): void;
-    getAmbient(): AmbientSettings;
-    enableTimeOfDay(sunLightId?: LightId, moonLightId?: LightId): void;
-    disableTimeOfDay(): void;
-    setTimeOfDay(time: number): void;
-    getTimeOfDay(): number;
-    setTimeOfDaySettings(settings: Partial<TimeOfDaySettings>): void;
-    setLightAnimation(lightId: LightId, animation: LightAnimation): void;
-    enableLightAnimation(lightId: LightId): void;
-    disableLightAnimation(lightId: LightId): void;
-    update(deltaTime: number): void;
-    private updateTimeOfDay;
-    private interpolateAmbient;
-    private updateAnimations;
-    private updateDirtyProbes;
-    getLightsAffectingPoint(position: Vector3): Light[];
-    getLightsByTag(tag: string): Light[];
-    getAllLights(): Light[];
-    getEnabledLights(): Light[];
-    private calculateDistance;
-    private normalizeVector;
-}
-export declare function createLightingSystem(config?: Partial<LightingSystemConfig>): NiceLighting;
-export declare function defineLightPreset(options: Partial<Light> & {
-    type: LightType;
-}): Partial<Light> & {
-    type: LightType;
-};
-export default NiceLighting;