zcf

const AI_OUTPUT_LANGUAGES: {
    readonly 'zh-CN': { readonly directive: 'Always respond in Chinese-simplified' };
    readonly en: { readonly directive: 'Always respond in English' };
    readonly custom: { readonly directive: '' };
};

const API_DEFAULT_URL: string;

const API_ENV_KEY: string;

const ClAUDE_CONFIG_FILE: string;

const CLAUDE_DIR: string;

const CLAUDE_MD_FILE: string;

const CLAUDE_VSC_CONFIG_FILE: string;

const CODE_TOOL_ALIASES: Record<string, 'claude-code' | 'codex'>;

const CODE_TOOL_BANNERS: Record<'claude-code' | 'codex', string>;

const CODE_TOOL_TYPES: readonly ['claude-code', 'codex'];

const CODEX_AGENTS_FILE: string;

const CODEX_AUTH_FILE: string;

const CODEX_CONFIG_FILE: string;

const CODEX_DIR: string;

const CODEX_PROMPTS_DIR: string;

const DEFAULT_CODE_TOOL_TYPE: 'claude-code' | 'codex';

const LANG_LABELS: { readonly 'zh-CN': '简体中文'; readonly en: 'English' };

const LEGACY_ZCF_CONFIG_FILES: string[];

const SETTINGS_FILE: string;

const SUPPORTED_LANGS: readonly ['zh-CN', 'en'];

const ZCF_CONFIG_DIR: string;

const ZCF_CONFIG_FILE: string;

addCompletedOnboarding: () => void;

applyAiLanguageDirective: (aiOutputLang: AiOutputLanguage | string) => void;

backupExistingConfig: () => string | null;

backupMcpConfig: () => string | null;

buildMcpServerConfig: (
    baseConfig: McpServerConfig,
    apiKey?: string,
    placeholder?: string,
    envVarName?: string
) => McpServerConfig;

cleanupPermissions: (
    templatePermissions: string[],
    userPermissions: string[]
) => string[];

commandExists: (command: string) => Promise<boolean>;

configureApi: (apiConfig: ApiConfig | null) => ApiConfig | null;

copyConfigFiles: (onlyMd?: boolean) => void;

createHomebrewSymlink: (
    command: string,
    sourcePath: string
) => Promise<SymlinkResult>;

detectInstalledVersion: (codeType: CodeType) => Promise<string | null>;

displayVerificationResult: (
    result: VerificationResult,
    codeType: CodeType
) => void;

ensureApiKeyApproved: (
    config: ClaudeConfiguration,
    apiKey: string
) => ClaudeConfiguration;

ensureClaudeDir: () => void;

executeInstallMethod: (
    method: InstallMethod,
    codeType: CodeType
) => Promise<boolean>;

fixWindowsMcpConfig: (config: ClaudeConfiguration) => ClaudeConfiguration;

getAiOutputLanguageLabel: (lang: AiOutputLanguage) => string;

getExistingApiConfig: () => ApiConfig | null;

getExistingModelConfig: () =>
    | 'opus'
    | 'sonnet'
    | 'sonnet[1m]'
    | 'default'
    | 'custom'
    | null;

getInstallationStatus: () => Promise<InstallationStatus>;

getMcpConfigPath: () => string;

getPlatform: () => 'windows' | 'macos' | 'linux';

handleInstallFailure: (
    codeType: CodeType,
    failedMethods: InstallMethod[]
) => Promise<boolean>;

importRecommendedEnv: () => Promise<void>;

importRecommendedPermissions: () => Promise<void>;

init: (options?: InitOptions) => Promise<void>;

installClaudeCode: (skipMethodSelection?: boolean) => Promise<void>;

installCodex: (skipMethodSelection?: boolean) => Promise<void>;

isClaudeCodeInstalled: () => Promise<boolean>;

isCodeToolType: (value: any) => value is 'claude-code' | 'codex';

isCodexInstalled: () => Promise<boolean>;

isLocalClaudeCodeInstalled: () => Promise<boolean>;

manageApiKeyApproval: (apiKey: string) => void;

mergeAndCleanPermissions: (
    templatePermissions: string[] | undefined,
    userPermissions: string[] | undefined
) => string[];

mergeConfigs: (sourceFile: string, targetFile: string) => void;

mergeMcpServers: (
    existing: ClaudeConfiguration | null,
    newServers: Record<string, McpServerConfig>
) => ClaudeConfiguration;

mergeSettingsFile: (templatePath: string, targetPath: string) => void;

openSettingsJson: () => Promise<void>;

promptApiConfigurationAction: () => Promise<
    'modify-partial' | 'modify-all' | 'keep-existing' | null
>;

readMcpConfig: () => ClaudeConfiguration | null;

removeApiKeyFromRejected: (
    config: ClaudeConfiguration,
    apiKey: string
) => ClaudeConfiguration;

removeLocalClaudeCode: () => Promise<void>;

resolveCodeToolType: (value: unknown) => CodeToolType;

selectInstallMethod: (
    codeType: CodeType,
    excludeMethods?: InstallMethod[]
) => Promise<InstallMethod | null>;

setInstallMethod: (method: InstallMethod, codeType?: CodeType) => Promise<void>;

setPrimaryApiKey: () => void;

switchToOfficialLogin: () => boolean;

uninstallCodeTool: (codeType: CodeType) => Promise<boolean>;

updateCustomModel: (
    primaryModel?: string,
    haikuModel?: string,
    sonnetModel?: string,
    opusModel?: string
) => void;

updateDefaultModel: (
    model: 'opus' | 'sonnet' | 'sonnet[1m]' | 'default' | 'custom'
) => void;

verifyInstallation: (codeType: CodeType) => Promise<VerificationResult>;

writeMcpConfig: (config: ClaudeConfiguration) => void;

type AiOutputLanguage = keyof typeof AI_OUTPUT_LANGUAGES;

type CodeToolType = (typeof CODE_TOOL_TYPES)[number];

type SupportedLang = (typeof SUPPORTED_LANGS)[number];