@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,108 @@
+import { EventEmitter } from 'events';
+export type StateId = string;
+export type ActionType = string;
+export interface StateConfig<TContext = Record<string, unknown>> {
+    id: StateId;
+    onEnter?: (context: TContext, previousState?: StateId) => void | Promise<void>;
+    onExit?: (context: TContext, nextState?: StateId) => void | Promise<void>;
+    onUpdate?: (context: TContext, deltaTime: number) => void;
+    transitions?: TransitionConfig<TContext>[];
+    parent?: StateId;
+    initial?: boolean;
+}
+export interface TransitionConfig<TContext = Record<string, unknown>> {
+    target: StateId;
+    action?: ActionType;
+    guard?: (context: TContext) => boolean;
+    onTransition?: (context: TContext) => void | Promise<void>;
+}
+export declare class State<TContext = Record<string, unknown>> {
+    readonly id: StateId;
+    readonly parent?: StateId;
+    readonly initial: boolean;
+    private transitions;
+    private onEnterFn?;
+    private onExitFn?;
+    private onUpdateFn?;
+    constructor(config: StateConfig<TContext>);
+    enter(context: TContext, previousState?: StateId): Promise<void>;
+    exit(context: TContext, nextState?: StateId): Promise<void>;
+    update(context: TContext, deltaTime: number): void;
+    getTransitions(): TransitionConfig<TContext>[];
+    findTransition(action: ActionType, context: TContext): TransitionConfig<TContext> | undefined;
+}
+export type StateMachineEventType = 'state-enter' | 'state-exit' | 'transition-start' | 'transition-end' | 'action-dispatched';
+export interface StateMachineEvent {
+    type: StateMachineEventType;
+    state?: StateId;
+    previousState?: StateId;
+    nextState?: StateId;
+    action?: ActionType;
+}
+export interface StateMachineConfig<TContext = Record<string, unknown>> {
+    id: string;
+    initial: StateId;
+    context: TContext;
+    states: StateConfig<TContext>[];
+    onTransition?: (from: StateId, to: StateId, context: TContext) => void;
+}
+export declare class NiceStateMachine<TContext = Record<string, unknown>> extends EventEmitter {
+    readonly id: string;
+    private states;
+    private currentStateId;
+    private context;
+    private history;
+    private isTransitioning;
+    private onTransitionFn?;
+    constructor(config: StateMachineConfig<TContext>);
+    getCurrentState(): StateId;
+    getState(id: StateId): State<TContext> | undefined;
+    isInState(id: StateId): boolean;
+    getContext(): TContext;
+    setContext(context: Partial<TContext>): void;
+    updateContext(updater: (ctx: TContext) => TContext): void;
+    dispatch(action: ActionType): Promise<boolean>;
+    transitionTo(targetState: StateId): Promise<boolean>;
+    private transition;
+    getHistory(): StateId[];
+    getPreviousState(): StateId | undefined;
+    goBack(): Promise<boolean>;
+    clearHistory(): void;
+    update(deltaTime: number): void;
+    reset(initialState?: StateId): Promise<void>;
+}
+export declare class HierarchicalStateMachine<TContext = Record<string, unknown>> extends NiceStateMachine<TContext> {
+    private childMachines;
+    registerChildMachine(parentState: StateId, machine: NiceStateMachine<TContext>): void;
+    update(deltaTime: number): void;
+    dispatchToChild(action: ActionType): Promise<boolean>;
+    getChildMachine(): NiceStateMachine<TContext> | undefined;
+}
+export declare class PushdownStateMachine<TContext = Record<string, unknown>> extends EventEmitter {
+    private states;
+    private stateStack;
+    private context;
+    private isTransitioning;
+    constructor(config: {
+        context: TContext;
+        states: StateConfig<TContext>[];
+        initial: StateId;
+    });
+    getCurrentState(): StateId | undefined;
+    getStackDepth(): number;
+    getStack(): StateId[];
+    push(stateId: StateId): Promise<boolean>;
+    pop(): Promise<StateId | undefined>;
+    replace(stateId: StateId): Promise<boolean>;
+    update(deltaTime: number): void;
+    getContext(): TContext;
+    setContext(ctx: Partial<TContext>): void;
+}
+export declare function createStateMachine<TContext = Record<string, unknown>>(config: StateMachineConfig<TContext>): NiceStateMachine<TContext>;
+export declare function createHierarchicalStateMachine<TContext = Record<string, unknown>>(config: StateMachineConfig<TContext>): HierarchicalStateMachine<TContext>;
+export declare function createPushdownStateMachine<TContext = Record<string, unknown>>(config: {
+    context: TContext;
+    states: StateConfig<TContext>[];
+    initial: StateId;
+}): PushdownStateMachine<TContext>;
+export default NiceStateMachine;

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

@@ -0,0 +1,116 @@
+import { EventEmitter } from 'events';
+export type StatusId = string;
+export type StatusInstanceId = string;
+export type EntityId = string;
+export type StatId = string;
+export type StatusType = 'buff' | 'debuff' | 'neutral';
+export type StatusCategory = 'physical' | 'magical' | 'poison' | 'disease' | 'curse' | 'bleed' | 'burn' | 'freeze' | 'stun' | 'silence' | 'slow' | 'haste' | 'shield' | 'heal' | 'damage' | 'control' | 'other';
+export type StackingBehavior = 'none' | 'duration' | 'intensity' | 'separate' | 'refresh';
+export interface StatusDefinition {
+    id: StatusId;
+    name: string;
+    description: string;
+    type: StatusType;
+    category: StatusCategory;
+    duration: number;
+    maxStacks: number;
+    stackingBehavior: StackingBehavior;
+    statModifiers?: StatModifier[];
+    periodicEffect?: PeriodicEffect;
+    tags?: string[];
+    icon?: string;
+    immunities?: StatusId[];
+    dispelCategories?: StatusCategory[];
+    onApply?: (entity: EntityId, stacks: number) => void;
+    onRemove?: (entity: EntityId, stacks: number) => void;
+    onTick?: (entity: EntityId, stacks: number) => void;
+}
+export interface StatModifier {
+    stat: StatId;
+    value: number;
+    type: 'flat' | 'percent' | 'multiply';
+    perStack: boolean;
+}
+export interface PeriodicEffect {
+    interval: number;
+    damage?: number;
+    heal?: number;
+    damageType?: string;
+    scalingPerStack?: number;
+}
+export interface StatusInstance {
+    instanceId: StatusInstanceId;
+    statusId: StatusId;
+    entityId: EntityId;
+    sourceId?: EntityId;
+    stacks: number;
+    startTime: number;
+    expiresAt: number;
+    lastTickTime: number;
+    paused: boolean;
+}
+export interface EntityStatusState {
+    entityId: EntityId;
+    activeStatuses: Map<StatusInstanceId, StatusInstance>;
+    immunities: Set<StatusId>;
+    categoryImmunities: Set<StatusCategory>;
+}
+export type StatusEventType = 'status-applied' | 'status-stacked' | 'status-refreshed' | 'status-expired' | 'status-removed' | 'status-dispelled' | 'status-tick' | 'immunity-blocked';
+export interface StatusEvent {
+    type: StatusEventType;
+    entityId: EntityId;
+    statusId: StatusId;
+    instanceId?: StatusInstanceId;
+    stacks?: number;
+    sourceId?: EntityId;
+    damage?: number;
+    heal?: number;
+}
+export interface StatusConfig {
+    maxStatusesPerEntity?: number;
+    tickInterval?: number;
+    defaultDuration?: number;
+}
+export declare const DEFAULT_STATUS_CONFIG: StatusConfig;
+export declare class NiceStatus extends EventEmitter {
+    private definitions;
+    private entities;
+    private nextInstanceId;
+    private config;
+    constructor(config?: Partial<StatusConfig>);
+    register(definition: StatusDefinition): void;
+    unregister(statusId: StatusId): boolean;
+    getDefinition(statusId: StatusId): StatusDefinition | undefined;
+    registerEntity(entityId: EntityId): void;
+    unregisterEntity(entityId: EntityId): void;
+    apply(entityId: EntityId, statusId: StatusId, options?: {
+        sourceId?: EntityId;
+        stacks?: number;
+        duration?: number;
+    }): StatusInstanceId | null;
+    private findExistingInstance;
+    private handleStacking;
+    remove(entityId: EntityId, instanceId: StatusInstanceId): boolean;
+    removeByStatusId(entityId: EntityId, statusId: StatusId): number;
+    removeAll(entityId: EntityId, type?: StatusType): number;
+    dispel(entityId: EntityId, categories: StatusCategory[], maxDispel?: number): number;
+    addImmunity(entityId: EntityId, statusId: StatusId): void;
+    removeImmunity(entityId: EntityId, statusId: StatusId): void;
+    addCategoryImmunity(entityId: EntityId, category: StatusCategory): void;
+    removeCategoryImmunity(entityId: EntityId, category: StatusCategory): void;
+    isImmune(entityId: EntityId, statusId: StatusId): boolean;
+    update(_deltaTime: number): void;
+    private processTick;
+    has(entityId: EntityId, statusId: StatusId): boolean;
+    getStacks(entityId: EntityId, statusId: StatusId): number;
+    getActiveStatuses(entityId: EntityId): StatusInstance[];
+    getStatusesByType(entityId: EntityId, type: StatusType): StatusInstance[];
+    getStatusesByCategory(entityId: EntityId, category: StatusCategory): StatusInstance[];
+    getRemainingDuration(entityId: EntityId, statusId: StatusId): number;
+    getStatModifiers(entityId: EntityId): Map<StatId, number>;
+    pause(entityId: EntityId, instanceId: StatusInstanceId): void;
+    resume(entityId: EntityId, instanceId: StatusInstanceId): void;
+}
+export declare function createStatusSystem(config?: Partial<StatusConfig>): NiceStatus;
+export declare function defineStatus(id: StatusId, name: string, type: StatusType, category: StatusCategory, options?: Partial<Omit<StatusDefinition, 'id' | 'name' | 'type' | 'category'>>): StatusDefinition;
+export default NiceStatus;

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

@@ -0,0 +1,204 @@
+import { EventEmitter } from 'events';
+export type EntityId = string;
+export type ZoneId = string;
+export interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+export type DetectionState = 'undetected' | 'suspicious' | 'alerted' | 'detected' | 'lost-contact' | 'searching';
+export interface DetectionLevel {
+    current: number;
+    decayRate: number;
+    buildRate: number;
+    suspiciousThreshold: number;
+    alertedThreshold: number;
+    detectedThreshold: number;
+}
+export interface DetectionInfo {
+    detecteeId: EntityId;
+    detectorId: EntityId;
+    level: number;
+    state: DetectionState;
+    lastSeenPosition?: Vector3;
+    lastSeenTime?: number;
+    isInSight: boolean;
+    isInHearing: boolean;
+}
+export interface VisibilityProfile {
+    baseVisibility: number;
+    lightMultiplier: number;
+    movementMultiplier: number;
+    stanceModifiers: {
+        standing: number;
+        crouching: number;
+        prone: number;
+    };
+    coverReduction: number;
+}
+export interface EntityVisibility {
+    entityId: EntityId;
+    position: Vector3;
+    stance: 'standing' | 'crouching' | 'prone';
+    isMoving: boolean;
+    movementSpeed: number;
+    lightLevel: number;
+    inCover: boolean;
+    coverValue: number;
+    currentVisibility: number;
+}
+export interface SoundEvent {
+    id: string;
+    sourceId: EntityId;
+    position: Vector3;
+    volume: number;
+    range: number;
+    type: 'footstep' | 'voice' | 'weapon' | 'impact' | 'environment' | 'alert';
+    priority: number;
+    timestamp: number;
+    duration: number;
+}
+export interface HearingProfile {
+    baseRange: number;
+    sensitivity: number;
+    alertSoundThreshold: number;
+    suspiciousSoundThreshold: number;
+}
+export interface SightProfile {
+    viewDistance: number;
+    fovAngle: number;
+    peripheralAngle: number;
+    peripheralEfficiency: number;
+    verticalFov: number;
+    nightVision: boolean;
+    nightVisionRange?: number;
+}
+export interface CoverPoint {
+    id: string;
+    position: Vector3;
+    normal: Vector3;
+    height: number;
+    width: number;
+    coverValue: number;
+    type: 'soft' | 'hard';
+}
+export interface DetectionZone {
+    id: ZoneId;
+    name: string;
+    bounds: {
+        min: Vector3;
+        max: Vector3;
+    };
+    alertLevel: DetectionState;
+    activeDetectors: Set<EntityId>;
+    lastAlertTime?: number;
+    searchTimeRemaining?: number;
+}
+export interface Detector {
+    id: EntityId;
+    position: Vector3;
+    forward: Vector3;
+    sightProfile: SightProfile;
+    hearingProfile: HearingProfile;
+    detectionLevel: DetectionLevel;
+    currentState: DetectionState;
+    detections: Map<EntityId, DetectionInfo>;
+    isAlerted: boolean;
+    lastKnownPosition?: Vector3;
+    searchPattern?: Vector3[];
+    patrolRoute?: Vector3[];
+    currentPatrolIndex: number;
+    alertCooldown: number;
+}
+export interface StealthEntity {
+    id: EntityId;
+    position: Vector3;
+    visibility: EntityVisibility;
+    visibilityProfile: VisibilityProfile;
+}
+export type StealthEventType = 'detection-started' | 'detection-increased' | 'detection-decreased' | 'state-changed' | 'fully-detected' | 'lost-contact' | 'search-started' | 'search-ended' | 'sound-heard' | 'zone-alert-changed';
+export interface StealthEvent {
+    type: StealthEventType;
+    detectorId: EntityId;
+    detecteeId?: EntityId;
+    zoneId?: ZoneId;
+    data?: Record<string, unknown>;
+}
+export interface StealthSystemConfig {
+    defaultDetectionThresholds?: {
+        suspicious: number;
+        alerted: number;
+        detected: number;
+    };
+    defaultDecayRate?: number;
+    defaultBuildRate?: number;
+    lostContactTimeout?: number;
+    searchDuration?: number;
+    soundPropagationSpeed?: number;
+}
+export declare const DEFAULT_STEALTH_CONFIG: StealthSystemConfig;
+export declare class NiceStealth extends EventEmitter {
+    private detectors;
+    private stealthEntities;
+    private coverPoints;
+    private zones;
+    private activeSounds;
+    private nextSoundId;
+    private config;
+    constructor(config?: Partial<StealthSystemConfig>);
+    registerDetector(id: EntityId, position: Vector3, options?: {
+        sightProfile?: Partial<SightProfile>;
+        hearingProfile?: Partial<HearingProfile>;
+        detectionLevel?: Partial<DetectionLevel>;
+    }): void;
+    updateDetector(id: EntityId, position: Vector3, forward: Vector3): void;
+    removeDetector(id: EntityId): void;
+    registerStealthEntity(id: EntityId, position: Vector3, profile?: Partial<VisibilityProfile>): void;
+    updateStealthEntity(id: EntityId, updates: {
+        position?: Vector3;
+        stance?: 'standing' | 'crouching' | 'prone';
+        isMoving?: boolean;
+        movementSpeed?: number;
+        lightLevel?: number;
+        inCover?: boolean;
+        coverValue?: number;
+    }): void;
+    private calculateVisibility;
+    removeStealthEntity(id: EntityId): void;
+    addCoverPoint(cover: CoverPoint): void;
+    removeCoverPoint(id: string): void;
+    findNearbyCover(position: Vector3, radius: number): CoverPoint[];
+    createZone(zone: DetectionZone): void;
+    setZoneAlert(zoneId: ZoneId, alertLevel: DetectionState): void;
+    emitSound(sourceId: EntityId, position: Vector3, options: {
+        volume: number;
+        range: number;
+        type: SoundEvent['type'];
+        priority?: number;
+        duration?: number;
+    }): string;
+    private processSoundForDetectors;
+    private handleSoundDetection;
+    hasLineOfSight(from: Vector3, to: Vector3, checkObstacles?: (from: Vector3, to: Vector3) => boolean): boolean;
+    isInFieldOfView(detector: Detector, targetPosition: Vector3): {
+        inFov: boolean;
+        inPeripheral: boolean;
+        angle: number;
+    };
+    calculateDetection(detectorId: EntityId, detecteeId: EntityId): number;
+    update(deltaTime: number): void;
+    private updateDetector2;
+    private changeDetectorState;
+    private updateZone;
+    private getDistance;
+    private normalizeVector;
+    getDetector(id: EntityId): Detector | undefined;
+    getDetectionInfo(detectorId: EntityId, detecteeId: EntityId): DetectionInfo | undefined;
+    getVisibility(entityId: EntityId): number;
+    isDetected(detecteeId: EntityId): boolean;
+    getAlertnessLevel(detectorId: EntityId): DetectionState;
+}
+export declare function createStealthSystem(config?: Partial<StealthSystemConfig>): NiceStealth;
+export declare function createVisibilityProfile(options?: Partial<VisibilityProfile>): VisibilityProfile;
+export declare function createSightProfile(options?: Partial<SightProfile>): SightProfile;
+export default NiceStealth;

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

@@ -0,0 +1,255 @@
+export type PlatformType = 'steam' | 'epic' | 'gog' | 'xbox' | 'playstation' | 'switch' | 'web' | 'standalone';
+export type AchievementId = string;
+export type LeaderboardId = string;
+export type StatId = string;
+export interface PlatformAchievement {
+    id: AchievementId;
+    apiName: string;
+    name: string;
+    description: string;
+    iconUrl?: string;
+    iconLockedUrl?: string;
+    hidden: boolean;
+    unlocked: boolean;
+    unlockedAt?: number;
+    progress?: number;
+    maxProgress?: number;
+}
+export interface LeaderboardEntry {
+    rank: number;
+    userId: string;
+    userName: string;
+    score: number;
+    details?: number[];
+    avatarUrl?: string;
+}
+export interface LeaderboardConfig {
+    id: LeaderboardId;
+    apiName: string;
+    sortMethod: 'ascending' | 'descending';
+    displayType: 'numeric' | 'time_seconds' | 'time_milliseconds';
+}
+export interface PlatformStat {
+    id: StatId;
+    apiName: string;
+    type: 'int' | 'float';
+    value: number;
+    defaultValue: number;
+    increment?: number;
+}
+export interface RichPresenceData {
+    state?: string;
+    details?: string;
+    largeImageKey?: string;
+    largeImageText?: string;
+    smallImageKey?: string;
+    smallImageText?: string;
+    partyId?: string;
+    partySize?: number;
+    partyMax?: number;
+    startTimestamp?: number;
+    endTimestamp?: number;
+}
+export interface PlatformFriend {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+    onlineStatus: 'online' | 'away' | 'busy' | 'offline';
+    inGame: boolean;
+    currentGameId?: string;
+    lastOnline?: number;
+}
+export interface WorkshopItem {
+    id: string;
+    title: string;
+    description: string;
+    previewUrl?: string;
+    author: string;
+    authorId: string;
+    tags: string[];
+    rating: number;
+    ratingCount: number;
+    subscriptions: number;
+    createdAt: number;
+    updatedAt: number;
+    fileSize: number;
+    installed: boolean;
+    downloadProgress?: number;
+}
+export interface WorkshopQuery {
+    type: 'subscribed' | 'popular' | 'recent' | 'trending' | 'search';
+    searchText?: string;
+    tags?: string[];
+    page: number;
+    perPage: number;
+}
+export interface CloudSaveFile {
+    name: string;
+    size: number;
+    timestamp: number;
+    syncStatus: 'synced' | 'pending' | 'error' | 'conflict';
+}
+export type PlatformEventType = 'initialized' | 'achievement-unlocked' | 'leaderboard-uploaded' | 'leaderboard-downloaded' | 'stat-changed' | 'cloud-conflict' | 'cloud-synced' | 'friend-status-changed' | 'overlay-activated' | 'overlay-deactivated' | 'dlc-installed' | 'screenshot-taken' | 'workshop-subscribed' | 'workshop-unsubscribed' | 'error';
+export interface PlatformEvent {
+    type: PlatformEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type PlatformEventCallback = (event: PlatformEvent) => void;
+export interface SteamConfig {
+    appId: string;
+    enableOverlay: boolean;
+    enableCloudSave: boolean;
+    enableRichPresence: boolean;
+    enableWorkshop: boolean;
+    autoSyncStats: boolean;
+    debugMode: boolean;
+}
+export declare const DEFAULT_STEAM_CONFIG: SteamConfig;
+export interface IPlatformAdapter {
+    platform: PlatformType;
+    initialize(): Promise<boolean>;
+    shutdown(): Promise<void>;
+    getAchievements(): Promise<PlatformAchievement[]>;
+    unlockAchievement(id: AchievementId): Promise<boolean>;
+    setAchievementProgress(id: AchievementId, progress: number, max: number): Promise<boolean>;
+    clearAchievement(id: AchievementId): Promise<boolean>;
+    getStats(): Promise<PlatformStat[]>;
+    setStat(id: StatId, value: number): Promise<boolean>;
+    incrementStat(id: StatId, amount?: number): Promise<boolean>;
+    storeStats(): Promise<boolean>;
+    downloadLeaderboard(id: LeaderboardId, start: number, count: number): Promise<LeaderboardEntry[]>;
+    downloadLeaderboardAroundUser(id: LeaderboardId, range: number): Promise<LeaderboardEntry[]>;
+    uploadLeaderboardScore(id: LeaderboardId, score: number, details?: number[]): Promise<number>;
+    cloudSaveExists(filename: string): Promise<boolean>;
+    cloudSaveRead(filename: string): Promise<ArrayBuffer | null>;
+    cloudSaveWrite(filename: string, data: ArrayBuffer): Promise<boolean>;
+    cloudSaveDelete(filename: string): Promise<boolean>;
+    cloudSaveList(): Promise<CloudSaveFile[]>;
+    setRichPresence(data: RichPresenceData): Promise<void>;
+    clearRichPresence(): Promise<void>;
+    getFriends(): Promise<PlatformFriend[]>;
+    inviteFriend(friendId: string): Promise<boolean>;
+    getSubscribedItems(): Promise<WorkshopItem[]>;
+    queryWorkshop(query: WorkshopQuery): Promise<{
+        items: WorkshopItem[];
+        total: number;
+    }>;
+    subscribeItem(itemId: string): Promise<boolean>;
+    unsubscribeItem(itemId: string): Promise<boolean>;
+    getItemInstallPath(itemId: string): Promise<string | null>;
+    openOverlayToStore(dlcId?: string): void;
+    openOverlayToUrl(url: string): void;
+    openOverlayToFriend(friendId: string): void;
+    takeScreenshot(): void;
+    isDlcInstalled(dlcId: string): boolean;
+    getInstalledDlcs(): string[];
+    getCurrentLanguage(): string;
+    getUserId(): string;
+    getUserName(): string;
+}
+export declare class MockPlatformAdapter implements IPlatformAdapter {
+    platform: PlatformType;
+    private achievements;
+    private stats;
+    private cloudFiles;
+    initialize(): Promise<boolean>;
+    shutdown(): Promise<void>;
+    getAchievements(): Promise<PlatformAchievement[]>;
+    unlockAchievement(id: AchievementId): Promise<boolean>;
+    setAchievementProgress(id: AchievementId, progress: number, max: number): Promise<boolean>;
+    clearAchievement(id: AchievementId): Promise<boolean>;
+    getStats(): Promise<PlatformStat[]>;
+    setStat(id: StatId, value: number): Promise<boolean>;
+    incrementStat(id: StatId, amount?: number): Promise<boolean>;
+    storeStats(): Promise<boolean>;
+    downloadLeaderboard(): Promise<LeaderboardEntry[]>;
+    downloadLeaderboardAroundUser(): Promise<LeaderboardEntry[]>;
+    uploadLeaderboardScore(): Promise<number>;
+    cloudSaveExists(filename: string): Promise<boolean>;
+    cloudSaveRead(filename: string): Promise<ArrayBuffer | null>;
+    cloudSaveWrite(filename: string, data: ArrayBuffer): Promise<boolean>;
+    cloudSaveDelete(filename: string): Promise<boolean>;
+    cloudSaveList(): Promise<CloudSaveFile[]>;
+    setRichPresence(): Promise<void>;
+    clearRichPresence(): Promise<void>;
+    getFriends(): Promise<PlatformFriend[]>;
+    inviteFriend(): Promise<boolean>;
+    getSubscribedItems(): Promise<WorkshopItem[]>;
+    queryWorkshop(): Promise<{
+        items: WorkshopItem[];
+        total: number;
+    }>;
+    subscribeItem(): Promise<boolean>;
+    unsubscribeItem(): Promise<boolean>;
+    getItemInstallPath(): Promise<string | null>;
+    openOverlayToStore(): void;
+    openOverlayToUrl(url: string): void;
+    openOverlayToFriend(): void;
+    takeScreenshot(): void;
+    isDlcInstalled(): boolean;
+    getInstalledDlcs(): string[];
+    getCurrentLanguage(): string;
+    getUserId(): string;
+    getUserName(): string;
+}
+export declare class NiceSteam {
+    private config;
+    private adapter;
+    private initialized;
+    private achievementCache;
+    private statCache;
+    private richPresence;
+    private eventListeners;
+    constructor(config?: Partial<SteamConfig>, adapter?: IPlatformAdapter);
+    on(event: PlatformEventType, callback: PlatformEventCallback): () => void;
+    private emit;
+    initialize(): Promise<boolean>;
+    shutdown(): Promise<void>;
+    unlockAchievement(id: AchievementId): Promise<boolean>;
+    setAchievementProgress(id: AchievementId, progress: number, max: number): Promise<boolean>;
+    isAchievementUnlocked(id: AchievementId): boolean;
+    getAchievement(id: AchievementId): PlatformAchievement | undefined;
+    getAllAchievements(): PlatformAchievement[];
+    getAchievementProgress(): {
+        unlocked: number;
+        total: number;
+        percent: number;
+    };
+    setStat(id: StatId, value: number): Promise<boolean>;
+    incrementStat(id: StatId, amount?: number): Promise<boolean>;
+    getStat(id: StatId): number;
+    storeStats(): Promise<boolean>;
+    getLeaderboard(id: LeaderboardId, start?: number, count?: number): Promise<LeaderboardEntry[]>;
+    getLeaderboardAroundUser(id: LeaderboardId, range?: number): Promise<LeaderboardEntry[]>;
+    submitScore(id: LeaderboardId, score: number, details?: number[]): Promise<number>;
+    cloudSave(filename: string, data: string | object): Promise<boolean>;
+    cloudLoad<T = string>(filename: string, parseJson?: boolean): Promise<T | null>;
+    cloudDelete(filename: string): Promise<boolean>;
+    cloudList(): Promise<CloudSaveFile[]>;
+    setRichPresence(data: Partial<RichPresenceData>): Promise<void>;
+    clearRichPresence(): Promise<void>;
+    getFriends(): Promise<PlatformFriend[]>;
+    inviteFriend(friendId: string): Promise<boolean>;
+    getSubscribedMods(): Promise<WorkshopItem[]>;
+    searchWorkshop(query: WorkshopQuery): Promise<{
+        items: WorkshopItem[];
+        total: number;
+    }>;
+    subscribeMod(itemId: string): Promise<boolean>;
+    unsubscribeMod(itemId: string): Promise<boolean>;
+    getModInstallPath(itemId: string): Promise<string | null>;
+    openStore(dlcId?: string): void;
+    openUrl(url: string): void;
+    openFriendProfile(friendId: string): void;
+    isDlcOwned(dlcId: string): boolean;
+    getOwnedDlcs(): string[];
+    getUserId(): string;
+    getUserName(): string;
+    getLanguage(): string;
+    getPlatform(): PlatformType;
+    isInitialized(): boolean;
+    takeScreenshot(): void;
+    destroy(): void;
+}
+export declare function createSteamSystem(config?: Partial<SteamConfig>, adapter?: IPlatformAdapter): NiceSteam;