@nice2dev/game-engine 1.1.5 → 1.1.7

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

@@ -0,0 +1,196 @@
+export type AchievementId = string;
+export type CategoryId = string;
+export interface Achievement {
+    id: AchievementId;
+    name: string;
+    description: string;
+    icon: string;
+    category: CategoryId;
+    rarity: AchievementRarity;
+    points: number;
+    isHidden: boolean;
+    isSecret: boolean;
+    prerequisites?: AchievementId[];
+    rewards?: AchievementReward[];
+    progress?: AchievementProgress;
+}
+export type AchievementRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+export interface AchievementProgress {
+    current: number;
+    target: number;
+    unit?: string;
+    milestones?: number[];
+}
+export interface AchievementReward {
+    type: 'currency' | 'item' | 'title' | 'badge' | 'unlock';
+    id: string;
+    amount?: number;
+    name?: string;
+}
+export interface AchievementCategory {
+    id: CategoryId;
+    name: string;
+    description?: string;
+    icon?: string;
+    order: number;
+}
+export interface AchievementUnlock {
+    achievementId: AchievementId;
+    unlockedAt: number;
+    progress?: number;
+    isNew: boolean;
+}
+export interface AchievementNotification {
+    id: string;
+    achievement: Achievement;
+    type: 'unlock' | 'progress' | 'milestone';
+    timestamp: number;
+    duration: number;
+    position: NotificationPosition;
+    state: NotificationState;
+    progress?: {
+        current: number;
+        target: number;
+        milestone?: number;
+    };
+}
+export type NotificationPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export type NotificationState = 'entering' | 'visible' | 'exiting' | 'removed';
+export interface PanelState {
+    isOpen: boolean;
+    selectedCategory?: CategoryId;
+    selectedAchievement?: AchievementId;
+    filter: AchievementFilter;
+    sortBy: AchievementSort;
+    searchQuery: string;
+}
+export type AchievementFilter = 'all' | 'unlocked' | 'locked' | 'in-progress' | 'new';
+export type AchievementSort = 'name' | 'rarity' | 'points' | 'unlock-date' | 'progress';
+export interface AchievementStats {
+    totalAchievements: number;
+    unlockedCount: number;
+    totalPoints: number;
+    earnedPoints: number;
+    completionPercentage: number;
+    byRarity: Record<AchievementRarity, {
+        total: number;
+        unlocked: number;
+    }>;
+    byCategory: Record<CategoryId, {
+        total: number;
+        unlocked: number;
+    }>;
+    recentUnlocks: AchievementUnlock[];
+    rarest?: Achievement;
+}
+export interface AchievementRenderData {
+    achievement: Achievement;
+    isUnlocked: boolean;
+    unlockDate?: number;
+    isNew: boolean;
+    canUnlock: boolean;
+    progressPercent?: number;
+    rarityColor: string;
+    rarityLabel: string;
+}
+export type AchievementUIEventType = 'notification-shown' | 'notification-hidden' | 'notification-clicked' | 'panel-opened' | 'panel-closed' | 'category-selected' | 'achievement-selected' | 'achievement-hovered' | 'filter-changed' | 'sort-changed' | 'search-changed';
+export interface AchievementUIEvent {
+    type: AchievementUIEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export type AchievementUIEventCallback = (event: AchievementUIEvent) => void;
+export interface AchievementUIConfig {
+    /** Default notification duration (seconds) */
+    notificationDuration: number;
+    /** Default notification position */
+    notificationPosition: NotificationPosition;
+    /** Max concurrent notifications */
+    maxNotifications: number;
+    /** Show progress notifications */
+    showProgressNotifications: boolean;
+    /** Progress notification threshold (%) */
+    progressThreshold: number;
+    /** Show milestone notifications */
+    showMilestones: boolean;
+    /** Enable sound effects */
+    enableSounds: boolean;
+    /** Animation durations (ms) */
+    animationEnter: number;
+    animationExit: number;
+    /** Rarity colors */
+    rarityColors: Record<AchievementRarity, string>;
+    /** Show points in notifications */
+    showPoints: boolean;
+    /** Group notifications */
+    groupNotifications: boolean;
+    /** Recent unlocks count */
+    recentUnlocksCount: number;
+}
+export declare const DEFAULT_ACHIEVEMENT_UI_CONFIG: AchievementUIConfig;
+export type SoundCallback = (soundId: string) => void;
+export declare class NiceAchievementUI {
+    private config;
+    private achievements;
+    private categories;
+    private unlocks;
+    private notifications;
+    private notificationQueue;
+    private panelState;
+    private soundCallback?;
+    private idCounter;
+    private eventListeners;
+    constructor(config?: Partial<AchievementUIConfig>);
+    on(event: AchievementUIEventType, callback: AchievementUIEventCallback): () => void;
+    private emit;
+    setSoundCallback(callback: SoundCallback): void;
+    private playSound;
+    registerAchievement(achievement: Achievement): void;
+    registerAchievements(achievements: Achievement[]): void;
+    registerCategory(category: AchievementCategory): void;
+    registerCategories(categories: AchievementCategory[]): void;
+    getAchievement(id: AchievementId): Achievement | undefined;
+    getAllAchievements(): Achievement[];
+    getAchievementsByCategory(categoryId: CategoryId): Achievement[];
+    getCategories(): AchievementCategory[];
+    setUnlocked(achievementId: AchievementId, options?: {
+        timestamp?: number;
+        showNotification?: boolean;
+    }): void;
+    setProgress(achievementId: AchievementId, current: number, options?: {
+        showNotification?: boolean;
+    }): void;
+    isUnlocked(achievementId: AchievementId): boolean;
+    getUnlock(achievementId: AchievementId): AchievementUnlock | undefined;
+    markAsSeen(achievementId: AchievementId): void;
+    markAllAsSeen(): void;
+    getNewUnlocks(): AchievementUnlock[];
+    private queueNotification;
+    private processNotificationQueue;
+    private showNotification;
+    private hideNotification;
+    dismissNotification(notificationId: string): void;
+    dismissAllNotifications(): void;
+    getActiveNotifications(): AchievementNotification[];
+    openPanel(): void;
+    closePanel(): void;
+    togglePanel(): void;
+    isPanelOpen(): boolean;
+    selectCategory(categoryId: CategoryId | undefined): void;
+    selectAchievement(achievementId: AchievementId | undefined): void;
+    hoverAchievement(achievementId: AchievementId | undefined): void;
+    setFilter(filter: AchievementFilter): void;
+    setSort(sortBy: AchievementSort): void;
+    setSearchQuery(query: string): void;
+    getPanelState(): PanelState;
+    getFilteredAchievements(): AchievementRenderData[];
+    private sortAchievements;
+    getAchievementRenderData(achievement: Achievement): AchievementRenderData;
+    getStatistics(): AchievementStats;
+    exportUnlocks(): AchievementUnlock[];
+    importUnlocks(unlocks: AchievementUnlock[]): void;
+    save(storageKey?: string): void;
+    load(storageKey?: string): void;
+    destroy(): void;
+}
+export declare function createAchievementUISystem(config?: Partial<AchievementUIConfig>): NiceAchievementUI;

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

@@ -0,0 +1,230 @@
+export type AchievementId = string;
+export type StatId = string;
+export type LeaderboardId = string;
+export type AchievementRarity = 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+export type AchievementCategory = string;
+export interface AchievementDefinition {
+    id: AchievementId;
+    name: string;
+    description: string;
+    icon: string;
+    iconLocked?: string;
+    category: AchievementCategory;
+    rarity: AchievementRarity;
+    points: number;
+    secret: boolean;
+    /** Conditions to unlock */
+    conditions: AchievementCondition[];
+    /** Conditions must all be met, or any */
+    conditionMode: 'all' | 'any';
+    /** Rewards given when unlocked */
+    rewards?: AchievementReward[];
+    /** Platform-specific IDs */
+    platformIds?: {
+        steam?: string;
+        xbox?: string;
+        playstation?: string;
+        gog?: string;
+    };
+    /** Order for display */
+    sortOrder?: number;
+    /** Tags for filtering */
+    tags?: string[];
+    /** Dependent achievements (must be unlocked first) */
+    prerequisites?: AchievementId[];
+}
+export interface AchievementCondition {
+    type: 'stat' | 'event' | 'custom';
+    /** For stat conditions */
+    statId?: StatId;
+    comparator?: 'eq' | 'gt' | 'gte' | 'lt' | 'lte' | 'between';
+    value?: number;
+    valueMax?: number;
+    /** For event conditions */
+    eventName?: string;
+    eventCount?: number;
+    /** For custom conditions */
+    customCheck?: () => boolean;
+}
+export interface AchievementReward {
+    type: 'currency' | 'item' | 'title' | 'badge' | 'unlock' | 'custom';
+    id: string;
+    amount?: number;
+    data?: Record<string, unknown>;
+}
+export interface AchievementState {
+    id: AchievementId;
+    unlocked: boolean;
+    unlockedAt?: number;
+    progress: number;
+    notified: boolean;
+    syncedToPlatform: boolean;
+}
+export interface UnlockNotification {
+    achievement: AchievementDefinition;
+    state: AchievementState;
+    timestamp: number;
+}
+export interface StatDefinition {
+    id: StatId;
+    name: string;
+    description?: string;
+    type: 'int' | 'float' | 'max' | 'min' | 'set';
+    defaultValue: number;
+    min?: number;
+    max?: number;
+    increment?: number;
+    aggregation?: 'sum' | 'max' | 'min' | 'last' | 'count';
+    displayFormat?: string;
+    hidden?: boolean;
+    platformIds?: {
+        steam?: string;
+        xbox?: string;
+        playstation?: string;
+    };
+}
+export interface StatState {
+    id: StatId;
+    value: number;
+    lastUpdated: number;
+    history?: {
+        value: number;
+        timestamp: number;
+    }[];
+}
+export interface LeaderboardDefinition {
+    id: LeaderboardId;
+    name: string;
+    description?: string;
+    sortOrder: 'ascending' | 'descending';
+    displayType: 'numeric' | 'time' | 'money';
+    updateType: 'keep-best' | 'force-update';
+    platformIds?: {
+        steam?: string;
+        xbox?: string;
+        playstation?: string;
+    };
+}
+export interface LeaderboardEntry {
+    rank: number;
+    playerId: string;
+    playerName: string;
+    score: number;
+    timestamp: number;
+    details?: Record<string, unknown>;
+}
+export interface LeaderboardState {
+    id: LeaderboardId;
+    playerRank?: number;
+    playerScore?: number;
+    entries: LeaderboardEntry[];
+    lastFetched: number;
+}
+export type AchievementEventType = 'achievement-unlocked' | 'achievement-progress' | 'stat-updated' | 'leaderboard-updated' | 'reward-granted';
+export interface AchievementEvent {
+    type: AchievementEventType;
+    timestamp: number;
+    data: unknown;
+}
+export type AchievementEventCallback = (event: AchievementEvent) => void;
+export interface PlatformAchievementAdapter {
+    isAvailable(): Promise<boolean>;
+    unlockAchievement(platformId: string): Promise<boolean>;
+    setAchievementProgress(platformId: string, progress: number): Promise<boolean>;
+    setStat(platformId: string, value: number): Promise<boolean>;
+    getStat(platformId: string): Promise<number | null>;
+    submitLeaderboardScore(platformId: string, score: number, details?: Record<string, unknown>): Promise<boolean>;
+    getLeaderboard(platformId: string, start: number, count: number): Promise<LeaderboardEntry[]>;
+    getPlayerRank(platformId: string): Promise<number | null>;
+}
+export interface AchievementSystemConfig {
+    /** Auto-save achievement state */
+    autoSave: boolean;
+    /** Auto-save interval in seconds */
+    autoSaveInterval: number;
+    /** Show unlock notifications */
+    showNotifications: boolean;
+    /** Notification duration in ms */
+    notificationDuration: number;
+    /** Sync with platform services */
+    syncWithPlatform: boolean;
+    /** Platform adapter */
+    platformAdapter?: PlatformAchievementAdapter;
+    /** Storage key for persistence */
+    storageKey: string;
+    /** Keep stat history */
+    trackStatHistory: boolean;
+    /** Max history entries per stat */
+    maxStatHistory: number;
+}
+export declare const DEFAULT_ACHIEVEMENT_CONFIG: AchievementSystemConfig;
+export declare class NiceAchievements {
+    private config;
+    private achievements;
+    private achievementStates;
+    private stats;
+    private statStates;
+    private leaderboards;
+    private leaderboardStates;
+    private eventListeners;
+    private pendingNotifications;
+    private autoSaveTimer;
+    constructor(config?: Partial<AchievementSystemConfig>);
+    on(event: AchievementEventType, callback: AchievementEventCallback): () => void;
+    private emit;
+    registerAchievement(definition: AchievementDefinition): void;
+    registerAchievements(definitions: AchievementDefinition[]): void;
+    getAchievement(id: AchievementId): AchievementDefinition | undefined;
+    getAllAchievements(): AchievementDefinition[];
+    getAchievementsByCategory(category: AchievementCategory): AchievementDefinition[];
+    getCategories(): AchievementCategory[];
+    getAchievementState(id: AchievementId): AchievementState | undefined;
+    isUnlocked(id: AchievementId): boolean;
+    getProgress(id: AchievementId): number;
+    getUnlockedCount(): number;
+    getTotalPoints(): number;
+    getCompletionPercentage(): number;
+    unlock(id: AchievementId, options?: {
+        silent?: boolean;
+    }): boolean;
+    setProgress(id: AchievementId, progress: number): void;
+    incrementProgress(id: AchievementId, amount: number): void;
+    checkConditions(id: AchievementId): boolean;
+    private checkStatCondition;
+    private syncAchievementToPlatform;
+    registerStat(definition: StatDefinition): void;
+    registerStats(definitions: StatDefinition[]): void;
+    getStat(id: StatId): number;
+    getStatState(id: StatId): StatState | undefined;
+    setStat(id: StatId, value: number): void;
+    incrementStat(id: StatId, amount?: number): void;
+    decrementStat(id: StatId, amount?: number): void;
+    private checkAchievementsForStat;
+    getAllStats(): StatState[];
+    registerLeaderboard(definition: LeaderboardDefinition): void;
+    submitScore(id: LeaderboardId, score: number, details?: Record<string, unknown>): Promise<boolean>;
+    fetchLeaderboard(id: LeaderboardId, start?: number, count?: number): Promise<LeaderboardEntry[]>;
+    getLeaderboardState(id: LeaderboardId): LeaderboardState | undefined;
+    getPendingNotifications(): UnlockNotification[];
+    clearNotification(timestamp: number): void;
+    clearAllNotifications(): void;
+    save(): string;
+    load(data: string): void;
+    saveToStorage(): void;
+    loadFromStorage(): boolean;
+    private startAutoSave;
+    resetAchievement(id: AchievementId): void;
+    resetAllAchievements(): void;
+    resetStat(id: StatId): void;
+    resetAllStats(): void;
+    resetAll(): void;
+    destroy(): void;
+}
+export declare function createAchievementSystem(config?: Partial<AchievementSystemConfig>): NiceAchievements;
+export declare function createProgressAchievement(id: AchievementId, name: string, description: string, statId: StatId, targetValue: number, options?: Partial<AchievementDefinition>): AchievementDefinition;
+export declare function createTieredAchievements(baseId: string, baseName: string, description: string, statId: StatId, tiers: {
+    name: string;
+    value: number;
+    points: number;
+    rarity: AchievementRarity;
+}[], options?: Partial<AchievementDefinition>): AchievementDefinition[];

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

@@ -0,0 +1,81 @@
+import { EventEmitter } from 'events';
+export type ActionId = string;
+export type ActionType = string;
+export type ActorId = string;
+export interface ActionDefinition<TParams extends Record<string, unknown> = Record<string, unknown>> {
+    type: ActionType;
+    name: string;
+    duration?: number;
+    cooldown?: number;
+    priority?: number;
+    interruptible?: boolean;
+    tags?: string[];
+    condition?: (actor: ActorId, params: TParams) => boolean;
+    execute: (actor: ActorId, params: TParams, progress: number) => void;
+    onStart?: (actor: ActorId, params: TParams) => void;
+    onComplete?: (actor: ActorId, params: TParams) => void;
+    onCancel?: (actor: ActorId, params: TParams) => void;
+}
+export interface ActionInstance<TParams extends Record<string, unknown> = Record<string, unknown>> {
+    id: ActionId;
+    type: ActionType;
+    actorId: ActorId;
+    params: TParams;
+    state: ActionState;
+    priority: number;
+    startTime: number;
+    progress: number;
+    queuedAt: number;
+}
+export type ActionState = 'queued' | 'running' | 'completed' | 'cancelled' | 'failed';
+export interface ActorActionState {
+    currentAction?: ActionInstance;
+    queue: ActionInstance[];
+    cooldowns: Map<ActionType, number>;
+    blocked: boolean;
+}
+export type ActionEventType = 'action-queued' | 'action-started' | 'action-progress' | 'action-completed' | 'action-cancelled' | 'action-failed' | 'cooldown-started' | 'cooldown-ended';
+export interface ActionEvent {
+    type: ActionEventType;
+    actionId?: ActionId;
+    actorId?: ActorId;
+    actionType?: ActionType;
+    progress?: number;
+    cooldown?: number;
+}
+export interface ActionSystemConfig {
+    maxQueueSize?: number;
+    defaultPriority?: number;
+    allowInterrupts?: boolean;
+}
+export declare const DEFAULT_ACTION_CONFIG: ActionSystemConfig;
+export declare class NiceAction extends EventEmitter {
+    private definitions;
+    private actors;
+    private nextId;
+    private config;
+    constructor(config?: Partial<ActionSystemConfig>);
+    register<TParams extends Record<string, unknown> = Record<string, unknown>>(definition: ActionDefinition<TParams>): void;
+    unregister(type: ActionType): boolean;
+    hasAction(type: ActionType): boolean;
+    registerActor(actorId: ActorId): void;
+    unregisterActor(actorId: ActorId): void;
+    private getOrCreateActor;
+    queue<TParams extends Record<string, unknown> = Record<string, unknown>>(actorId: ActorId, actionType: ActionType, params?: TParams): ActionId | null;
+    execute<TParams extends Record<string, unknown> = Record<string, unknown>>(actorId: ActorId, actionType: ActionType, params?: TParams): ActionId | null;
+    cancel(actionId: ActionId): boolean;
+    cancelAll(actorId: ActorId): void;
+    update(_deltaTime: number): void;
+    private completeAction;
+    getCurrentAction(actorId: ActorId): ActionInstance | undefined;
+    getQueue(actorId: ActorId): ActionInstance[];
+    getCooldown(actorId: ActorId, actionType: ActionType): number;
+    isOnCooldown(actorId: ActorId, actionType: ActionType): boolean;
+    canExecute(actorId: ActorId, actionType: ActionType): boolean;
+    block(actorId: ActorId): void;
+    unblock(actorId: ActorId): void;
+    isBlocked(actorId: ActorId): boolean;
+}
+export declare function createActionSystem(config?: Partial<ActionSystemConfig>): NiceAction;
+export declare function defineAction<TParams extends Record<string, unknown> = Record<string, unknown>>(type: ActionType, name: string, options: Omit<ActionDefinition<TParams>, 'type' | 'name'>): ActionDefinition<TParams>;
+export default NiceAction;

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

@@ -0,0 +1,195 @@
+export type ReagentId = string;
+export type PotionId = string;
+export type RecipeId = string;
+export type PotionType = 'health' | 'mana' | 'stamina' | 'buff' | 'resist' | 'elixir' | 'oil' | 'poison' | 'transmute';
+export interface ReagentDefinition {
+    id: ReagentId;
+    name: string;
+    description?: string;
+    rarity: 'common' | 'uncommon' | 'rare' | 'epic' | 'legendary';
+    tier: number;
+    properties: ReagentProperty[];
+    sources: string[];
+    gatherTime?: number;
+    icon: string;
+    color?: string;
+    sellValue: number;
+    stackSize: number;
+}
+export interface ReagentProperty {
+    id: string;
+    name: string;
+    type: 'positive' | 'negative' | 'neutral';
+    hidden: boolean;
+    discoveryDifficulty: number;
+    effect: PotionEffect;
+}
+export interface PotionDefinition {
+    id: PotionId;
+    name: string;
+    description: string;
+    type: PotionType;
+    quality: 'crude' | 'common' | 'good' | 'excellent' | 'masterwork';
+    tier: number;
+    effects: PotionEffect[];
+    duration: number;
+    cooldown: number;
+    charges: number;
+    consumable: boolean;
+    icon: string;
+    color: string;
+    vfx?: string;
+    sellValue: number;
+}
+export interface PotionEffect {
+    type: 'heal' | 'restore_mana' | 'restore_stamina' | 'buff' | 'debuff' | 'resist' | 'damage' | 'transform' | 'custom';
+    value: number;
+    isPercentage: boolean;
+    stat?: string;
+    buffId?: string;
+    duration?: number;
+    damageType?: string;
+    effectData?: Record<string, unknown>;
+}
+export interface AlchemyRecipe {
+    id: RecipeId;
+    name: string;
+    description?: string;
+    resultPotion: PotionId;
+    resultCount: number;
+    reagents: Record<ReagentId, number>;
+    catalyst?: ReagentId;
+    alchemyLevelRequired: number;
+    discoverable: boolean;
+    craftTime: number;
+    successRate: number;
+    failureResult?: PotionId;
+    xpGain: number;
+}
+export interface TransmuteRecipe {
+    id: RecipeId;
+    name: string;
+    inputItems: Record<string, number>;
+    outputItem: string;
+    outputCount: number;
+    alchemyLevelRequired: number;
+    xpGain: number;
+}
+export interface PlayerAlchemyData {
+    playerId: string;
+    reagents: Map<ReagentId, number>;
+    potions: Map<PotionId, number>;
+    knownRecipes: Set<RecipeId>;
+    discoveredProperties: Map<ReagentId, Set<string>>;
+    alchemyLevel: number;
+    alchemyXP: number;
+    activePotionEffects: ActivePotionEffect[];
+    potionCooldowns: Map<PotionId, number>;
+    potionsCrafted: number;
+    potionsUsed: number;
+    reagentsGathered: number;
+    transmutationsPerformed: number;
+    failedCrafts: number;
+}
+export interface ActivePotionEffect {
+    potionId: PotionId;
+    effects: PotionEffect[];
+    appliedAt: number;
+    expiresAt: number;
+    stacks: number;
+}
+export interface CraftResult {
+    success: boolean;
+    potionId?: PotionId;
+    count: number;
+    quality?: string;
+    xpGained: number;
+    bonusPotion?: PotionId;
+}
+export type AlchemyEventType = 'reagent-gathered' | 'property-discovered' | 'recipe-learned' | 'potion-crafted' | 'craft-failed' | 'potion-used' | 'effect-applied' | 'effect-expired' | 'transmute-success' | 'alchemy-level-up';
+export interface AlchemyEvent {
+    type: AlchemyEventType;
+    timestamp: number;
+    data?: unknown;
+}
+export type AlchemyEventCallback = (event: AlchemyEvent) => void;
+export interface AlchemyConfig {
+    maxReagentStacks: number;
+    maxPotionStacks: number;
+    maxActiveEffects: number;
+    xpPerLevel: number;
+    maxLevel: number;
+    qualitySuccessBonus: number;
+    storageKey: string;
+}
+export declare const DEFAULT_ALCHEMY_CONFIG: AlchemyConfig;
+export declare class NiceAlchemy {
+    private config;
+    private reagents;
+    private potions;
+    private recipes;
+    private transmuteRecipes;
+    private players;
+    private eventListeners;
+    private updateInterval?;
+    constructor(config?: Partial<AlchemyConfig>);
+    on(event: AlchemyEventType, callback: AlchemyEventCallback): () => void;
+    private emit;
+    private startUpdateLoop;
+    private update;
+    registerReagent(reagent: ReagentDefinition): void;
+    registerPotion(potion: PotionDefinition): void;
+    registerRecipe(recipe: AlchemyRecipe): void;
+    registerTransmuteRecipe(recipe: TransmuteRecipe): void;
+    getPlayer(playerId: string): PlayerAlchemyData;
+    private createPlayerData;
+    addReagent(playerId: string, reagentId: ReagentId, count?: number): boolean;
+    removeReagent(playerId: string, reagentId: ReagentId, count?: number): boolean;
+    getReagentCount(playerId: string, reagentId: ReagentId): number;
+    discoverProperty(playerId: string, reagentId: ReagentId, propertyId: string): boolean;
+    isPropertyDiscovered(playerId: string, reagentId: ReagentId, propertyId: string): boolean;
+    getDiscoveredProperties(playerId: string, reagentId: ReagentId): ReagentProperty[];
+    learnRecipe(playerId: string, recipeId: RecipeId): boolean;
+    knowsRecipe(playerId: string, recipeId: RecipeId): boolean;
+    getKnownRecipes(playerId: string): AlchemyRecipe[];
+    canCraft(playerId: string, recipeId: RecipeId): boolean;
+    craft(playerId: string, recipeId: RecipeId): CraftResult;
+    canUsePotion(playerId: string, potionId: PotionId): boolean;
+    usePotion(playerId: string, potionId: PotionId): ActivePotionEffect | null;
+    getActiveEffects(playerId: string): ActivePotionEffect[];
+    hasActiveEffect(playerId: string, potionId: PotionId): boolean;
+    removeEffect(playerId: string, potionId: PotionId): boolean;
+    canTransmute(playerId: string, recipeId: RecipeId): boolean;
+    transmute(playerId: string, recipeId: RecipeId): {
+        success: boolean;
+        outputItem?: string;
+        outputCount: number;
+        xpGained: number;
+    };
+    addAlchemyXP(playerId: string, xp: number): void;
+    getXPForLevel(level: number): number;
+    getReagent(id: ReagentId): ReagentDefinition | undefined;
+    getAllReagents(): ReagentDefinition[];
+    getPotion(id: PotionId): PotionDefinition | undefined;
+    getAllPotions(): PotionDefinition[];
+    getRecipe(id: RecipeId): AlchemyRecipe | undefined;
+    getAllRecipes(): AlchemyRecipe[];
+    getPotionCount(playerId: string, potionId: PotionId): number;
+    getCooldownRemaining(playerId: string, potionId: PotionId): number;
+    getStats(playerId: string): {
+        level: number;
+        xp: number;
+        xpNeeded: number;
+        potionsCrafted: number;
+        potionsUsed: number;
+        reagentsGathered: number;
+        recipesKnown: number;
+        propertiesDiscovered: number;
+        successRate: number;
+    };
+    save(): void;
+    load(): void;
+    reset(): void;
+    destroy(): void;
+}
+export declare function createAlchemySystem(config?: Partial<AlchemyConfig>): NiceAlchemy;