@nice2dev/game-engine 1.1.5 → 1.1.6

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

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

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

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