import type { ConfigValidationResult, GeneratorConfig, GeneratorConfigBuilder, PackageConfig, TypeScriptConfig } from '../types';
/**
 * Fluent builder for `GeneratorConfig`. Starts from `createDefaultConfig()`
 * so every setter is a partial override; `build()` validates first and
 * throws on a config that cannot run (no packages, enabled output without a
 * path). The `ConfigurationFactory` presets are thin compositions over this.
 */
export declare class DocsConfigurationBuilder implements GeneratorConfigBuilder {
    private config;
    /**
     * Start a builder from the defaults, optionally shallow-merging a partial
     * base config over them (top-level sections replace wholesale; the result
     * is deep-cloned so the builder never aliases caller state).
     */
    constructor(baseConfig?: Partial<GeneratorConfig>);
    /**
     * Add a package to scan (repeatable). At least one package is required —
     * `validate()` fails an empty list, so `build()` throws without any.
     */
    addPackage(packageConfig: PackageConfig): GeneratorConfigBuilder;
    /**
     * Set the package TypeScript context. `configPath` is the switch that
     * enables program-backed cross-file type resolution in extraction; every
     * `ConfigurationFactory` preset points it at the package's tsconfig.json.
     */
    setTypeScript(tsConfig: TypeScriptConfig): GeneratorConfigBuilder;
    /**
     * Override the docs-schema expectations (version, strictness), merged over
     * the default `{ version: '2.0.0', strict: true }`.
     */
    setSchema(schemaConfig: Partial<GeneratorConfig['input']['schema']>): GeneratorConfigBuilder;
    /**
     * Override extraction settings, shallow-merged over the defaults (a passed
     * sub-config like `typescript` replaces that whole block, so restate any
     * default flags you want to keep).
     */
    setExtraction(extractionConfig: Partial<GeneratorConfig['processing']['extraction']>): GeneratorConfigBuilder;
    /** Override enrichment settings (cross-references, derived metadata), shallow-merged over the defaults. */
    setEnrichment(enrichmentConfig: Partial<GeneratorConfig['processing']['enrichment']>): GeneratorConfigBuilder;
    /** Override validation settings (rules, schema gate), shallow-merged over the defaults. */
    setValidation(validationConfig: Partial<GeneratorConfig['processing']['validation']>): GeneratorConfigBuilder;
    /**
     * Turn on batched parallel extraction (default concurrency 4). Note the
     * side effect in `PipelineOrchestrator`: with parallel extraction enabled
     * the ErrorHandler is created non-fail-fast.
     */
    enableParallel(parallelConfig?: Partial<GeneratorConfig['processing']['parallel']>): GeneratorConfigBuilder;
    /**
     * Configure the LLM output target, merged over the defaults. An
     * extension-less `outputPath` selects directory mode (per-component
     * llm.txt tree + llms.txt manifests) — how all presets run.
     */
    setLLMOutput(llmConfig: Partial<GeneratorConfig['output']['llm']>): GeneratorConfigBuilder;
    /**
     * Configure the API output target, merged over the defaults. An
     * extension-less `outputPath` selects directory mode (one typed `api.ts`
     * per component under its route) — how all presets run.
     */
    setAPIOutput(apiConfig: Partial<GeneratorConfig['output']['api']>): GeneratorConfigBuilder;
    /**
     * Turn on debug reporting (default level `info`, console output). Gates
     * the full error report on partially-failed pipeline runs.
     */
    enableDebug(debugConfig?: Partial<GeneratorConfig['debug']>): GeneratorConfigBuilder;
    /**
     * Check the assembled config without building. Blocking errors: no
     * packages, or an enabled output (LLM/API) without an `outputPath`.
     * Warnings are advisory and never fail validation.
     */
    validate(): ConfigValidationResult;
    /**
     * Validate and return the final config. Throws with all validation errors
     * joined when the config cannot run; logs (but tolerates) warnings.
     */
    build(): GeneratorConfig;
    /** Discard everything configured so far and return to the pristine defaults. */
    reset(): GeneratorConfigBuilder;
}
/**
 * Preset `GeneratorConfig`s for the four in-repo targets (blocks, docs,
 * table, auth) plus file-based loading for external configs. Each preset
 * points the extraction at the package's own tsconfig (cross-file type
 * resolution) and writes into the docs app's static/routes trees — these are
 * exactly the configs `docs-gen generate` runs per `--target`.
 */
export declare class ConfigurationFactory {
    /**
     * Preset for `@urbicon-ui/blocks`: scans every primitives/components
     * `index.ts`, resolves types via `../blocks/tsconfig.json`, and writes
     * llm.txt to `apps/docs/static/blocks` + per-component api.ts under the
     * `/blocks` routes.
     */
    static blocks(): GeneratorConfig;
    /**
     * Preset for `@urbicon-ui/docs` (the documentation UI components):
     * mirrors the blocks preset onto `static/docs` + the `/docs` routes.
     */
    static docs(): GeneratorConfig;
    /**
     * Preset for `@urbicon-ui/table`: a single component entry
     * (`src/lib/core/table/index.ts`), written onto `static/table` + the
     * `/table` routes.
     */
    static table(): GeneratorConfig;
    /**
     * Preset for `@urbicon-ui/auth`: scans each `index.ts` under
     * `src/lib/client/components/`, written onto `static/auth` + the `/auth`
     * routes.
     */
    static auth(): GeneratorConfig;
    /**
     * Minimal config for an arbitrary package following the conventional
     * `src/components/<Name>/` layout, with default output paths. No tsconfig
     * is wired, so extraction stays single-file.
     */
    static singlePackage(packagePath: string, packageName: string): GeneratorConfig;
    /**
     * Load a config from disk — `.json` or an ES module (`.js`/`.mjs`/`.ts`
     * with a default or named `config` export). The loaded data is replayed
     * through the builder, so it gets the same defaults-merge and fail-loud
     * validation as a programmatic config. Throws on a missing file, an
     * unsupported extension, or validation errors.
     */
    static fromFile(configPath: string): Promise<GeneratorConfig>;
    /** Parse a JSON config file and replay it through the builder. */
    private static loadJSONConfig;
    /**
     * Import an ES-module config (default or named `config` export) and replay
     * it through the builder. Throws when the module exports neither.
     */
    private static loadESModuleConfig;
    /**
     * Replay loaded config data section-by-section through a fresh builder,
     * so file-based configs share the exact defaults + validation of
     * programmatic ones (build() throws on an unrunnable config).
     */
    private static validateAndBuildConfig;
}
//# sourceMappingURL=ConfigurationBuilder.d.ts.map