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): {
    enabled: boolean;
    headless: boolean;
    allowPrivateUrls: boolean;
    commandTimeout: number;
    backend: unknown;
    cloudProvider: unknown;
    cloud: Record<string, unknown>;
    cdpUrl: string;
    extension: unknown;
    cloakbrowser: unknown;
    humanize: unknown;
    humanPreset: unknown;
    dialogPolicy: unknown;
    dialogTimeoutSeconds: number;
};
/** 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;
            identity: {
                name: string;
                role: string;
                language: string;
                tone: string;
                description?: string;
                avatar?: string;
            };
            workspace: {
                root: string;
            };
            models: {
                defaultRole?: string;
                roles?: Record<string, {
                    model: string;
                    fallbacks?: string[];
                    description?: string;
                }>;
                imageModel?: {
                    primary: string;
                    fallbacks?: string[];
                    timeoutMs?: number;
                    autoProviderFallback?: boolean;
                };
                imageGenerationModel?: {
                    primary: string;
                    fallbacks?: string[];
                    timeoutMs?: number;
                    autoProviderFallback?: boolean;
                };
                policy?: {
                    allowFallbacks?: boolean;
                    maxCostTier?: "low" | "high" | "medium";
                };
            };
            tools: {
                builtin?: Record<string, {
                    mode: "allow" | "deny" | "confirm";
                    scope?: "workspace" | "readonly" | "unrestricted";
                    limits?: {
                        maxCallsPerTurn?: number;
                        timeoutMs?: number;
                    };
                }>;
                mcp?: {
                    servers?: Record<string, {
                        mode: "allow" | "deny" | "confirm";
                        scope?: "workspace" | "readonly" | "unrestricted";
                        limits?: {
                            maxCallsPerTurn?: number;
                            timeoutMs?: number;
                        };
                    }>;
                    tools?: Record<string, {
                        mode: "allow" | "deny" | "confirm";
                        scope?: "workspace" | "readonly" | "unrestricted";
                        limits?: {
                            maxCallsPerTurn?: number;
                            timeoutMs?: number;
                        };
                    }>;
                };
            };
            skills: {
                mode: "off" | "all" | "allowlist" | "denylist";
                allow?: string[];
                deny?: string[];
            };
            workflows: {
                default?: string;
                allowed?: string[];
                suggested?: {
                    intent: string;
                    workflow: string;
                }[];
            };
            boundaries: {
                requiresConfirmation?: string[];
                forbidden?: string[];
                escalation?: string[];
            };
        }[];
        capabilityPresets: Record<string, {
            id: string;
            name: string;
            version: number;
            description?: string;
            extends?: string[];
            models?: {
                defaultRole?: string;
                roles?: Record<string, {
                    model: string;
                    fallbacks?: string[];
                    description?: string;
                }>;
                imageModel?: {
                    primary: string;
                    fallbacks?: string[];
                    timeoutMs?: number;
                    autoProviderFallback?: boolean;
                };
                imageGenerationModel?: {
                    primary: string;
                    fallbacks?: string[];
                    timeoutMs?: number;
                    autoProviderFallback?: boolean;
                };
                policy?: {
                    allowFallbacks?: boolean;
                    maxCostTier?: "low" | "high" | "medium";
                };
            };
            tools?: {
                builtin?: Record<string, {
                    mode: "allow" | "deny" | "confirm";
                    scope?: "workspace" | "readonly" | "unrestricted";
                    limits?: {
                        maxCallsPerTurn?: number;
                        timeoutMs?: number;
                    };
                }>;
                mcp?: {
                    servers?: Record<string, {
                        mode: "allow" | "deny" | "confirm";
                        scope?: "workspace" | "readonly" | "unrestricted";
                        limits?: {
                            maxCallsPerTurn?: number;
                            timeoutMs?: number;
                        };
                    }>;
                    tools?: Record<string, {
                        mode: "allow" | "deny" | "confirm";
                        scope?: "workspace" | "readonly" | "unrestricted";
                        limits?: {
                            maxCallsPerTurn?: number;
                            timeoutMs?: number;
                        };
                    }>;
                };
            };
            skills?: {
                mode: "off" | "all" | "allowlist" | "denylist";
                allow?: string[];
                deny?: string[];
            };
            workflows?: {
                default?: string;
                allowed?: string[];
                suggested?: {
                    intent: string;
                    workflow: string;
                }[];
            };
            boundaries?: {
                requiresConfirmation?: string[];
                forbidden?: string[];
                escalation?: string[];
            };
            runtime?: {
                maxTurns?: number;
                timeoutMs?: number;
                maxToolFailuresPerTurn?: number;
                promptCacheRetention?: "none" | "short" | "long";
            };
            locks?: string[];
        }>;
    };
    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: {
        enabled: boolean;
        headless: boolean;
        allowPrivateUrls: boolean;
        commandTimeout: number;
        backend: unknown;
        cloudProvider: unknown;
        cloud: Record<string, unknown>;
        cdpUrl: string;
        extension: unknown;
        cloakbrowser: unknown;
        humanize: unknown;
        humanPreset: unknown;
        dialogPolicy: unknown;
        dialogTimeoutSeconds: number;
    };
    session: {
        dmScope: "main" | "per-peer" | "per-channel-peer" | "per-account-channel-peer";
        storage: {
            pruneAfterDays: number;
            maxEntries: number;
        };
    };
    userContext: {
        preferences: {
            responseLanguage: "auto" | "zh-CN" | "en";
        };
        dreaming: {
            mode: "off" | "review";
            schedule: {
                time: string;
            };
            minEvidenceSources: number;
            limit: number;
            timezone?: string;
        };
        privacy: {
            sensitiveWritePolicy: "allow" | "deny" | "confirm";
        };
        memory: {
            retention: {
                compaction: {
                    enabled: boolean;
                    triggerThreshold: number;
                    reserveTokens: number;
                    minMessagesBeforeCompact: number;
                    keepRecentTokens: number;
                    recentTurnsPreserve: number;
                    summaryMaxTokens: number;
                    summaryChunkTokens: number;
                    summaryTimeoutMs: number;
                    summaryRetries: number;
                    qualityGuard: 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: "beta" | "stable" | "dev";
        auto: {
            enabled: boolean;
            stableDelayHours: number;
            stableJitterHours: number;
            betaCheckIntervalHours: number;
        };
    };
    stt: unknown;
    tts: unknown;
    voice: {
        languageMode?: "manual" | "auto";
        language?: "en" | "zh";
        input?: {
            refinement?: {
                mode: "off" | "custom" | "punctuation" | "light";
                model?: string;
                customInstruction?: string;
            };
        };
    };
    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;
    };
}>;