import type { Config } from '../../../config/schema.js';
import type { GatewayService } from '../../service.js';
/** MCP block for GET/PATCH `/api/config` (authenticated console editing). */
export declare function buildSafeMcpConfigForWeb(config: Config): {
    servers: import("../../../config/mcp-config-normalize.js").ConfigMcpServers;
    sessionIdleTtlMs?: number;
};
export declare function buildSafeBrowserConfigForWeb(browser: unknown): {
    security?: unknown;
    limits?: unknown;
    observation?: unknown;
    driver?: {
        [x: string]: unknown;
    };
    enabled: boolean;
};
/** Sanitized config snapshot for GET/PATCH `/api/config` (matches persisted `service.currentConfig`). */
export declare function buildSafeWebConfigPayload(service: GatewayService, options?: {
    locale?: string;
}): Promise<{
    agents: {
        defaultId: string;
        list: {
            id: string;
            workspace: string;
            models: {
                chat?: {
                    primary: string;
                    fallbacks: string[];
                };
                intents?: Partial<Record<"review" | "coding" | "understanding" | "fast" | "reasoning" | "vision", {
                    primary: string;
                    fallbacks: string[];
                }>>;
                imageUnderstanding?: {
                    primary: string;
                    fallbacks: string[];
                };
                imageGeneration?: {
                    primary: string;
                    fallbacks: string[];
                    autoProviderFallback: boolean;
                    timeoutMs?: number;
                };
            };
            tools: Record<string, {
                mode: "allow" | "deny" | "ask";
                maxCallsPerTurn?: number;
                timeoutMs?: number;
            }>;
            skills: {
                mode: "merge";
                add: string[];
                remove: string[];
            } | {
                mode: "replace";
                include: string[];
            };
            workflows: {
                default?: string;
                allowed?: string[];
            };
        }[];
        defaults: {
            models: {
                chat: {
                    primary: string;
                    fallbacks: string[];
                };
                intents: Partial<Record<"review" | "coding" | "understanding" | "fast" | "reasoning" | "vision", {
                    primary: string;
                    fallbacks: string[];
                }>>;
                imageUnderstanding?: {
                    primary: string;
                    fallbacks: string[];
                };
                imageGeneration?: {
                    primary: string;
                    fallbacks: string[];
                    autoProviderFallback: boolean;
                    timeoutMs?: number;
                };
            };
            skills: {
                mode: "all-enabled";
                exclude: string[];
            } | {
                mode: "selected";
                include: string[];
            };
            tools: Record<string, {
                mode: "allow" | "deny" | "ask";
                maxCallsPerTurn?: number;
                timeoutMs?: number;
            }>;
            workflows: {
                default?: string;
                allowed?: string[];
            };
            runtime: {
                commandIsolation?: {
                    mode: "host";
                } | {
                    mode: "docker";
                    image: string;
                    network: boolean;
                };
                maxTurns?: number;
                timeoutMs?: number;
                maxToolFailuresPerTurn?: number;
                promptCache?: {
                    mode: "off" | "auto";
                    lifetime: "short" | "long";
                };
            };
        };
    };
    channels: {
        [k: string]: {
            enabled: boolean;
            configured: boolean;
            setupStatus: import("../../../channels/catalog/channel-catalog-types.js").ChannelSetupStatus;
            config: Record<string, unknown>;
            schema: Record<string, unknown>;
            uiHints: Record<string, import("../../../extensions/index.js").ChannelConfigUiHint>;
        };
    };
    providers: any;
    /** Masked `cfg.providers` for capability keys (image / STT / etc.). */
    providersConfig: Record<string, import("./safe-providers-config.js").SafeProviderAuthEntry>;
    gateway: {
        bind: "custom" | "auto" | "loopback" | "lan" | "tailnet";
        customBindHost: string;
        port: number;
        corsOrigins: string[];
        trustedProxies: string[];
        allowRealIpFallback: boolean;
        dangerouslyAllowHostHeaderOriginFallback: boolean;
        security: {
            strict: boolean;
        };
        auth: {
            mode: "token" | "password" | "none" | "trusted-proxy";
            token: string;
            password: string;
            trustedProxy: {
                userHeader: string;
                requiredHeaders: string[];
                allowUsers: string[];
                allowLoopback: boolean;
            };
            rateLimit: {
                enabled: boolean;
                maxAttempts: number;
                windowMs: number;
                blockDurationMs: number;
                exemptLoopback: boolean;
            };
        };
        heartbeat: {
            enabled: boolean;
            intervalMs: number;
            includeSystemPromptSection: boolean;
            target: string;
            targetChatId: string;
            prompt: string;
            ackMaxChars: number;
            isolatedSession: boolean;
            activeHours: {
                start: string;
                end: string;
                timezone?: string;
            };
        };
        webchat: {
            activityDetailDefault: "stream" | "on" | "off";
        };
        channelConnectDeferMode: "explicit" | "off" | "auto";
        channelConnectDeferIds: string[];
        channelConnectDeferSkipIds: string[];
        share: import("../../../share/share-types.js").ShareConfig;
        publicUrl: string;
        skillsMarketplaceProvider: string;
        skillsStoreBaseUrl: string;
    };
    browser: {
        security?: unknown;
        limits?: unknown;
        observation?: unknown;
        driver?: {
            [x: string]: unknown;
        };
        enabled: boolean;
    };
    session: {
        dmScope: "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
        storage: {
            pruneAfterDays: number;
            maxEntries: number;
        };
    };
    userContext: {
        preferences: {
            responseLanguage: "en" | "auto" | "zh-CN";
        };
        userModel: {
            enabled: boolean;
            writePolicy: "allow" | "confirm" | "deny";
            sensitiveWritePolicy: "allow" | "confirm" | "deny";
            processingPolicy: "local_only" | "remote_allowed";
            extraction: {
                reviewIntervalTurns: number;
                maxHistoryMessages: number;
                maxDurationMs: number;
            };
            maintenance: {
                enabled: boolean;
                temporalSweepMinutes: number;
                dailyTime: string;
                weeklyDay: "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
                weeklyTime: string;
                evidenceThreshold: number;
                limit: number;
                staleRetentionDays: number;
                timezone?: string;
            };
        };
        knowledgeMemory: {
            enabled: boolean;
            writePolicy: "allow" | "confirm" | "deny";
            sources: ("project" | "session" | "workspace" | "connector")[];
            searchStrategy: "local-first" | "external-first" | "fanout" | "local-only" | "external-only";
            writeStrategy: "local-first" | "external-first" | "local-only" | "external-only" | "write-through";
            allowExternalWrites: boolean;
            allowedProviderIds?: string[];
            autoWriteKinds?: string[];
        };
        contextPlanning: {
            enabled: boolean;
            maxAssertions: number;
            maxKnowledge: number;
            maxChars: number;
            compaction: {
                enabled: boolean;
                triggerThreshold: number;
                reserveTokens: number;
                minMessagesBeforeCompact: number;
                keepRecentTokens: number;
                recentTurnsPreserve: number;
                summaryMaxTokens: number;
                summaryChunkTokens: number;
                summaryTimeoutMs: number;
                summaryRetries: number;
                qualityGuard: boolean;
                gapAudit: boolean;
                minToolResultKeepChars: number;
                maxActiveTranscriptBytes: number;
                postCompactionSections: string[];
                model?: string;
            };
        };
    };
    tui: {
        defaultAgent: string;
    };
    tunnel: {
        enabled: boolean;
        autoStart: boolean;
        brokerUrl: string;
        registrationSecret: string;
        consent: {
            version: string;
            acceptedAt: string;
        };
        transport: {
            tls: "broker_terminated";
        };
    };
    update: {
        checkOnStart: boolean;
        channel: "stable" | "beta" | "dev";
        auto: {
            enabled: boolean;
            stableDelayHours: number;
            stableJitterHours: number;
            betaCheckIntervalHours: number;
        };
    };
    stt: unknown;
    tts: unknown;
    voice: unknown;
    tools: {
        web: {
            region: "cn" | "global" | null;
            search: {
                maxResults: number;
                providers: Array<{
                    type: string;
                    apiKey: string;
                    url: string;
                    disabled: boolean;
                }>;
            };
            blocklist: {
                enabled: boolean;
                domains: string[];
            };
        };
    };
    bindings: {
        agentId: string;
        priority: number;
        match: {
            channel: string;
            accountId?: string;
            peerKind?: string;
            peerId?: string;
            guildId?: string;
            teamId?: string;
            memberRoleIds?: string[];
        };
        enabled: boolean;
        id?: string;
    }[];
    mcp: {
        servers: import("../../../config/mcp-config-normalize.js").ConfigMcpServers;
        sessionIdleTtlMs?: number;
    };
}>;