/**
 * @license
 * Copyright 2025 Google LLC
 * SPDX-License-Identifier: Apache-2.0
 */
import { type ContentGeneratorConfig } from '../core/contentGenerator.js';
import { PromptRegistry } from '../prompts/prompt-registry.js';
import { ResourceRegistry } from '../resources/resource-registry.js';
import { ToolRegistry } from '../tools/tool-registry.js';
import type { SubagentSchedulerFactory } from '../core/subagentScheduler.js';
import { GeminiClient } from '../core/client.js';
import type { HookDefinition, HookEventName } from '../hooks/types.js';
import { HookSystem } from '../hooks/hookSystem.js';
import { FileDiscoveryService } from '../services/fileDiscoveryService.js';
import { GitService } from '../services/gitService.js';
import { ContextManager } from '../services/contextManager.js';
import type { SessionRecordingService } from '../recording/SessionRecordingService.js';
import { AsyncTaskManager } from '../services/asyncTaskManager.js';
import { AsyncTaskReminderService } from '../services/asyncTaskReminderService.js';
import { OutputFormat } from '../utils/output-format.js';
import { TelemetryTarget } from '../telemetry/index.js';
import { DEFAULT_GEMINI_FLASH_MODEL } from './models.js';
import type { IProviderManager as ProviderManager } from '../providers/IProviderManager.js';
import type { BucketFailureReason } from '../providers/errors.js';
import { type MCPOAuthConfig } from '../mcp/oauth-provider.js';
import { IdeClient } from '../ide/ide-client.js';
import { SettingsService } from '../settings/SettingsService.js';
import { type FileSystemService } from '../services/fileSystemService.js';
import { ProfileManager } from './profileManager.js';
import { SubagentManager } from './subagentManager.js';
import { type SchedulerCallbacks, type SchedulerOptions } from './schedulerSingleton.js';
export type { MCPOAuthConfig, AnyToolInvocation };
import type { AnyToolInvocation } from '../tools/tools.js';
import { WorkspaceContext } from '../utils/workspaceContext.js';
import { Storage } from './storage.js';
import { FileExclusions } from '../utils/ignorePatterns.js';
import type { EventEmitter } from 'node:events';
import { MessageBus } from '../confirmation-bus/message-bus.js';
import { PolicyEngine } from '../policy/policy-engine.js';
import type { PolicyEngineConfig } from '../policy/types.js';
import { type ExtensionLoader } from '../utils/extensionLoader.js';
import { McpClientManager } from '../tools/mcp-client-manager.js';
import type { ShellExecutionConfig } from '../services/shellExecutionService.js';
export interface RedactionConfig {
    redactApiKeys: boolean;
    redactCredentials: boolean;
    redactFilePaths: boolean;
    redactUrls: boolean;
    redactEmails: boolean;
    redactPersonalInfo: boolean;
    customPatterns?: Array<{
        name: string;
        pattern: RegExp;
        replacement: string;
        enabled: boolean;
    }>;
}
export declare enum ApprovalMode {
    DEFAULT = "default",
    AUTO_EDIT = "autoEdit",
    YOLO = "yolo"
}
export interface AccessibilitySettings {
    disableLoadingPhrases?: boolean;
    screenReader?: boolean;
}
export interface BugCommandSettings {
    urlTemplate: string;
}
export interface ChatCompressionSettings {
    contextPercentageThreshold?: number;
    /** @plan PLAN-20260211-COMPRESSION.P12 */
    strategy?: string;
    /** @plan PLAN-20260211-COMPRESSION.P12 */
    profile?: string;
}
export interface SummarizeToolOutputSettings {
    tokenBudget?: number;
}
export interface ComplexityAnalyzerSettings {
    complexityThreshold?: number;
    minTasksForSuggestion?: number;
    suggestionCooldownMs?: number;
}
export interface TelemetrySettings {
    enabled?: boolean;
    target?: TelemetryTarget;
    otlpEndpoint?: string;
    logPrompts?: boolean;
    outfile?: string;
    logConversations?: boolean;
    logResponses?: boolean;
    redactSensitiveData?: boolean;
    maxConversationHistory?: number;
    conversationLogPath?: string;
    maxLogFiles?: number;
    maxLogSizeMB?: number;
    retentionDays?: number;
    redactFilePaths?: boolean;
    redactUrls?: boolean;
    redactEmails?: boolean;
    redactPersonalInfo?: boolean;
    customRedactionPatterns?: Array<{
        name: string;
        pattern: RegExp;
        replacement: string;
        enabled: boolean;
    }>;
    enableDataRetention?: boolean;
    conversationExpirationDays?: number;
    maxConversationsStored?: number;
    remoteConsentGiven?: boolean;
}
/**
 * All information required in CLI to handle an extension. Defined in Core so
 * that the collection of loaded, active, and inactive extensions can be passed
 * around on the config object though Core does not use this information
 * directly.
 */
export interface GeminiCLIExtension {
    name: string;
    version: string;
    isActive: boolean;
    path: string;
    installMetadata?: ExtensionInstallMetadata;
    mcpServers?: Record<string, MCPServerConfig>;
    contextFiles: string[];
    excludeTools?: string[];
    hooks?: {
        [K in HookEventName]?: HookDefinition[];
    };
}
export interface ExtensionInstallMetadata {
    source: string;
    type: 'git' | 'local' | 'link' | 'github-release';
    releaseTag?: string;
    ref?: string;
    autoUpdate?: boolean;
}
import type { FileFilteringOptions } from './constants.js';
import { DEFAULT_FILE_FILTERING_OPTIONS, DEFAULT_MEMORY_FILE_FILTERING_OPTIONS } from './constants.js';
export type { FileFilteringOptions };
export { DEFAULT_FILE_FILTERING_OPTIONS, DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, };
/** Shell replacement mode type */
export type ShellReplacementMode = 'allowlist' | 'all' | 'none';
/**
 * Normalize shell-replacement setting to canonical mode.
 * Handles legacy boolean values for backward compatibility.
 */
export declare function normalizeShellReplacement(value: ShellReplacementMode | boolean | undefined): ShellReplacementMode;
export declare const DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD = 4000000;
export declare const DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES = 1000;
export declare class MCPServerConfig {
    readonly command?: string | undefined;
    readonly args?: string[] | undefined;
    readonly env?: Record<string, string> | undefined;
    readonly cwd?: string | undefined;
    readonly url?: string | undefined;
    readonly httpUrl?: string | undefined;
    readonly headers?: Record<string, string> | undefined;
    readonly tcp?: string | undefined;
    /**
     * Transport type for URL-based servers.
     * When set, disables automatic HTTP→SSE fallback.
     * - 'http' → StreamableHTTPClientTransport
     * - 'sse'  → SSEClientTransport
     * - omitted → defaults to HTTP with SSE fallback (deprecated; add type explicitly)
     *
     * Note: 'httpUrl' is deprecated; use 'url' + 'type: "http"' instead.
     * @plan PLAN-20250219-GMERGE021.R3.P03
     * @requirement REQ-GMERGE021-R3-001
     */
    readonly type?: "sse" | "http" | undefined;
    readonly timeout?: number | undefined;
    readonly trust?: boolean | undefined;
    readonly description?: string | undefined;
    readonly includeTools?: string[] | undefined;
    readonly excludeTools?: string[] | undefined;
    readonly extensionName?: string | undefined;
    readonly extension?: GeminiCLIExtension | undefined;
    readonly oauth?: MCPOAuthConfig | undefined;
    readonly authProviderType?: AuthProviderType | undefined;
    readonly targetAudience?: string | undefined;
    readonly targetServiceAccount?: string | undefined;
    constructor(command?: string | undefined, args?: string[] | undefined, env?: Record<string, string> | undefined, cwd?: string | undefined, url?: string | undefined, httpUrl?: string | undefined, headers?: Record<string, string> | undefined, tcp?: string | undefined, 
    /**
     * Transport type for URL-based servers.
     * When set, disables automatic HTTP→SSE fallback.
     * - 'http' → StreamableHTTPClientTransport
     * - 'sse'  → SSEClientTransport
     * - omitted → defaults to HTTP with SSE fallback (deprecated; add type explicitly)
     *
     * Note: 'httpUrl' is deprecated; use 'url' + 'type: "http"' instead.
     * @plan PLAN-20250219-GMERGE021.R3.P03
     * @requirement REQ-GMERGE021-R3-001
     */
    type?: "sse" | "http" | undefined, timeout?: number | undefined, trust?: boolean | undefined, description?: string | undefined, includeTools?: string[] | undefined, excludeTools?: string[] | undefined, extensionName?: string | undefined, extension?: GeminiCLIExtension | undefined, oauth?: MCPOAuthConfig | undefined, authProviderType?: AuthProviderType | undefined, targetAudience?: string | undefined, targetServiceAccount?: string | undefined);
}
export declare enum AuthProviderType {
    DYNAMIC_DISCOVERY = "dynamic_discovery",
    GOOGLE_CREDENTIALS = "google_credentials",
    SERVICE_ACCOUNT_IMPERSONATION = "service_account_impersonation"
}
export interface SandboxConfig {
    command: 'docker' | 'podman' | 'sandbox-exec';
    image: string;
}
export interface ActiveExtension {
    name: string;
    version: string;
}
/**
 * @plan PLAN-20260223-ISSUE1598.P03
 * @requirement REQ-1598-IC10
 */
export interface FailoverContext {
    triggeringStatus?: number;
}
/**
 * Handler for bucket failover on rate limit/quota errors
 * @plan PLAN-20251213issue490
 */
export interface BucketFailoverHandler {
    /**
     * Get the list of available buckets
     */
    getBuckets(): string[];
    /**
     * Get the currently active bucket
     */
    getCurrentBucket(): string | undefined;
    /**
     * Try to failover to the next bucket
     * @plan PLAN-20260223-ISSUE1598.P03
     * @param context Optional context about the triggering failure
     * @returns true if failover succeeded (may switch bucket or refresh/reauth current), false if no recovery possible
     */
    tryFailover(context?: FailoverContext): Promise<boolean>;
    /**
     * Check if bucket failover is enabled
     */
    isEnabled(): boolean;
    /**
     * Reset the session tracking so failover can try buckets again in a new request.
     * Call this at the start of each new request to prevent infinite cycling.
     */
    resetSession?(): void;
    /**
     * Full reset for new user turns: clears tried set, resets to first bucket, and
     * resets session bucket to the primary (first) bucket so the next request starts fresh.
     */
    reset?(): void;
    /**
     * @plan PLAN-20260223-ISSUE1598.P03
     * @requirement REQ-1598-IC09
     * Get the failure reasons for buckets that were skipped during last failover
     */
    getLastFailoverReasons?(): Record<string, BucketFailureReason>;
    /**
     * @fix issue1616
     * Eagerly authenticate all unauthenticated buckets.
     * Called at user-turn boundaries so all buckets have tokens before API calls begin.
     * Respects auth-bucket-prompt and auth-bucket-delay ephemerals.
     * No-op for single-bucket profiles.
     */
    ensureBucketsAuthenticated?(): Promise<void>;
}
export interface ConfigParameters {
    sessionId: string;
    embeddingModel?: string;
    sandbox?: SandboxConfig;
    targetDir: string;
    debugMode: boolean;
    outputFormat?: OutputFormat;
    question?: string;
    coreTools?: string[];
    allowedTools?: string[];
    excludeTools?: string[];
    toolDiscoveryCommand?: string;
    toolCallCommand?: string;
    mcpServerCommand?: string;
    mcpServers?: Record<string, MCPServerConfig>;
    lsp?: import('../lsp/types.js').LspConfig | boolean;
    userMemory?: string;
    llxprtMdFileCount?: number;
    llxprtMdFilePaths?: string[];
    approvalMode?: ApprovalMode;
    showMemoryUsage?: boolean;
    contextLimit?: number;
    compressionThreshold?: number;
    contextFileName?: string | string[];
    accessibility?: AccessibilitySettings;
    telemetry?: TelemetrySettings;
    usageStatisticsEnabled?: boolean;
    fileFiltering?: {
        respectGitIgnore?: boolean;
        respectLlxprtIgnore?: boolean;
        enableRecursiveFileSearch?: boolean;
        disableFuzzySearch?: boolean;
    };
    checkpointing?: boolean;
    dumpOnError?: boolean;
    proxy?: string;
    cwd: string;
    fileDiscoveryService?: FileDiscoveryService;
    includeDirectories?: string[];
    bugCommand?: BugCommandSettings;
    model: string;
    extensionContextFilePaths?: string[];
    maxSessionTurns?: number;
    experimentalZedIntegration?: boolean;
    listExtensions?: boolean;
    activeExtensions?: ActiveExtension[];
    providerManager?: ProviderManager;
    provider?: string;
    extensions?: GeminiCLIExtension[];
    extensionLoader?: ExtensionLoader;
    enabledExtensions?: string[];
    enableExtensionReloading?: boolean;
    allowedMcpServers?: string[];
    blockedMcpServers?: Array<{
        name: string;
        extensionName: string;
    }>;
    noBrowser?: boolean;
    summarizeToolOutput?: Record<string, SummarizeToolOutputSettings>;
    folderTrust?: boolean;
    ideMode?: boolean;
    ideClient?: IdeClient;
    complexityAnalyzer?: ComplexityAnalyzerSettings;
    loadMemoryFromIncludeDirectories?: boolean;
    chatCompression?: ChatCompressionSettings;
    interactive?: boolean;
    shellReplacement?: 'allowlist' | 'all' | 'none' | boolean;
    trustedFolder?: boolean;
    useRipgrep?: boolean;
    shouldUseNodePtyShell?: boolean;
    allowPtyThemeOverride?: boolean;
    ptyScrollbackLimit?: number;
    ptyTerminalWidth?: number;
    ptyTerminalHeight?: number;
    skipNextSpeakerCheck?: boolean;
    extensionManagement?: boolean;
    enablePromptCompletion?: boolean;
    eventEmitter?: EventEmitter;
    settingsService?: SettingsService;
    policyEngineConfig?: PolicyEngineConfig;
    truncateToolOutputThreshold?: number;
    truncateToolOutputLines?: number;
    enableToolOutputTruncation?: boolean;
    continueOnFailedApiCall?: boolean;
    enableShellOutputEfficiency?: boolean;
    continueSession?: boolean | string;
    disableYoloMode?: boolean;
    enableHooks?: boolean;
    hooks?: {
        [K in HookEventName]?: HookDefinition[];
    };
    jitContextEnabled?: boolean;
}
export declare class Config {
    private toolRegistry;
    private mcpClientManager?;
    private allowedMcpServers;
    private blockedMcpServers;
    private promptRegistry;
    private resourceRegistry;
    private readonly sessionId;
    private adoptedSessionId;
    private readonly settingsService;
    private fileSystemService;
    private contentGeneratorConfig;
    private readonly embeddingModel;
    private readonly sandbox;
    private readonly targetDir;
    private workspaceContext;
    private readonly debugMode;
    private readonly outputFormat;
    private readonly question;
    /**
     * @plan PLAN-20250212-LSP.P33
     * @requirement REQ-CFG-010, REQ-CFG-015, REQ-CFG-070
     */
    private lspConfig?;
    private lspServiceClient?;
    private lspMcpClient?;
    private lspMcpTransport?;
    private readonly coreTools;
    private readonly allowedTools;
    private readonly excludeTools;
    private readonly toolDiscoveryCommand;
    private readonly toolCallCommand;
    private readonly mcpServerCommand;
    private mcpServers;
    private userMemory;
    private llxprtMdFileCount;
    private llxprtMdFilePaths;
    private approvalMode;
    private readonly jitContextEnabled?;
    private contextManager?;
    private terminalBackground;
    private readonly showMemoryUsage;
    private readonly accessibility;
    private telemetrySettings;
    private readonly usageStatisticsEnabled;
    private geminiClient;
    private runtimeState;
    private readonly fileFiltering;
    private alwaysAllowedCommands;
    private fileDiscoveryService;
    private gitService;
    private sessionRecordingService;
    private asyncTaskManager;
    private asyncTaskReminderService?;
    private asyncTaskAutoTrigger?;
    private readonly checkpointing;
    private readonly dumpOnError;
    private readonly proxy;
    private readonly cwd;
    private readonly bugCommand;
    private model;
    private readonly originalModel;
    private readonly extensionContextFilePaths;
    private readonly noBrowser;
    private readonly folderTrust;
    private ideMode;
    private ideClient;
    private inFallbackMode;
    private _modelSwitchedDuringSession;
    private readonly maxSessionTurns;
    private readonly _activeExtensions;
    private readonly listExtensions;
    private readonly _extensionLoader;
    private readonly enableExtensionReloading;
    private providerManager?;
    private profileManager?;
    private subagentManager?;
    private subagentSchedulerFactory?;
    private bucketFailoverHandler?;
    private allPotentialTools;
    setProviderManager(providerManager: ProviderManager): void;
    getProviderManager(): ProviderManager | undefined;
    setProfileManager(manager: ProfileManager | undefined): void;
    getProfileManager(): ProfileManager | undefined;
    setSubagentManager(manager: SubagentManager | undefined): void;
    getSubagentManager(): SubagentManager | undefined;
    /**
     * Set the bucket failover handler for rate limit/quota error handling
     * @plan PLAN-20251213issue490
     */
    setBucketFailoverHandler(handler: BucketFailoverHandler | undefined): void;
    /**
     * Get the bucket failover handler
     * @plan PLAN-20251213issue490
     */
    getBucketFailoverHandler(): BucketFailoverHandler | undefined;
    /**
     * Set the session recording service for hooks to access transcript path
     * @plan PLAN-20250219-GMERGE022.B2
     * @requirement R1
     */
    setSessionRecordingService(service: SessionRecordingService | undefined): void;
    /**
     * Get the session recording service
     * @plan PLAN-20250219-GMERGE022.B2
     * @requirement R1
     */
    getSessionRecordingService(): SessionRecordingService | undefined;
    setInteractiveSubagentSchedulerFactory(factory: SubagentSchedulerFactory | undefined): void;
    getInteractiveSubagentSchedulerFactory(): SubagentSchedulerFactory | undefined;
    private provider?;
    private readonly summarizeToolOutput;
    private readonly experimentalZedIntegration;
    private readonly complexityAnalyzerSettings;
    private readonly loadMemoryFromIncludeDirectories;
    private readonly chatCompression;
    private readonly interactive;
    private readonly trustedFolder;
    private readonly useRipgrep;
    private readonly shouldUseNodePtyShell;
    private readonly allowPtyThemeOverride;
    private readonly ptyScrollbackLimit;
    private ptyTerminalWidth?;
    private ptyTerminalHeight?;
    private readonly skipNextSpeakerCheck;
    private readonly extensionManagement;
    private readonly enablePromptCompletion;
    private readonly shellReplacement;
    readonly storage: Storage;
    private readonly fileExclusions;
    private readonly eventEmitter?;
    private readonly messageBus;
    private readonly policyEngine;
    truncateToolOutputThreshold: number;
    truncateToolOutputLines: number;
    enableToolOutputTruncation: boolean;
    private readonly continueOnFailedApiCall;
    private readonly enableShellOutputEfficiency;
    private readonly continueSession;
    private readonly disableYoloMode;
    private readonly enableHooks;
    private readonly hooks;
    private disabledHooks;
    /**
     * @plan:PLAN-20260216-HOOKSYSTEMREWRITE.P03
     * @requirement:HOOK-001,HOOK-002
     * Lazily-created HookSystem instance, only when enableHooks=true
     */
    private hookSystem;
    private initialized;
    constructor(params: ConfigParameters);
    /**
     * Must only be called once, throws if called again.
     */
    initialize(): Promise<void>;
    initializeContentGeneratorConfig: () => Promise<void>;
    refreshAuth(authMethod?: string): Promise<void>;
    getSessionId(): string;
    /**
     * @fix FIX-1336-SESSION-ADOPTION
     * Adopt a restored session's ID for use by TodoStore and other session-scoped services.
     * This allows --continue to properly restore todos from the previous session.
     */
    adoptSessionId(sessionId: string): void;
    isContinueSession(): boolean;
    shouldLoadMemoryFromIncludeDirectories(): boolean;
    setTerminalBackground(terminalBackground: string | undefined): void;
    getTerminalBackground(): string | undefined;
    getContentGeneratorConfig(): ContentGeneratorConfig | undefined;
    getModel(): string;
    setModel(newModel: string): void;
    isInFallbackMode(): boolean;
    resetModelToDefault(): void;
    setFallbackMode(active: boolean): void;
    getMaxSessionTurns(): number;
    getEmbeddingModel(): string | undefined;
    getSandbox(): SandboxConfig | undefined;
    isRestrictiveSandbox(): boolean;
    getTargetDir(): string;
    getProjectRoot(): string;
    getWorkspaceContext(): WorkspaceContext;
    getToolRegistry(): ToolRegistry;
    getPromptRegistry(): PromptRegistry;
    getResourceRegistry(): ResourceRegistry;
    getDebugMode(): boolean;
    getOutputFormat(): OutputFormat;
    getQuestion(): string | undefined;
    getCoreTools(): string[] | undefined;
    getAllowedTools(): string[] | undefined;
    /**
     * All the excluded tools from static configuration, loaded extensions, or
     * other sources.
     *
     * May change over time.
     */
    getExcludeTools(): string[] | undefined;
    getToolDiscoveryCommand(): string | undefined;
    getToolCallCommand(): string | undefined;
    getMcpServerCommand(): string | undefined;
    /**
     * The user configured MCP servers (via gemini settings files).
     *
     * Does NOT include mcp servers configured by extensions.
     */
    getMcpServers(): Record<string, MCPServerConfig> | undefined;
    getMcpClientManager(): McpClientManager | undefined;
    getAllowedMcpServers(): string[] | undefined;
    getBlockedMcpServers(): Array<{
        name: string;
        extensionName: string;
    }> | undefined;
    setMcpServers(mcpServers: Record<string, MCPServerConfig>): void;
    getUserMemory(): string;
    getGlobalMemory(): string;
    getEnvironmentMemory(): string;
    getCoreMemory(): string | undefined;
    setCoreMemory(_content: string): void;
    setUserMemory(newUserMemory: string): void;
    updateSystemInstructionIfInitialized(): void | Promise<void>;
    getContinueSessionRef(): string | null;
    getLlxprtMdFileCount(): number;
    setLlxprtMdFileCount(count: number): void;
    getLlxprtMdFilePaths(): string[];
    setLlxprtMdFilePaths(paths: string[]): void;
    getApprovalMode(): ApprovalMode;
    setApprovalMode(mode: ApprovalMode): void;
    isJitContextEnabled(): boolean;
    getContextManager(): ContextManager | undefined;
    getMessageBus(): MessageBus;
    getPolicyEngine(): PolicyEngine;
    isYoloModeDisabled(): boolean;
    getShowMemoryUsage(): boolean;
    getAccessibility(): AccessibilitySettings;
    getTelemetryEnabled(): boolean;
    getTelemetryLogPromptsEnabled(): boolean;
    getTelemetryOtlpEndpoint(): string;
    getTelemetryTarget(): TelemetryTarget;
    getTelemetryOutfile(): string | undefined;
    getConversationLoggingEnabled(): boolean;
    getResponseLoggingEnabled(): boolean;
    getConversationLogPath(): string;
    getMaxConversationHistory(): number;
    getConversationRetentionDays(): number;
    getMaxLogFiles(): number;
    getMaxLogSizeMB(): number;
    getRedactionConfig(): RedactionConfig;
    getDataRetentionEnabled(): boolean;
    getConversationExpirationDays(): number;
    getMaxConversationsStored(): number;
    getTelemetrySettings(): TelemetrySettings & {
        remoteConsentGiven?: boolean;
        [key: string]: unknown;
    };
    updateTelemetrySettings(settings: Partial<TelemetrySettings>): void;
    private expandPath;
    getGeminiClient(): GeminiClient;
    getGeminiDir(): string;
    getProjectTempDir(): string;
    getEnableRecursiveFileSearch(): boolean;
    getFileFilteringDisableFuzzySearch(): boolean;
    getFileFilteringRespectGitIgnore(): boolean;
    getFileFilteringRespectLlxprtIgnore(): boolean;
    getFileFilteringOptions(): FileFilteringOptions;
    /**
     * Gets custom file exclusion patterns from configuration.
     * TODO: This is a placeholder implementation. In the future, this could
     * read from settings files, CLI arguments, or environment variables.
     */
    getCustomExcludes(): string[];
    getCheckpointingEnabled(): boolean;
    getDumpOnError(): boolean;
    getProxy(): string | undefined;
    getWorkingDir(): string;
    getBugCommand(): BugCommandSettings | undefined;
    getFileService(): FileDiscoveryService;
    getUsageStatisticsEnabled(): boolean;
    getExtensionContextFilePaths(): string[];
    getExperimentalZedIntegration(): boolean;
    getListExtensions(): boolean;
    getExtensionManagement(): boolean;
    getExtensionLoader(): ExtensionLoader;
    getExtensions(): GeminiCLIExtension[];
    getActiveExtensions(): ActiveExtension[];
    /**
     * Check if an extension is enabled (i.e., isActive in the extension loader).
     * Returns true for unknown extensions to avoid filtering valid commands.
     */
    isExtensionEnabled(extensionName: string): boolean;
    getEnableExtensionReloading(): boolean;
    getExtensionEvents(): EventEmitter | undefined;
    getProvider(): string | undefined;
    setProvider(provider: string): void;
    getNoBrowser(): boolean;
    isBrowserLaunchSuppressed(): boolean;
    getSummarizeToolOutputConfig(): Record<string, SummarizeToolOutputSettings> | undefined;
    getIdeClient(): IdeClient | undefined;
    getIdeMode(): boolean;
    /**
     * Returns 'true' if the folder trust feature is enabled.
     */
    getFolderTrust(): boolean;
    /**
     * Returns 'true' if the workspace is considered "trusted".
     * 'false' for untrusted.
     */
    isTrustedFolder(): boolean;
    setIdeMode(value: boolean): void;
    setIdeClientDisconnected(): void;
    setIdeClientConnected(): void;
    getComplexityAnalyzerSettings(): ComplexityAnalyzerSettings;
    private normalizeStreamingValue;
    private normalizeAndPersistStreaming;
    getEphemeralSetting(key: string): unknown;
    private normalizeContextLimit;
    setEphemeralSetting(key: string, value: unknown): void;
    clearEphemeralSettings(): void;
    getEphemeralSettings(): Record<string, unknown>;
    isInteractive(): boolean;
    getNonInteractive(): boolean;
    /**
     * Get the current FileSystemService
     */
    getFileSystemService(): FileSystemService;
    /**
     * Set a custom FileSystemService
     */
    setFileSystemService(fileSystemService: FileSystemService): void;
    getChatCompression(): ChatCompressionSettings | undefined;
    addAlwaysAllowedCommand(rootCommand: string): void;
    isCommandAlwaysAllowed(rootCommand: string): boolean;
    getAlwaysAllowedCommands(): string[];
    getShellReplacement(): ShellReplacementMode;
    getUseRipgrep(): boolean;
    getShouldUseNodePtyShell(): boolean;
    getAllowPtyThemeOverride(): boolean;
    getPtyScrollbackLimit(): number;
    getPtyTerminalWidth(): number | undefined;
    getPtyTerminalHeight(): number | undefined;
    setPtyTerminalSize(width: number | undefined, height: number | undefined): void;
    getShellExecutionConfig(): ShellExecutionConfig;
    getSkipNextSpeakerCheck(): boolean;
    getContinueOnFailedApiCall(): boolean;
    getEnableShellOutputEfficiency(): boolean;
    getScreenReader(): boolean;
    getEnablePromptCompletion(): boolean;
    getJitContextEnabled(): boolean;
    /**
     * Lazily loads JIT subdirectory memory for a given path.
     * Returns formatted memory content from LLXPRT.md files found between
     * the target path and the trusted root, excluding already-loaded paths.
     */
    getJitMemoryForPath(targetPath: string): Promise<string>;
    getGitService(): Promise<GitService>;
    /**
     * Get the AsyncTaskManager instance
     * @plan PLAN-20260130-ASYNCTASK.P09
     */
    getAsyncTaskManager(): AsyncTaskManager | undefined;
    /**
     * Get the AsyncTaskReminderService instance
     * @plan PLAN-20260130-ASYNCTASK.P22
     */
    getAsyncTaskReminderService(): AsyncTaskReminderService | undefined;
    /**
     * Set up AsyncTaskAutoTrigger with client callbacks
     * @plan PLAN-20260130-ASYNCTASK.P22
     * @param isAgentBusy Function to check if the agent is busy
     * @param triggerAgentTurn Function to trigger an agent turn with a message
     * @returns Cleanup function to unsubscribe from auto-trigger
     */
    setupAsyncTaskAutoTrigger(isAgentBusy: () => boolean, triggerAgentTurn: (message: string) => Promise<void>): () => void;
    /**
     * Get the SettingsService instance
     */
    getSettingsService(): SettingsService;
    getFileExclusions(): FileExclusions;
    refreshMemory(): Promise<{
        memoryContent: string;
        fileCount: number;
        filePaths: string[];
    }>;
    createToolRegistry(): Promise<ToolRegistry>;
    /**
     * Get all potential tools (both registered and unregistered) for settings UI
     */
    getAllPotentialTools(): {
        toolClass: any;
        toolName: string;
        displayName: string;
        isRegistered: boolean;
        reason?: string;
        args: any[];
    }[];
    /**
     * Get tool registry information with registered/unregistered separation
     */
    getToolRegistryInfo(): {
        registered: {
            toolClass: any;
            toolName: string;
            displayName: string;
            isRegistered: boolean;
            reason?: string;
            args: any[];
        }[];
        unregistered: {
            toolClass: any;
            toolName: string;
            displayName: string;
            isRegistered: boolean;
            reason?: string;
            args: any[];
        }[];
    };
    getOrCreateScheduler(sessionId: string, callbacks: SchedulerCallbacks, options?: SchedulerOptions): Promise<import('../core/coreToolScheduler.js').CoreToolScheduler>;
    disposeScheduler(sessionId: string): void;
    getEnableHooks(): boolean;
    /**
     * Get hooks configuration
     */
    getHooks(): {
        [K in HookEventName]?: HookDefinition[];
    } | undefined;
    /**
     * Get disabled hooks list
     */
    getDisabledHooks(): string[];
    /**
     * Set disabled hooks list
     * Updates both in-memory state and persists to settings
     */
    setDisabledHooks(hooks: string[]): void;
    /**
     * Get the HookSystem instance, creating it lazily on first access.
     * Returns undefined if hooks are disabled (enableHooks=false).
     *
     * @plan:PLAN-20260216-HOOKSYSTEMREWRITE.P03
     * @requirement:HOOK-001 - Lazy creation on first call when enableHooks=true
     * @requirement:HOOK-002 - Returns undefined when enableHooks=false
     * @requirement:HOOK-010 - Zero CPU/memory overhead when hooks are disabled
     */
    getHookSystem(): HookSystem | undefined;
    /**
     * Check if interactive shell is enabled.
     * Returns true if shouldUseNodePtyShell setting is enabled.
     */
    getEnableInteractiveShell(): boolean;
    /**
     * Get LSP service client if available.
     * @plan PLAN-20250212-LSP.P33
     * @requirement REQ-DIAG-010, REQ-CFG-010, REQ-CFG-015, REQ-CFG-020
     * @returns LspServiceClient instance or undefined if not initialized or disabled
     */
    getLspServiceClient(): import('../lsp/lsp-service-client.js').LspServiceClient | undefined;
    /**
     * Get LSP configuration.
     * @plan PLAN-20250212-LSP.P33
     * @requirement REQ-DIAG-010, REQ-CFG-010, REQ-CFG-015, REQ-CFG-020
     * @returns LspConfig or undefined (undefined means LSP disabled)
     */
    getLspConfig(): import('../lsp/types.js').LspConfig | undefined;
    /**
     * Register MCP navigation tools from LSP service.
     * @plan PLAN-20250212-LSP.P33
     * @requirement REQ-NAV-055, REQ-CFG-070
     */
    private registerMcpNavigationTools;
    /**
     * Shutdown LSP service if running.
     * @plan PLAN-20250212-LSP.P33
     * @requirement REQ-GRACE-020, REQ-GRACE-040
     */
    shutdownLspService(): Promise<void>;
}
export { type SchedulerCallbacks, type SchedulerOptions };
export { DEFAULT_GEMINI_FLASH_MODEL };