import { ECSContext } from "../core/ecs";
import { Inventory, InventoryItem } from "../core/inventory";
import { ReactiveMap } from "../utils/reactiveTypes";
import { Module } from "./Module";
export interface SerializableStore<T, S = any> {
    serialize(eid: number): S | undefined;
    deserialize(eid: number, data: S): void;
}
export declare class Store<T> {
    protected readonly map: Map<number, T>;
    constructor(initial?: Map<number, T>);
    get(eid: number): T | undefined;
    set(eid: number, value: T): void;
    delete(eid: number): void;
    entries(): IterableIterator<[number, T]>;
    has(eid: number): boolean;
    [Symbol.iterator](): IterableIterator<[number, T]>;
}
export declare class SetStore extends Store<Set<number>> implements SerializableStore<Set<number>, number[]> {
    serialize(eid: number): number[] | undefined;
    deserialize(eid: number, data: number[]): void;
}
export declare class LazySetStore extends SetStore {
    get(eid: number): Set<number>;
}
/**
 * Store for entity references that need to persist across saves/loads.
 *
 * IMPORTANT: This store works with entity IDs (eids) at runtime, but serialization
 * must convert to/from StableIDs. The conversion is handled in despawn.ts and spawn.ts.
 *
 * Runtime: Stores entity IDs (eids) - used by systems
 * Serialization: Converts to StableIDs - persists across saves
 * Deserialization: Converts from StableIDs back to eids - restores references
 */
export declare class StableIdReferenceStore extends LazySetStore {
}
export declare class UnlockedAchievementsStore extends Store<Set<string>> implements SerializableStore<Set<string>, string[]> {
    get(eid: number): Set<string>;
    serialize(eid: number): string[] | undefined;
    deserialize(eid: number, data: string[]): void;
}
export interface MetricData {
    [metricName: string]: {
        __value: number;
        [type: string]: number;
    };
}
export declare class MetricsStore extends Store<MetricData> implements SerializableStore<MetricData, MetricData> {
    serialize(eid: number): MetricData | undefined;
    deserialize(eid: number, data: MetricData): void;
}
export type InventorySlot = InventoryItem | null;
export type StockValue = {
    current: number;
    max: number;
    min?: number;
};
export declare class StockStore extends Store<StockValue> implements SerializableStore<StockValue, StockValue> {
    get(eid: number): StockValue;
    serialize(eid: number): StockValue | undefined;
    deserialize(eid: number, data: StockValue): void;
}
export declare class InventoryStore extends Store<Inventory> implements SerializableStore<Inventory, any> {
    serialize(eid: number): {
        size: number;
        selectedItemIndex: number;
        items: (string | Record<string, any>)[];
    };
    deserialize(eid: number, data: any): void;
}
export declare class AIMemoryStore extends Store<any> implements SerializableStore<any, any> {
    serialize(eid: number): any | undefined;
    deserialize(eid: number, data: any): void;
}
export declare class HeldItemsStore extends Store<{
    eid: number;
    slot: number;
}> implements SerializableStore<{
    eid: number;
    slot: number;
}, {
    eid: number;
    slot: number;
}> {
    serialize(eid: number): {
        eid: number;
        slot: number;
    } | undefined;
    deserialize(eid: number, data: {
        eid: number;
        slot: number;
    }): void;
}
export declare class InventoryCooldownsStore extends Store<ReactiveMap<number>> implements SerializableStore<ReactiveMap<number>, Record<string, number>> {
    serialize(eid: number): Record<string, number> | undefined;
    deserialize(eid: number, data: Record<string, number>): void;
}
export declare class ArchetypeRefStore extends Store<string> implements SerializableStore<string, string> {
    serialize(eid: number): string | undefined;
    deserialize(eid: number, data: string): void;
}
export declare class RulesStore extends Store<any[]> implements SerializableStore<any[], any[]> {
    serialize(eid: number): any[] | undefined;
    deserialize(eid: number, data: any[]): void;
}
type StoreOptions = {
    globalSerializable?: boolean;
};
export declare class EntityStoreModule extends Module<{
    type: string;
    params: any;
}, Store<any>> {
    private readonly instances;
    private readonly typeFactories;
    private readonly instanceMeta;
    constructor(ctx: ECSContext);
    registerStoreType(type: string, factory: () => Store<any>): void;
    registerStoreInstance(name: string, type: string, options?: StoreOptions): void;
    registerStore(name: string, factory: () => Store<any>, options?: StoreOptions): void;
    hasStore(name: string): boolean;
    getStoreType(name: string): string | undefined;
    listStoreInstances(): Array<{
        name: string;
        type: string;
    }>;
    getStore<T extends Store<any>>(name: string): T;
    serializeAll(): Record<string, any>;
    hydrateAll(data: Record<string, any>): void;
    forEachStore(fn: (name: string, store: Store<any>) => void): void;
}
export declare function entityStoreModule(ctx: ECSContext): EntityStoreModule;
export declare function getStore<T extends Store<any>>(ctx: ECSContext, name: string): T;
export declare function cleanupEntityStores(ctx: ECSContext, eid: number): void;
export {};
//# sourceMappingURL=entityStore.d.ts.map