/**
 * Workspace Manager — Stores per-project data outside the Mémoire repo.
 * Each project gets a workspace at ~/.memoire-workspaces/{workspace-id}/
 * keyed by SHA256 hash of the project's absolute path.
 */
import { z } from "zod";
declare const ProjectMetaSchema: z.ZodObject<{
    name: z.ZodString;
    path: z.ZodString;
    created: z.ZodString;
    lastAccessed: z.ZodString;
}, "strip", z.ZodTypeAny, {
    path: string;
    name: string;
    created: string;
    lastAccessed: string;
}, {
    path: string;
    name: string;
    created: string;
    lastAccessed: string;
}>;
export type ProjectMeta = z.infer<typeof ProjectMetaSchema>;
declare const DesignSystemDataSchema: z.ZodObject<{
    tokens: z.ZodDefault<z.ZodArray<z.ZodUnknown, "many">>;
    components: z.ZodDefault<z.ZodArray<z.ZodUnknown, "many">>;
    styles: z.ZodDefault<z.ZodArray<z.ZodUnknown, "many">>;
    lastSync: z.ZodDefault<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    components: unknown[];
    lastSync: string;
    styles: unknown[];
    tokens: unknown[];
}, {
    components?: unknown[] | undefined;
    lastSync?: string | undefined;
    styles?: unknown[] | undefined;
    tokens?: unknown[] | undefined;
}>;
export type DesignSystemData = z.infer<typeof DesignSystemDataSchema>;
declare const KnowledgeBaseSchema: z.ZodObject<{
    research: z.ZodOptional<z.ZodUnknown>;
    patterns: z.ZodOptional<z.ZodUnknown>;
    decisions: z.ZodOptional<z.ZodUnknown>;
}, "strip", z.ZodTypeAny, {
    research?: unknown;
    patterns?: unknown;
    decisions?: unknown;
}, {
    research?: unknown;
    patterns?: unknown;
    decisions?: unknown;
}>;
export type KnowledgeBase = z.infer<typeof KnowledgeBaseSchema>;
declare const ServerStateSchema: z.ZodObject<{
    port: z.ZodOptional<z.ZodNumber>;
    pid: z.ZodOptional<z.ZodNumber>;
    startedAt: z.ZodOptional<z.ZodString>;
    status: z.ZodDefault<z.ZodEnum<["running", "stopped"]>>;
}, "strip", z.ZodTypeAny, {
    status: "running" | "stopped";
    port?: number | undefined;
    startedAt?: string | undefined;
    pid?: number | undefined;
}, {
    status?: "running" | "stopped" | undefined;
    port?: number | undefined;
    startedAt?: string | undefined;
    pid?: number | undefined;
}>;
export type ServerState = z.infer<typeof ServerStateSchema>;
declare const GenerationEntrySchema: z.ZodObject<{
    timestamp: z.ZodString;
    specName: z.ZodString;
    status: z.ZodEnum<["success", "failed"]>;
    message: z.ZodString;
    files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    error: z.ZodOptional<z.ZodString>;
}, "strip", z.ZodTypeAny, {
    status: "success" | "failed";
    message: string;
    timestamp: string;
    specName: string;
    error?: string | undefined;
    files?: string[] | undefined;
}, {
    status: "success" | "failed";
    message: string;
    timestamp: string;
    specName: string;
    error?: string | undefined;
    files?: string[] | undefined;
}>;
export type GenerationEntry = z.infer<typeof GenerationEntrySchema>;
declare const RegistrySchema: z.ZodObject<{
    version: z.ZodLiteral<1>;
    entries: z.ZodRecord<z.ZodString, z.ZodObject<{
        workspaceId: z.ZodString;
        created: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        created: string;
        workspaceId: string;
    }, {
        created: string;
        workspaceId: string;
    }>>;
}, "strip", z.ZodTypeAny, {
    entries: Record<string, {
        created: string;
        workspaceId: string;
    }>;
    version: 1;
}, {
    entries: Record<string, {
        created: string;
        workspaceId: string;
    }>;
    version: 1;
}>;
export type WorkspaceRegistry = z.infer<typeof RegistrySchema>;
export declare class WorkspaceManager {
    private workspaceRoot;
    constructor(workspaceRoot?: string);
    /**
     * Generate a workspace ID from project path (SHA256 hash, first 12 chars)
     */
    private generateWorkspaceId;
    /**
     * Get the workspace directory for a project
     */
    private getWorkspaceDir;
    /**
     * Load or initialize the workspace registry
     */
    private loadRegistry;
    /**
     * Save the workspace registry
     */
    private saveRegistry;
    /**
     * Get or create a workspace for a project
     */
    getWorkspace(projectPath: string): Promise<ProjectMeta>;
    /**
     * List all known workspaces
     */
    listWorkspaces(): Promise<ProjectMeta[]>;
    /**
     * Clean up a workspace (reset all project data)
     */
    cleanWorkspace(projectPath: string): Promise<void>;
    /**
     * Read cached design system
     */
    getDesignSystem(projectPath: string): Promise<DesignSystemData | null>;
    /**
     * Write design system
     */
    saveDesignSystem(projectPath: string, data: DesignSystemData): Promise<void>;
    /**
     * Read knowledge base
     */
    getKnowledge(projectPath: string): Promise<KnowledgeBase | null>;
    /**
     * Write to knowledge base
     */
    saveKnowledge(projectPath: string, key: "research" | "patterns" | "decisions", data: unknown): Promise<void>;
    /**
     * Read server state
     */
    getServerState(projectPath: string): Promise<ServerState | null>;
    /**
     * Write server state
     */
    saveServerState(projectPath: string, state: ServerState): Promise<void>;
    /**
     * Append to codegen history
     */
    logGeneration(projectPath: string, entry: GenerationEntry): Promise<void>;
}
/**
 * Singleton workspace manager instance
 */
export declare const workspace: WorkspaceManager;
export {};