@nice2dev/game-engine 1.3.12 → 1.3.14

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

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

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

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

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