import { z, ZodError } from 'zod';

/**
 * Schema v1 for project.config.ts / offline.config.ts.
 *
 * Design notes:
 * - A project declares pages once. CLI/Vite plugin/offline all read this list.
 * - Offline config is optional and additive; it references page identifiers
 *   from project config instead of redeclaring them.
 * - Unknown keys are stripped (`strip()` default). We prefer silent success on
 *   extra fields so downstream tools can extend shapes without a lock-step bump.
 */
type Framework = 'vue3' | 'react';
type EnvMode = 'dev' | 'test' | 'staging' | 'prod';
/**
 * A single "externalized dependency": e.g. vue or pinia. When cdn is enabled
 * the build pipeline strips `import ... from '<name>'` out of the bundle,
 * injects `<script src>` for each URL in order with onerror chaining, and
 * exposes the module via the UMD global (`globalVar`). If every URL in
 * `urls` fails, the runtime falls back to the local vendor chunk we also
 * emit (so offline / flaky networks never show a blank page).
 */
declare const cdnEntrySchema: z.ZodObject<{
    name: z.ZodString;
    globalVar: z.ZodOptional<z.ZodString>;
    urls: z.ZodArray<z.ZodString>;
    depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
    externals: z.ZodOptional<z.ZodArray<z.ZodString>>;
    localFallback: z.ZodOptional<z.ZodString>;
    aliasGlobals: z.ZodOptional<z.ZodArray<z.ZodString>>;
    initScript: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
declare const cdnConfigSchema: z.ZodObject<{
    enabled: z.ZodDefault<z.ZodBoolean>;
    applyOn: z.ZodDefault<z.ZodArray<z.ZodEnum<{
        dev: "dev";
        build: "build";
        preview: "preview";
    }>>>;
    fallback: z.ZodDefault<z.ZodEnum<{
        error: "error";
        local: "local";
    }>>;
    timeoutMs: z.ZodDefault<z.ZodNumber>;
    globalNamespace: z.ZodDefault<z.ZodString>;
    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        globalVar: z.ZodOptional<z.ZodString>;
        urls: z.ZodArray<z.ZodString>;
        depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
        externals: z.ZodOptional<z.ZodArray<z.ZodString>>;
        localFallback: z.ZodOptional<z.ZodString>;
        aliasGlobals: z.ZodOptional<z.ZodArray<z.ZodString>>;
        initScript: z.ZodOptional<z.ZodString>;
    }, z.core.$strict>>>;
}, z.core.$strict>;
type CdnEntryInput = z.input<typeof cdnEntrySchema>;
type CdnEntry = z.output<typeof cdnEntrySchema>;
type CdnConfigInput = z.input<typeof cdnConfigSchema>;
type CdnConfig = z.output<typeof cdnConfigSchema>;
declare const viteProxyEntrySchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
    target: z.ZodString;
    changeOrigin: z.ZodOptional<z.ZodBoolean>;
    rewrite: z.ZodOptional<z.ZodString>;
    secure: z.ZodOptional<z.ZodBoolean>;
    ws: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>]>;
declare const envEntrySchema: z.ZodObject<{
    apiBase: z.ZodOptional<z.ZodString>;
    publicPath: z.ZodOptional<z.ZodString>;
    proxy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
        target: z.ZodString;
        changeOrigin: z.ZodOptional<z.ZodBoolean>;
        rewrite: z.ZodOptional<z.ZodString>;
        secure: z.ZodOptional<z.ZodBoolean>;
        ws: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>]>>>;
    define: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, z.core.$strict>;
declare const pageDefinitionSchema: z.ZodObject<{
    title: z.ZodString;
    entry: z.ZodOptional<z.ZodString>;
    template: z.ZodOptional<z.ZodString>;
    filename: z.ZodOptional<z.ZodString>;
    namespace: z.ZodOptional<z.ZodString>;
    store: z.ZodOptional<z.ZodString>;
    offline: z.ZodOptional<z.ZodBoolean>;
    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
}, z.core.$strict>;
declare const projectConfigSchema: z.ZodObject<{
    name: z.ZodString;
    framework: z.ZodEnum<{
        vue3: "vue3";
        react: "react";
    }>;
    rootDir: z.ZodOptional<z.ZodString>;
    srcDir: z.ZodOptional<z.ZodString>;
    pagesDir: z.ZodOptional<z.ZodString>;
    publicDir: z.ZodOptional<z.ZodString>;
    outDir: z.ZodOptional<z.ZodString>;
    aliases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    envs: z.ZodObject<{
        dev: z.ZodOptional<z.ZodObject<{
            apiBase: z.ZodOptional<z.ZodString>;
            publicPath: z.ZodOptional<z.ZodString>;
            proxy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                target: z.ZodString;
                changeOrigin: z.ZodOptional<z.ZodBoolean>;
                rewrite: z.ZodOptional<z.ZodString>;
                secure: z.ZodOptional<z.ZodBoolean>;
                ws: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>]>>>;
            define: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>;
        test: z.ZodOptional<z.ZodObject<{
            apiBase: z.ZodOptional<z.ZodString>;
            publicPath: z.ZodOptional<z.ZodString>;
            proxy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                target: z.ZodString;
                changeOrigin: z.ZodOptional<z.ZodBoolean>;
                rewrite: z.ZodOptional<z.ZodString>;
                secure: z.ZodOptional<z.ZodBoolean>;
                ws: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>]>>>;
            define: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>;
        staging: z.ZodOptional<z.ZodObject<{
            apiBase: z.ZodOptional<z.ZodString>;
            publicPath: z.ZodOptional<z.ZodString>;
            proxy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                target: z.ZodString;
                changeOrigin: z.ZodOptional<z.ZodBoolean>;
                rewrite: z.ZodOptional<z.ZodString>;
                secure: z.ZodOptional<z.ZodBoolean>;
                ws: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>]>>>;
            define: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>;
        prod: z.ZodOptional<z.ZodObject<{
            apiBase: z.ZodOptional<z.ZodString>;
            publicPath: z.ZodOptional<z.ZodString>;
            proxy: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                target: z.ZodString;
                changeOrigin: z.ZodOptional<z.ZodBoolean>;
                rewrite: z.ZodOptional<z.ZodString>;
                secure: z.ZodOptional<z.ZodBoolean>;
                ws: z.ZodOptional<z.ZodBoolean>;
            }, z.core.$strip>]>>>;
            define: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
        }, z.core.$strict>>;
    }, z.core.$strip>;
    pages: z.ZodRecord<z.ZodString, z.ZodObject<{
        title: z.ZodString;
        entry: z.ZodOptional<z.ZodString>;
        template: z.ZodOptional<z.ZodString>;
        filename: z.ZodOptional<z.ZodString>;
        namespace: z.ZodOptional<z.ZodString>;
        store: z.ZodOptional<z.ZodString>;
        offline: z.ZodOptional<z.ZodBoolean>;
        meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    }, z.core.$strict>>;
    cdn: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodDefault<z.ZodBoolean>;
        applyOn: z.ZodDefault<z.ZodArray<z.ZodEnum<{
            dev: "dev";
            build: "build";
            preview: "preview";
        }>>>;
        fallback: z.ZodDefault<z.ZodEnum<{
            error: "error";
            local: "local";
        }>>;
        timeoutMs: z.ZodDefault<z.ZodNumber>;
        globalNamespace: z.ZodDefault<z.ZodString>;
        entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
            name: z.ZodString;
            globalVar: z.ZodOptional<z.ZodString>;
            urls: z.ZodArray<z.ZodString>;
            depends: z.ZodOptional<z.ZodArray<z.ZodString>>;
            externals: z.ZodOptional<z.ZodArray<z.ZodString>>;
            localFallback: z.ZodOptional<z.ZodString>;
            aliasGlobals: z.ZodOptional<z.ZodArray<z.ZodString>>;
            initScript: z.ZodOptional<z.ZodString>;
        }, z.core.$strict>>>;
    }, z.core.$strict>>;
    offline: z.ZodOptional<z.ZodObject<{
        enabled: z.ZodOptional<z.ZodBoolean>;
    }, z.core.$strip>>;
}, z.core.$strict>;
type ProjectConfigInput = z.input<typeof projectConfigSchema>;
type ProjectConfigRaw = z.output<typeof projectConfigSchema>;
type PageDefinition = z.output<typeof pageDefinitionSchema>;
type EnvEntry = z.output<typeof envEntrySchema>;
/**
 * Fully-resolved project config (defaults applied, entries materialized).
 */
interface ResolvedProjectConfig extends Omit<ProjectConfigRaw, 'pages' | 'cdn'> {
    rootDir: string;
    srcDir: string;
    pagesDir: string;
    publicDir: string;
    outDir: string;
    aliases: Record<string, string>;
    pages: Record<string, ResolvedPageDefinition>;
    /** Always present; `enabled=false` means CDN is a no-op. */
    cdn: ResolvedCdnConfig;
}
interface ResolvedCdnEntry extends Omit<CdnEntry, 'globalVar' | 'externals' | 'aliasGlobals' | 'localFallback' | 'initScript'> {
    globalVar: string;
    externals: string[];
    aliasGlobals: string[];
    localFallback: string | null;
    initScript: string | null;
}
interface ResolvedCdnConfig extends Omit<CdnConfig, 'entries'> {
    entries: ResolvedCdnEntry[];
}
interface ResolvedPageDefinition extends PageDefinition {
    name: string;
    entry: string;
    template: string;
    filename: string;
    namespace: string;
    offline: boolean;
    meta: Record<string, string>;
}
declare const prefetchRuleSchema: z.ZodObject<{
    name: z.ZodString;
    match: z.ZodUnion<readonly [z.ZodObject<{
        page: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        url: z.ZodString;
    }, z.core.$strict>]>;
    keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
    apiUrl: z.ZodString;
    maxAge: z.ZodOptional<z.ZodNumber>;
    priority: z.ZodOptional<z.ZodEnum<{
        high: "high";
        normal: "normal";
        low: "low";
    }>>;
}, z.core.$strict>;
declare const offlineConfigSchema: z.ZodObject<{
    enabled: z.ZodBoolean;
    versions: z.ZodObject<{
        test: z.ZodOptional<z.ZodString>;
        prod: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>;
    whitelistPages: z.ZodOptional<z.ZodArray<z.ZodString>>;
    prefetch: z.ZodOptional<z.ZodArray<z.ZodObject<{
        name: z.ZodString;
        match: z.ZodUnion<readonly [z.ZodObject<{
            page: z.ZodString;
        }, z.core.$strict>, z.ZodObject<{
            url: z.ZodString;
        }, z.core.$strict>]>;
        keys: z.ZodOptional<z.ZodArray<z.ZodString>>;
        apiUrl: z.ZodString;
        maxAge: z.ZodOptional<z.ZodNumber>;
        priority: z.ZodOptional<z.ZodEnum<{
            high: "high";
            normal: "normal";
            low: "low";
        }>>;
    }, z.core.$strict>>>;
    rollback: z.ZodOptional<z.ZodObject<{
        strategy: z.ZodOptional<z.ZodEnum<{
            previous: "previous";
            none: "none";
        }>>;
    }, z.core.$strip>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
    outDir: z.ZodOptional<z.ZodString>;
}, z.core.$strict>;
type OfflineConfigInput = z.input<typeof offlineConfigSchema>;
type OfflineConfigRaw = z.output<typeof offlineConfigSchema>;
type PrefetchRule = z.output<typeof prefetchRuleSchema>;
interface ResolvedOfflineConfig extends OfflineConfigRaw {
    outDir: string;
}

declare function resolveProjectConfig(input: ProjectConfigRaw, cwd: string): ResolvedProjectConfig;
declare function resolveOfflineConfig(input: OfflineConfigRaw, project: ResolvedProjectConfig): ResolvedOfflineConfig;
/**
 * Resolve an alias target path against the resolved project rootDir.
 */
declare function resolveAliasTarget(rootDir: string, target: string): string;
/**
 * Absolute path of a page entry file.
 */
declare function absolutePageEntry(project: ResolvedProjectConfig, page: ResolvedPageDefinition): string;
/**
 * Check if a project directory structure exists on disk (used by doctor, not by loaders).
 */
declare function entryExists(project: ResolvedProjectConfig, page: ResolvedPageDefinition): boolean;

/**
 * Identity helper with type inference. Users write:
 *   export default defineProjectConfig({...});
 * and get completion on pages/envs/aliases.
 */
declare function defineProjectConfig<T extends ProjectConfigInput>(config: T): T;
declare function defineOfflineConfig<T extends OfflineConfigInput>(config: T): T;

interface Diagnostic {
    level: 'error' | 'warn' | 'info';
    code: string;
    message: string;
    path?: (string | number)[];
    source?: string;
}
declare class ConfigError extends Error {
    readonly diagnostics: Diagnostic[];
    constructor(diagnostics: Diagnostic[]);
}
declare function diagnosticsFromZod(err: ZodError, source: string): Diagnostic[];
declare function formatDiagnostics(diagnostics: Diagnostic[]): string;

interface ListPagesOptions {
    /**
     * When true, return only pages that should be shipped in the offline zip:
     * - pages with `page.offline === true`, plus
     * - pages listed in offline.whitelistPages (if offline config provided).
     */
    offline?: boolean;
    /**
     * When provided, restrict to the given page names (used by LHX_PAGES filtering).
     */
    only?: string[];
}
declare function listPages(project: ResolvedProjectConfig, offline?: ResolvedOfflineConfig | null, options?: ListPagesOptions): ResolvedPageDefinition[];
declare function getPage(project: ResolvedProjectConfig, name: string): ResolvedPageDefinition;
declare function resolveEnv(project: ResolvedProjectConfig, mode: EnvMode): EnvEntry;
declare function resolveAlias(project: ResolvedProjectConfig, name: string): string | null;
declare const ENV_MODES: readonly EnvMode[];
declare function normalizeEnvMode(mode: string | undefined): EnvMode;
/**
 * Extract `${var}` placeholders from a string; used for prefetch apiUrl validation.
 */
declare function extractPlaceholders(input: string): string[];

interface LoadResult<T> {
    config: T;
    file: string;
}
interface LoadOptions {
    /**
     * When true, throw if the config file is missing. Default: true for project, false for offline.
     */
    required?: boolean;
}
/**
 * Load and validate project.config.* from a project root directory.
 * Throws ConfigError with aggregated diagnostics on failure.
 */
declare function loadProjectConfig(rootDir: string, options?: LoadOptions): Promise<LoadResult<ResolvedProjectConfig>>;
/**
 * Load and validate offline.config.* from a project root directory.
 * If the file does not exist but `project.offline.enabled === true`, returns null and a
 * diagnostic is expected to be raised by the caller (CLI/doctor).
 */
declare function loadOfflineConfig(rootDir: string, project: ResolvedProjectConfig, options?: LoadOptions): Promise<LoadResult<ResolvedOfflineConfig> | null>;
/**
 * Walks upward from `startDir` looking for the nearest project.config.*.
 * Returns the directory containing it, or null.
 */
declare function findNearestProjectRoot(startDir: string): string | null;
/**
 * Convenience: load both configs from the same root.
 * Offline config is optional; returns `offline: null` when not present.
 */
declare function loadConfigs(rootDir: string): Promise<{
    project: LoadResult<ResolvedProjectConfig>;
    offline: LoadResult<ResolvedOfflineConfig> | null;
}>;

/**
 * Cross-validate project + offline config against the filesystem.
 * Returns a list of diagnostics; the caller decides how to render them (doctor/info/CI).
 */
declare function validateAgainstFilesystem(project: ResolvedProjectConfig, offline: ResolvedOfflineConfig | null): Diagnostic[];
declare function hasErrors(diagnostics: Diagnostic[]): boolean;

export { type CdnConfig, type CdnConfigInput, type CdnEntry, type CdnEntryInput, ConfigError, type Diagnostic, ENV_MODES, type EnvEntry, type EnvMode, type Framework, type ListPagesOptions, type LoadOptions, type LoadResult, type OfflineConfigInput, type OfflineConfigRaw, type PageDefinition, type PrefetchRule, type ProjectConfigInput, type ProjectConfigRaw, type ResolvedCdnConfig, type ResolvedCdnEntry, type ResolvedOfflineConfig, type ResolvedPageDefinition, type ResolvedProjectConfig, absolutePageEntry, cdnConfigSchema, cdnEntrySchema, defineOfflineConfig, defineProjectConfig, diagnosticsFromZod, entryExists, envEntrySchema, extractPlaceholders, findNearestProjectRoot, formatDiagnostics, getPage, hasErrors, listPages, loadConfigs, loadOfflineConfig, loadProjectConfig, normalizeEnvMode, offlineConfigSchema, pageDefinitionSchema, prefetchRuleSchema, projectConfigSchema, resolveAlias, resolveAliasTarget, resolveEnv, resolveOfflineConfig, resolveProjectConfig, validateAgainstFilesystem, viteProxyEntrySchema };