import { z } from "zod";
export declare const taskBindingSchema: z.ZodObject<{
    provider: z.ZodString;
    model: z.ZodString;
}, "strip", z.ZodTypeAny, {
    model: string;
    provider: string;
}, {
    model: string;
    provider: string;
}>;
export declare const providerEntrySchema: z.ZodObject<{
    package: z.ZodString;
    enabled: z.ZodDefault<z.ZodBoolean>;
    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    package: string;
    enabled: boolean;
    config: Record<string, unknown>;
}, {
    package: string;
    enabled?: boolean | undefined;
    config?: Record<string, unknown> | undefined;
}>;
export declare const adapterEntrySchema: z.ZodObject<{
    package: z.ZodString;
    enabled: z.ZodDefault<z.ZodBoolean>;
    schedule: z.ZodOptional<z.ZodString>;
    config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    package: string;
    enabled: boolean;
    config: Record<string, unknown>;
    schedule?: string | undefined;
}, {
    package: string;
    enabled?: boolean | undefined;
    config?: Record<string, unknown> | undefined;
    schedule?: string | undefined;
}>;
export declare const memoryBackendName: z.ZodEnum<["engram", "pgvector"]>;
export declare const memoryConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Primary backend. Falls back to `fallback` at startup if unhealthy. */
    primary: z.ZodDefault<z.ZodEnum<["engram", "pgvector"]>>;
    /** Optional fallback backend. Omit or set equal to primary for none. */
    fallback: z.ZodOptional<z.ZodEnum<["engram", "pgvector"]>>;
    engram: z.ZodDefault<z.ZodObject<{
        command: z.ZodOptional<z.ZodString>;
        args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, "strip", z.ZodTypeAny, {
        args: string[];
        env: Record<string, string>;
        command?: string | undefined;
    }, {
        command?: string | undefined;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
    }>>;
    pgvector: z.ZodDefault<z.ZodObject<{
        /**
         * 'external' (default) connects to a real Postgres server via
         * connectionString. 'embedded' spawns PGlite in-process — no
         * Docker, no system PG, no port. The Pyre 'Install Cortex'
         * flow defaults to embedded so the user gets a working KB
         * with zero external setup.
         */
        mode: z.ZodDefault<z.ZodEnum<["external", "embedded"]>>;
        connectionString: z.ZodOptional<z.ZodString>;
        /**
         * Filesystem path for the embedded PGlite database. Required
         * when mode='embedded'; ignored otherwise. Path can be relative
         * (resolved against cwd at boot) or absolute.
         */
        dataDir: z.ZodOptional<z.ZodString>;
        table: z.ZodDefault<z.ZodString>;
        embeddingDim: z.ZodDefault<z.ZodNumber>;
        /** Task id to use when calling router.embed(). Default: 'embed'. */
        embedTask: z.ZodDefault<z.ZodString>;
        /**
         * Force the bundled local Xenova embedder even when an LLM router
         * is configured. Set true when your chosen LLM provider doesn't
         * have an embedding model — most common case: Azure OpenAI behind
         * the openrouter shim, where the configured chat model
         * (gpt-4o-mini) is not an embedding model and Azure embedding
         * deployments are a separate resource. Without this, every
         * kb_search query 500s with `Provider does not support embeddings`.
         * Default false to preserve behavior for operators with
         * embedding-capable providers (real OpenRouter, Ollama with an
         * embedding model loaded, etc.).
         */
        useLocalEmbedder: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        table: string;
        embeddingDim: number;
        mode: "external" | "embedded";
        embedTask: string;
        useLocalEmbedder: boolean;
        connectionString?: string | undefined;
        dataDir?: string | undefined;
    }, {
        table?: string | undefined;
        embeddingDim?: number | undefined;
        connectionString?: string | undefined;
        mode?: "external" | "embedded" | undefined;
        dataDir?: string | undefined;
        embedTask?: string | undefined;
        useLocalEmbedder?: boolean | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    pgvector: {
        table: string;
        embeddingDim: number;
        mode: "external" | "embedded";
        embedTask: string;
        useLocalEmbedder: boolean;
        connectionString?: string | undefined;
        dataDir?: string | undefined;
    };
    engram: {
        args: string[];
        env: Record<string, string>;
        command?: string | undefined;
    };
    primary: "pgvector" | "engram";
    fallback?: "pgvector" | "engram" | undefined;
}, {
    pgvector?: {
        table?: string | undefined;
        embeddingDim?: number | undefined;
        connectionString?: string | undefined;
        mode?: "external" | "embedded" | undefined;
        dataDir?: string | undefined;
        embedTask?: string | undefined;
        useLocalEmbedder?: boolean | undefined;
    } | undefined;
    engram?: {
        command?: string | undefined;
        args?: string[] | undefined;
        env?: Record<string, string> | undefined;
    } | undefined;
    primary?: "pgvector" | "engram" | undefined;
    fallback?: "pgvector" | "engram" | undefined;
}>>;
export declare const webhooksConfigSchema: z.ZodDefault<z.ZodObject<{
    /** Off by default — webhooks only start when an operator explicitly opts in. */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /** Bind host. 0.0.0.0 so a reverse proxy / Tailscale Funnel can forward. */
    host: z.ZodDefault<z.ZodString>;
    port: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    host: string;
    port: number;
}, {
    enabled?: boolean | undefined;
    host?: string | undefined;
    port?: number | undefined;
}>>;
export declare const apiConfigSchema: z.ZodDefault<z.ZodObject<{
    /**
     * Off by default — the dashboard API only boots when the operator opts
     * in. Like webhooks, it's a new surface and should stay dormant until
     * an operator explicitly wants it. Install scripts targeting remote
     * deploys (curl|sh, docker-compose) flip this to true.
     */
    enabled: z.ZodDefault<z.ZodBoolean>;
    /**
     * Bind host. Localhost by default because the dashboard is a per-user
     * local app; exposing the API over a LAN/Tailscale is an opt-in move.
     * Remote installs override to 0.0.0.0.
     */
    host: z.ZodDefault<z.ZodString>;
    port: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
    host: string;
    port: number;
}, {
    enabled?: boolean | undefined;
    host?: string | undefined;
    port?: number | undefined;
}>>;
export declare const mcpConfigSchema: z.ZodDefault<z.ZodObject<{
    /**
     * Transport for the MCP server. 'stdio' = subprocess (Pyre / Claude
     * Desktop launch Cortex per-session). 'http' = long-running HTTP
     * server (remote VPS deploys, hosted Cortex, anything where a
     * client connects over the network). Env var PRZM_CORTEX_MCP_TRANSPORT
     * still works as an override at boot.
     */
    transport: z.ZodDefault<z.ZodEnum<["stdio", "http"]>>;
    /**
     * Host to bind when transport='http'. 127.0.0.1 by default for
     * local installs; remote deploys override to 0.0.0.0 (firewall
     * or reverse proxy in front).
     */
    host: z.ZodDefault<z.ZodString>;
    port: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
    host: string;
    port: number;
    transport: "stdio" | "http";
}, {
    host?: string | undefined;
    port?: number | undefined;
    transport?: "stdio" | "http" | undefined;
}>>;
/**
 * Per-extractor opt-in config (ADR-020). Each key is an extractor name.
 * Off by default — omitting the key or setting `enabled: false` disables
 * the extractor. Only takes effect when an LLM provider is configured.
 * Available extractors: `summary`, `keywords`.
 */
export declare const extractorEntrySchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    enabled: boolean;
}, {
    enabled?: boolean | undefined;
}>;
export declare const extractorsConfigSchema: z.ZodDefault<z.ZodObject<{
    /** LLM-generated 1–3 sentence gist → metadata.summary */
    summary: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
    }, {
        enabled?: boolean | undefined;
    }>>;
    /** LLM-extracted domain terms/acronyms/jargon → metadata.keywords[] */
    keywords: z.ZodDefault<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
    }, {
        enabled?: boolean | undefined;
    }>>;
}, "strip", z.ZodTypeAny, {
    summary: {
        enabled: boolean;
    };
    keywords: {
        enabled: boolean;
    };
}, {
    summary?: {
        enabled?: boolean | undefined;
    } | undefined;
    keywords?: {
        enabled?: boolean | undefined;
    } | undefined;
}>>;
export type ExtractorsConfig = z.infer<typeof extractorsConfigSchema>;
export type ExtractorEntry = z.infer<typeof extractorEntrySchema>;
/**
 * Customer-extensible memory taxonomy. Built-in canonical types are
 * defined in `@onenomad/przm-cortex-core > BUILT_IN_MEMORY_TYPES`; this
 * stanza adds per-workspace types on top. `source: "auto"` entries
 * are the ones the ingest path registered from unknown classifier
 * output — operators promote them to `"config"` (or delete them) from
 * the dashboard's Memory Types tab.
 */
export declare const customMemoryTypeSchema: z.ZodObject<{
    slug: z.ZodString;
    label: z.ZodOptional<z.ZodString>;
    description: z.ZodOptional<z.ZodString>;
    source: z.ZodDefault<z.ZodEnum<["config", "auto"]>>;
}, "strip", z.ZodTypeAny, {
    source: "config" | "auto";
    slug: string;
    label?: string | undefined;
    description?: string | undefined;
}, {
    slug: string;
    source?: "config" | "auto" | undefined;
    label?: string | undefined;
    description?: string | undefined;
}>;
export declare const taxonomyConfigSchema: z.ZodDefault<z.ZodObject<{
    customTypes: z.ZodDefault<z.ZodArray<z.ZodObject<{
        slug: z.ZodString;
        label: z.ZodOptional<z.ZodString>;
        description: z.ZodOptional<z.ZodString>;
        source: z.ZodDefault<z.ZodEnum<["config", "auto"]>>;
    }, "strip", z.ZodTypeAny, {
        source: "config" | "auto";
        slug: string;
        label?: string | undefined;
        description?: string | undefined;
    }, {
        slug: string;
        source?: "config" | "auto" | undefined;
        label?: string | undefined;
        description?: string | undefined;
    }>, "many">>;
}, "strip", z.ZodTypeAny, {
    customTypes: {
        source: "config" | "auto";
        slug: string;
        label?: string | undefined;
        description?: string | undefined;
    }[];
}, {
    customTypes?: {
        slug: string;
        source?: "config" | "auto" | undefined;
        label?: string | undefined;
        description?: string | undefined;
    }[] | undefined;
}>>;
export declare const cortexConfigSchema: z.ZodObject<{
    llm: z.ZodObject<{
        providers: z.ZodRecord<z.ZodString, z.ZodObject<{
            package: z.ZodString;
            enabled: z.ZodDefault<z.ZodBoolean>;
            config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, "strip", z.ZodTypeAny, {
            package: string;
            enabled: boolean;
            config: Record<string, unknown>;
        }, {
            package: string;
            enabled?: boolean | undefined;
            config?: Record<string, unknown> | undefined;
        }>>;
        tasks: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
            provider: z.ZodString;
            model: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            model: string;
            provider: string;
        }, {
            model: string;
            provider: string;
        }>>, Record<string, {
            model: string;
            provider: string;
        }>, Record<string, {
            model: string;
            provider: string;
        }>>;
        fallbackChain: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        providers: Record<string, {
            package: string;
            enabled: boolean;
            config: Record<string, unknown>;
        }>;
        tasks: Record<string, {
            model: string;
            provider: string;
        }>;
        fallbackChain: string[];
    }, {
        providers: Record<string, {
            package: string;
            enabled?: boolean | undefined;
            config?: Record<string, unknown> | undefined;
        }>;
        tasks: Record<string, {
            model: string;
            provider: string;
        }>;
        fallbackChain?: string[] | undefined;
    }>;
    memory: z.ZodDefault<z.ZodObject<{
        /** Primary backend. Falls back to `fallback` at startup if unhealthy. */
        primary: z.ZodDefault<z.ZodEnum<["engram", "pgvector"]>>;
        /** Optional fallback backend. Omit or set equal to primary for none. */
        fallback: z.ZodOptional<z.ZodEnum<["engram", "pgvector"]>>;
        engram: z.ZodDefault<z.ZodObject<{
            command: z.ZodOptional<z.ZodString>;
            args: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
            env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
        }, "strip", z.ZodTypeAny, {
            args: string[];
            env: Record<string, string>;
            command?: string | undefined;
        }, {
            command?: string | undefined;
            args?: string[] | undefined;
            env?: Record<string, string> | undefined;
        }>>;
        pgvector: z.ZodDefault<z.ZodObject<{
            /**
             * 'external' (default) connects to a real Postgres server via
             * connectionString. 'embedded' spawns PGlite in-process — no
             * Docker, no system PG, no port. The Pyre 'Install Cortex'
             * flow defaults to embedded so the user gets a working KB
             * with zero external setup.
             */
            mode: z.ZodDefault<z.ZodEnum<["external", "embedded"]>>;
            connectionString: z.ZodOptional<z.ZodString>;
            /**
             * Filesystem path for the embedded PGlite database. Required
             * when mode='embedded'; ignored otherwise. Path can be relative
             * (resolved against cwd at boot) or absolute.
             */
            dataDir: z.ZodOptional<z.ZodString>;
            table: z.ZodDefault<z.ZodString>;
            embeddingDim: z.ZodDefault<z.ZodNumber>;
            /** Task id to use when calling router.embed(). Default: 'embed'. */
            embedTask: z.ZodDefault<z.ZodString>;
            /**
             * Force the bundled local Xenova embedder even when an LLM router
             * is configured. Set true when your chosen LLM provider doesn't
             * have an embedding model — most common case: Azure OpenAI behind
             * the openrouter shim, where the configured chat model
             * (gpt-4o-mini) is not an embedding model and Azure embedding
             * deployments are a separate resource. Without this, every
             * kb_search query 500s with `Provider does not support embeddings`.
             * Default false to preserve behavior for operators with
             * embedding-capable providers (real OpenRouter, Ollama with an
             * embedding model loaded, etc.).
             */
            useLocalEmbedder: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            table: string;
            embeddingDim: number;
            mode: "external" | "embedded";
            embedTask: string;
            useLocalEmbedder: boolean;
            connectionString?: string | undefined;
            dataDir?: string | undefined;
        }, {
            table?: string | undefined;
            embeddingDim?: number | undefined;
            connectionString?: string | undefined;
            mode?: "external" | "embedded" | undefined;
            dataDir?: string | undefined;
            embedTask?: string | undefined;
            useLocalEmbedder?: boolean | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        pgvector: {
            table: string;
            embeddingDim: number;
            mode: "external" | "embedded";
            embedTask: string;
            useLocalEmbedder: boolean;
            connectionString?: string | undefined;
            dataDir?: string | undefined;
        };
        engram: {
            args: string[];
            env: Record<string, string>;
            command?: string | undefined;
        };
        primary: "pgvector" | "engram";
        fallback?: "pgvector" | "engram" | undefined;
    }, {
        pgvector?: {
            table?: string | undefined;
            embeddingDim?: number | undefined;
            connectionString?: string | undefined;
            mode?: "external" | "embedded" | undefined;
            dataDir?: string | undefined;
            embedTask?: string | undefined;
            useLocalEmbedder?: boolean | undefined;
        } | undefined;
        engram?: {
            command?: string | undefined;
            args?: string[] | undefined;
            env?: Record<string, string> | undefined;
        } | undefined;
        primary?: "pgvector" | "engram" | undefined;
        fallback?: "pgvector" | "engram" | undefined;
    }>>;
    webhooks: z.ZodDefault<z.ZodObject<{
        /** Off by default — webhooks only start when an operator explicitly opts in. */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /** Bind host. 0.0.0.0 so a reverse proxy / Tailscale Funnel can forward. */
        host: z.ZodDefault<z.ZodString>;
        port: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        host: string;
        port: number;
    }, {
        enabled?: boolean | undefined;
        host?: string | undefined;
        port?: number | undefined;
    }>>;
    api: z.ZodDefault<z.ZodObject<{
        /**
         * Off by default — the dashboard API only boots when the operator opts
         * in. Like webhooks, it's a new surface and should stay dormant until
         * an operator explicitly wants it. Install scripts targeting remote
         * deploys (curl|sh, docker-compose) flip this to true.
         */
        enabled: z.ZodDefault<z.ZodBoolean>;
        /**
         * Bind host. Localhost by default because the dashboard is a per-user
         * local app; exposing the API over a LAN/Tailscale is an opt-in move.
         * Remote installs override to 0.0.0.0.
         */
        host: z.ZodDefault<z.ZodString>;
        port: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        enabled: boolean;
        host: string;
        port: number;
    }, {
        enabled?: boolean | undefined;
        host?: string | undefined;
        port?: number | undefined;
    }>>;
    mcp: z.ZodDefault<z.ZodObject<{
        /**
         * Transport for the MCP server. 'stdio' = subprocess (Pyre / Claude
         * Desktop launch Cortex per-session). 'http' = long-running HTTP
         * server (remote VPS deploys, hosted Cortex, anything where a
         * client connects over the network). Env var PRZM_CORTEX_MCP_TRANSPORT
         * still works as an override at boot.
         */
        transport: z.ZodDefault<z.ZodEnum<["stdio", "http"]>>;
        /**
         * Host to bind when transport='http'. 127.0.0.1 by default for
         * local installs; remote deploys override to 0.0.0.0 (firewall
         * or reverse proxy in front).
         */
        host: z.ZodDefault<z.ZodString>;
        port: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        host: string;
        port: number;
        transport: "stdio" | "http";
    }, {
        host?: string | undefined;
        port?: number | undefined;
        transport?: "stdio" | "http" | undefined;
    }>>;
    adapters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
        package: z.ZodString;
        enabled: z.ZodDefault<z.ZodBoolean>;
        schedule: z.ZodOptional<z.ZodString>;
        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    }, "strip", z.ZodTypeAny, {
        package: string;
        enabled: boolean;
        config: Record<string, unknown>;
        schedule?: string | undefined;
    }, {
        package: string;
        enabled?: boolean | undefined;
        config?: Record<string, unknown> | undefined;
        schedule?: string | undefined;
    }>>>;
    taxonomy: z.ZodDefault<z.ZodObject<{
        customTypes: z.ZodDefault<z.ZodArray<z.ZodObject<{
            slug: z.ZodString;
            label: z.ZodOptional<z.ZodString>;
            description: z.ZodOptional<z.ZodString>;
            source: z.ZodDefault<z.ZodEnum<["config", "auto"]>>;
        }, "strip", z.ZodTypeAny, {
            source: "config" | "auto";
            slug: string;
            label?: string | undefined;
            description?: string | undefined;
        }, {
            slug: string;
            source?: "config" | "auto" | undefined;
            label?: string | undefined;
            description?: string | undefined;
        }>, "many">>;
    }, "strip", z.ZodTypeAny, {
        customTypes: {
            source: "config" | "auto";
            slug: string;
            label?: string | undefined;
            description?: string | undefined;
        }[];
    }, {
        customTypes?: {
            slug: string;
            source?: "config" | "auto" | undefined;
            label?: string | undefined;
            description?: string | undefined;
        }[] | undefined;
    }>>;
    /**
     * Ingest-time LLM enrichment extractors (ADR-020). Each extractor is
     * individually opt-in and off by default. Only runs when an LLM
     * provider is configured. See `extractorsConfigSchema` for the full
     * list of available extractors.
     */
    extractors: z.ZodDefault<z.ZodObject<{
        /** LLM-generated 1–3 sentence gist → metadata.summary */
        summary: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
        }, {
            enabled?: boolean | undefined;
        }>>;
        /** LLM-extracted domain terms/acronyms/jargon → metadata.keywords[] */
        keywords: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            enabled: boolean;
        }, {
            enabled?: boolean | undefined;
        }>>;
    }, "strip", z.ZodTypeAny, {
        summary: {
            enabled: boolean;
        };
        keywords: {
            enabled: boolean;
        };
    }, {
        summary?: {
            enabled?: boolean | undefined;
        } | undefined;
        keywords?: {
            enabled?: boolean | undefined;
        } | undefined;
    }>>;
    /**
     * Absolute paths to private/personal Cortex module directories
     * loaded at startup. Each must contain a `dist/index.js` exporting
     * `mcpTools`. See `server/src/private-modules.ts` + the companion
     * `cortex-private/` repo for the contract. Empty by default.
     */
    privateModules: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    memory: {
        pgvector: {
            table: string;
            embeddingDim: number;
            mode: "external" | "embedded";
            embedTask: string;
            useLocalEmbedder: boolean;
            connectionString?: string | undefined;
            dataDir?: string | undefined;
        };
        engram: {
            args: string[];
            env: Record<string, string>;
            command?: string | undefined;
        };
        primary: "pgvector" | "engram";
        fallback?: "pgvector" | "engram" | undefined;
    };
    llm: {
        providers: Record<string, {
            package: string;
            enabled: boolean;
            config: Record<string, unknown>;
        }>;
        tasks: Record<string, {
            model: string;
            provider: string;
        }>;
        fallbackChain: string[];
    };
    webhooks: {
        enabled: boolean;
        host: string;
        port: number;
    };
    api: {
        enabled: boolean;
        host: string;
        port: number;
    };
    mcp: {
        host: string;
        port: number;
        transport: "stdio" | "http";
    };
    adapters: Record<string, {
        package: string;
        enabled: boolean;
        config: Record<string, unknown>;
        schedule?: string | undefined;
    }>;
    taxonomy: {
        customTypes: {
            source: "config" | "auto";
            slug: string;
            label?: string | undefined;
            description?: string | undefined;
        }[];
    };
    extractors: {
        summary: {
            enabled: boolean;
        };
        keywords: {
            enabled: boolean;
        };
    };
    privateModules: string[];
}, {
    llm: {
        providers: Record<string, {
            package: string;
            enabled?: boolean | undefined;
            config?: Record<string, unknown> | undefined;
        }>;
        tasks: Record<string, {
            model: string;
            provider: string;
        }>;
        fallbackChain?: string[] | undefined;
    };
    memory?: {
        pgvector?: {
            table?: string | undefined;
            embeddingDim?: number | undefined;
            connectionString?: string | undefined;
            mode?: "external" | "embedded" | undefined;
            dataDir?: string | undefined;
            embedTask?: string | undefined;
            useLocalEmbedder?: boolean | undefined;
        } | undefined;
        engram?: {
            command?: string | undefined;
            args?: string[] | undefined;
            env?: Record<string, string> | undefined;
        } | undefined;
        primary?: "pgvector" | "engram" | undefined;
        fallback?: "pgvector" | "engram" | undefined;
    } | undefined;
    webhooks?: {
        enabled?: boolean | undefined;
        host?: string | undefined;
        port?: number | undefined;
    } | undefined;
    api?: {
        enabled?: boolean | undefined;
        host?: string | undefined;
        port?: number | undefined;
    } | undefined;
    mcp?: {
        host?: string | undefined;
        port?: number | undefined;
        transport?: "stdio" | "http" | undefined;
    } | undefined;
    adapters?: Record<string, {
        package: string;
        enabled?: boolean | undefined;
        config?: Record<string, unknown> | undefined;
        schedule?: string | undefined;
    }> | undefined;
    taxonomy?: {
        customTypes?: {
            slug: string;
            source?: "config" | "auto" | undefined;
            label?: string | undefined;
            description?: string | undefined;
        }[] | undefined;
    } | undefined;
    extractors?: {
        summary?: {
            enabled?: boolean | undefined;
        } | undefined;
        keywords?: {
            enabled?: boolean | undefined;
        } | undefined;
    } | undefined;
    privateModules?: string[] | undefined;
}>;
export type WebhooksConfig = z.infer<typeof webhooksConfigSchema>;
export type ApiConfig = z.infer<typeof apiConfigSchema>;
export type TaxonomyConfig = z.infer<typeof taxonomyConfigSchema>;
export type CustomMemoryTypeConfig = z.infer<typeof customMemoryTypeSchema>;
export type MemoryConfig = z.infer<typeof memoryConfigSchema>;
export type MemoryBackendName = z.infer<typeof memoryBackendName>;
export type CortexConfig = z.infer<typeof cortexConfigSchema>;
export type ProviderEntry = z.infer<typeof providerEntrySchema>;
export type AdapterEntry = z.infer<typeof adapterEntrySchema>;
/**
 * Loads and validates cortex.yaml.
 *
 * Resolution order (first hit wins):
 *   1. `<dir>/<name>.local.yaml`   — caller's real, gitignored config
 *   2. `<dir>/<name>.yaml`         — committed template
 *
 * Rationale: real deployment data (workspace names, space keys, client
 * mappings) must never be committed. Operators write their real config into
 * `cortex.local.yaml`, which is in .gitignore, and the loader transparently
 * prefers it. See docs/PRIVACY.md.
 *
 * Expands `${ENV_VAR}` references from `process.env` in string values.
 */
export declare function loadCortexConfig(configPath: string): Promise<CortexConfig>;
/**
 * Select fields (today: api.host / api.port / api.enabled) can be overridden
 * via env vars so a Docker image or VPS deploy doesn't need to hand-edit a
 * user's workspace config. The overrides kick in only when the env var is
 * present — absent vars leave the YAML value untouched.
 */
export declare function applyEnvOverrides(cfg: CortexConfig): CortexConfig;
/**
 * Given a path like `config/cortex.yaml`, prefer `config/cortex.local.yaml`
 * if it exists. Same-directory, same-basename, `.local.yaml` suffix. Used by
 * every config loader (cortex.yaml, projects.yaml, people.yaml, future
 * engagements.yaml) so the pattern is uniform.
 */
export declare function resolveLocalFirst(configPath: string): Promise<string>;
/**
 * `${FOO}` in YAML string positions is replaced with process.env.FOO. Throws
 * a readable error listing every missing/empty variable so the user knows
 * which .env entry to fill in, rather than surfacing as an opaque Zod
 * validation error downstream.
 *
 * Lines starting with `#` are treated as YAML comments and left untouched,
 * so commented-out config blocks don't require their env vars to be set.
 */
export declare function expandEnv(text: string): string;
//# sourceMappingURL=config.d.ts.map