/**
 * Represents an observation in the memory store
 */
export interface Observation {
    text: string;
    timestamp: string;
    version?: string;
}
/**
 * Query parameters for searching observations
 */
export interface MemoryQuery {
    keyword?: string;
    time?: {
        before?: string;
        after?: string;
    };
    tag?: string;
    agent?: string;
    limit?: number;
}
/**
 * Entity interface for backward compatibility
 */
export interface Entity {
    name: string;
    entityType: string;
    observations: string[];
}
/**
 * Relation interface for backward compatibility
 */
export interface Relation {
    from: string;
    to: string;
    relationType: string;
}
/**
 * Interface for memory storage implementations
 */
export interface MemoryStore {
    /**
     * Add a new observation to the store
     * @param entityName - Entity to associate the observation with
     * @param text - The observation text
     * @param metadata - Optional metadata for the observation
     * @returns The stored observation with generated metadata
     */
    add(entityName: string, text: string, metadata?: {
        version?: string;
        tags?: string[];
        agent?: string;
    }): Promise<Observation>;
    /**
     * Query observations based on filter criteria
     * @param query - Query parameters
     * @returns Array of matching observations
     */
    query(query: MemoryQuery): Promise<{
        entityName: string;
        observation: Observation;
    }[]>;
    /**
     * Prune observations from the store
     * @param options - Pruning options
     * @returns Count of pruned observations
     */
    prune(options: {
        before?: string;
        tag?: string;
        deprecate?: boolean;
    }): Promise<number>;
    /**
     * Find similar entity names based on the provided name
     * @param name - The name to find similar entities for
     * @returns Array of similar entity names
     */
    findSimilar(name: string): Promise<string[]>;
    /**
     * Save current state of the memory store
     * @returns Promise resolving when save is complete
     */
    save(): Promise<void>;
    /**
     * Load data into the memory store
     * @returns Promise resolving when load is complete
     */
    load(): Promise<void>;
    /**
     * Get the loading promise
     * @returns Promise that resolves when loading is complete
     */
    getLoadingPromise(): Promise<void>;
    /**
     * Backward compatibility method: Add a new entity to the graph
     * @param entity - The entity to add
     * @returns Promise resolving to true if the entity was added, false if it already exists
     */
    addEntity(entity: Entity): Promise<boolean>;
    /**
     * Backward compatibility method: Add a new relation between entities
     * @param relation - The relation to add
     * @returns Promise resolving to true if the relation was added, false if invalid or already exists
     */
    addRelation(relation: Relation): Promise<boolean>;
}
//# sourceMappingURL=MemoryStore.d.ts.map