/**
 * Configuration schema validation using Zod
 */
import { z } from 'zod';
export declare const reScriptConfigSchema: z.ZodObject<{
    provider: z.ZodObject<{
        name: z.ZodEnum<["openai", "anthropic", "ollama", "azure", "bedrock"]>;
        model: z.ZodString;
        apiKey: z.ZodOptional<z.ZodString>;
        baseUrl: z.ZodOptional<z.ZodString>;
        temperature: z.ZodDefault<z.ZodNumber>;
        maxTokens: z.ZodDefault<z.ZodNumber>;
        timeout: z.ZodDefault<z.ZodNumber>;
    }, "strip", z.ZodTypeAny, {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    }, {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    }>;
    processing: z.ZodDefault<z.ZodObject<{
        chunking: z.ZodDefault<z.ZodObject<{
            strategy: z.ZodDefault<z.ZodEnum<["simple", "ast-aware", "semantic"]>>;
            maxChunkSize: z.ZodDefault<z.ZodNumber>;
            overlapPercentage: z.ZodDefault<z.ZodNumber>;
            respectFunctionBoundaries: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        }, {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        }>>;
        caching: z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            ttl: z.ZodDefault<z.ZodNumber>;
            backend: z.ZodDefault<z.ZodEnum<["memory", "file", "redis"]>>;
            maxSize: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        }, {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        }>>;
        retries: z.ZodDefault<z.ZodObject<{
            maxAttempts: z.ZodDefault<z.ZodNumber>;
            backoffFactor: z.ZodDefault<z.ZodNumber>;
            maxDelay: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        }, {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        }>>;
        concurrency: z.ZodDefault<z.ZodNumber>;
        preserveComments: z.ZodDefault<z.ZodBoolean>;
        preserveSourceMaps: z.ZodDefault<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    }, {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    }>>;
    output: z.ZodDefault<z.ZodObject<{
        format: z.ZodDefault<z.ZodEnum<["prettier", "custom"]>>;
        prettierOptions: z.ZodDefault<z.ZodObject<{
            parser: z.ZodDefault<z.ZodString>;
            printWidth: z.ZodDefault<z.ZodNumber>;
            tabWidth: z.ZodDefault<z.ZodNumber>;
            useTabs: z.ZodDefault<z.ZodBoolean>;
            semi: z.ZodDefault<z.ZodBoolean>;
            singleQuote: z.ZodDefault<z.ZodBoolean>;
            trailingComma: z.ZodDefault<z.ZodEnum<["none", "es5", "all"]>>;
        }, "strip", z.ZodTypeAny, {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        }, {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        }>>;
        generateSourceMaps: z.ZodDefault<z.ZodBoolean>;
        addComments: z.ZodDefault<z.ZodBoolean>;
        commentStyle: z.ZodDefault<z.ZodEnum<["block", "line"]>>;
    }, "strip", z.ZodTypeAny, {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    }, {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    }>>;
    advanced: z.ZodDefault<z.ZodObject<{
        enablePlugins: z.ZodDefault<z.ZodBoolean>;
        pluginPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        pluginConfig: z.ZodDefault<z.ZodObject<{
            discovery: z.ZodDefault<z.ZodObject<{
                paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                patterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            }, {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            }>>;
            security: z.ZodDefault<z.ZodObject<{
                allowedApis: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                allowedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                timeoutMs: z.ZodDefault<z.ZodNumber>;
                memoryLimitMB: z.ZodDefault<z.ZodNumber>;
                networkAccess: z.ZodDefault<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            }, {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            }>>;
            execution: z.ZodDefault<z.ZodObject<{
                hooks: z.ZodDefault<z.ZodObject<{
                    beforeTransform: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    afterTransform: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    beforeAnalysis: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    afterAnalysis: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    onError: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                }, "strip", z.ZodTypeAny, {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                }, {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                }>>;
                chains: z.ZodDefault<z.ZodObject<{
                    transformers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                    analyzers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                }, "strip", z.ZodTypeAny, {
                    transformers?: string[];
                    analyzers?: string[];
                }, {
                    transformers?: string[];
                    analyzers?: string[];
                }>>;
                configs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
                    enabled: z.ZodDefault<z.ZodBoolean>;
                    priority: z.ZodDefault<z.ZodNumber>;
                    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                }, "strip", z.ZodTypeAny, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>>>;
            }, "strip", z.ZodTypeAny, {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            }, {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            }>>;
        }, "strip", z.ZodTypeAny, {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        }, {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        }>>;
        experimentalFeatures: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
        debugMode: z.ZodDefault<z.ZodBoolean>;
        logLevel: z.ZodDefault<z.ZodEnum<["error", "warn", "info", "debug"]>>;
    }, "strip", z.ZodTypeAny, {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    }, {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    }>>;
}, "strip", z.ZodTypeAny, {
    provider?: {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    };
    processing?: {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    };
    output?: {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    };
    advanced?: {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    };
}, {
    provider?: {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    };
    processing?: {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    };
    output?: {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    };
    advanced?: {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    };
}>;
export declare const partialConfigSchema: z.ZodObject<{
    provider: z.ZodOptional<z.ZodOptional<z.ZodObject<{
        name: z.ZodOptional<z.ZodEnum<["openai", "anthropic", "ollama", "azure", "bedrock"]>>;
        model: z.ZodOptional<z.ZodString>;
        apiKey: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        baseUrl: z.ZodOptional<z.ZodOptional<z.ZodString>>;
        temperature: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        maxTokens: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        timeout: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
    }, "strip", z.ZodTypeAny, {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    }, {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    }>>>;
    processing: z.ZodOptional<z.ZodOptional<z.ZodObject<{
        chunking: z.ZodOptional<z.ZodDefault<z.ZodObject<{
            strategy: z.ZodDefault<z.ZodEnum<["simple", "ast-aware", "semantic"]>>;
            maxChunkSize: z.ZodDefault<z.ZodNumber>;
            overlapPercentage: z.ZodDefault<z.ZodNumber>;
            respectFunctionBoundaries: z.ZodDefault<z.ZodBoolean>;
        }, "strip", z.ZodTypeAny, {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        }, {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        }>>>;
        caching: z.ZodOptional<z.ZodDefault<z.ZodObject<{
            enabled: z.ZodDefault<z.ZodBoolean>;
            ttl: z.ZodDefault<z.ZodNumber>;
            backend: z.ZodDefault<z.ZodEnum<["memory", "file", "redis"]>>;
            maxSize: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        }, {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        }>>>;
        retries: z.ZodOptional<z.ZodDefault<z.ZodObject<{
            maxAttempts: z.ZodDefault<z.ZodNumber>;
            backoffFactor: z.ZodDefault<z.ZodNumber>;
            maxDelay: z.ZodDefault<z.ZodNumber>;
        }, "strip", z.ZodTypeAny, {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        }, {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        }>>>;
        concurrency: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
        preserveComments: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        preserveSourceMaps: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
    }, "strip", z.ZodTypeAny, {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    }, {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    }>>>;
    output: z.ZodOptional<z.ZodOptional<z.ZodObject<{
        format: z.ZodOptional<z.ZodDefault<z.ZodEnum<["prettier", "custom"]>>>;
        prettierOptions: z.ZodOptional<z.ZodDefault<z.ZodObject<{
            parser: z.ZodDefault<z.ZodString>;
            printWidth: z.ZodDefault<z.ZodNumber>;
            tabWidth: z.ZodDefault<z.ZodNumber>;
            useTabs: z.ZodDefault<z.ZodBoolean>;
            semi: z.ZodDefault<z.ZodBoolean>;
            singleQuote: z.ZodDefault<z.ZodBoolean>;
            trailingComma: z.ZodDefault<z.ZodEnum<["none", "es5", "all"]>>;
        }, "strip", z.ZodTypeAny, {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        }, {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        }>>>;
        generateSourceMaps: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        addComments: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        commentStyle: z.ZodOptional<z.ZodDefault<z.ZodEnum<["block", "line"]>>>;
    }, "strip", z.ZodTypeAny, {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    }, {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    }>>>;
    advanced: z.ZodOptional<z.ZodOptional<z.ZodObject<{
        enablePlugins: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        pluginPaths: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
        pluginConfig: z.ZodOptional<z.ZodDefault<z.ZodObject<{
            discovery: z.ZodDefault<z.ZodObject<{
                paths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                patterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                excludePatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
            }, "strip", z.ZodTypeAny, {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            }, {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            }>>;
            security: z.ZodDefault<z.ZodObject<{
                allowedApis: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                allowedPaths: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                timeoutMs: z.ZodDefault<z.ZodNumber>;
                memoryLimitMB: z.ZodDefault<z.ZodNumber>;
                networkAccess: z.ZodDefault<z.ZodBoolean>;
            }, "strip", z.ZodTypeAny, {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            }, {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            }>>;
            execution: z.ZodDefault<z.ZodObject<{
                hooks: z.ZodDefault<z.ZodObject<{
                    beforeTransform: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    afterTransform: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    beforeAnalysis: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    afterAnalysis: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                    onError: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
                }, "strip", z.ZodTypeAny, {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                }, {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                }>>;
                chains: z.ZodDefault<z.ZodObject<{
                    transformers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                    analyzers: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
                }, "strip", z.ZodTypeAny, {
                    transformers?: string[];
                    analyzers?: string[];
                }, {
                    transformers?: string[];
                    analyzers?: string[];
                }>>;
                configs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
                    enabled: z.ZodDefault<z.ZodBoolean>;
                    priority: z.ZodDefault<z.ZodNumber>;
                    options: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
                }, "strip", z.ZodTypeAny, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>>>;
            }, "strip", z.ZodTypeAny, {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            }, {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            }>>;
        }, "strip", z.ZodTypeAny, {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        }, {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        }>>>;
        experimentalFeatures: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
        debugMode: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
        logLevel: z.ZodOptional<z.ZodDefault<z.ZodEnum<["error", "warn", "info", "debug"]>>>;
    }, "strip", z.ZodTypeAny, {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    }, {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    }>>>;
}, "strip", z.ZodTypeAny, {
    provider?: {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    };
    processing?: {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    };
    output?: {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    };
    advanced?: {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    };
}, {
    provider?: {
        name?: "openai" | "anthropic" | "ollama" | "azure" | "bedrock";
        model?: string;
        apiKey?: string;
        baseUrl?: string;
        temperature?: number;
        maxTokens?: number;
        timeout?: number;
    };
    processing?: {
        chunking?: {
            strategy?: "simple" | "ast-aware" | "semantic";
            maxChunkSize?: number;
            overlapPercentage?: number;
            respectFunctionBoundaries?: boolean;
        };
        caching?: {
            enabled?: boolean;
            ttl?: number;
            backend?: "memory" | "file" | "redis";
            maxSize?: number;
        };
        retries?: {
            maxAttempts?: number;
            backoffFactor?: number;
            maxDelay?: number;
        };
        concurrency?: number;
        preserveComments?: boolean;
        preserveSourceMaps?: boolean;
    };
    output?: {
        format?: "prettier" | "custom";
        prettierOptions?: {
            parser?: string;
            printWidth?: number;
            tabWidth?: number;
            useTabs?: boolean;
            semi?: boolean;
            singleQuote?: boolean;
            trailingComma?: "none" | "es5" | "all";
        };
        generateSourceMaps?: boolean;
        addComments?: boolean;
        commentStyle?: "block" | "line";
    };
    advanced?: {
        enablePlugins?: boolean;
        pluginPaths?: string[];
        pluginConfig?: {
            discovery?: {
                paths?: string[];
                patterns?: string[];
                excludePatterns?: string[];
            };
            security?: {
                allowedApis?: string[];
                allowedPaths?: string[];
                timeoutMs?: number;
                memoryLimitMB?: number;
                networkAccess?: boolean;
            };
            execution?: {
                hooks?: {
                    beforeTransform?: string[];
                    afterTransform?: string[];
                    beforeAnalysis?: string[];
                    afterAnalysis?: string[];
                    onError?: string[];
                };
                chains?: {
                    transformers?: string[];
                    analyzers?: string[];
                };
                configs?: Record<string, {
                    options?: Record<string, unknown>;
                    enabled?: boolean;
                    priority?: number;
                }>;
            };
        };
        experimentalFeatures?: string[];
        debugMode?: boolean;
        logLevel?: "error" | "warn" | "info" | "debug";
    };
}>;
export declare const cliOptionsSchema: z.ZodObject<{
    input: z.ZodString;
    output: z.ZodOptional<z.ZodString>;
    config: z.ZodOptional<z.ZodString>;
    provider: z.ZodOptional<z.ZodString>;
    model: z.ZodOptional<z.ZodString>;
    apiKey: z.ZodOptional<z.ZodString>;
    temperature: z.ZodOptional<z.ZodNumber>;
    maxTokens: z.ZodOptional<z.ZodNumber>;
    concurrency: z.ZodOptional<z.ZodNumber>;
    dryRun: z.ZodDefault<z.ZodBoolean>;
    watch: z.ZodDefault<z.ZodBoolean>;
    recursive: z.ZodDefault<z.ZodBoolean>;
    pattern: z.ZodOptional<z.ZodString>;
    exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    verbose: z.ZodDefault<z.ZodBoolean>;
    quiet: z.ZodDefault<z.ZodBoolean>;
    force: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    model?: string;
    apiKey?: string;
    temperature?: number;
    maxTokens?: number;
    concurrency?: number;
    provider?: string;
    output?: string;
    input?: string;
    config?: string;
    dryRun?: boolean;
    watch?: boolean;
    recursive?: boolean;
    pattern?: string;
    exclude?: string[];
    verbose?: boolean;
    quiet?: boolean;
    force?: boolean;
}, {
    model?: string;
    apiKey?: string;
    temperature?: number;
    maxTokens?: number;
    concurrency?: number;
    provider?: string;
    output?: string;
    input?: string;
    config?: string;
    dryRun?: boolean;
    watch?: boolean;
    recursive?: boolean;
    pattern?: string;
    exclude?: string[];
    verbose?: boolean;
    quiet?: boolean;
    force?: boolean;
}>;
export declare const jobInputSchema: z.ZodObject<{
    files: z.ZodArray<z.ZodString, "many">;
    options: z.ZodDefault<z.ZodObject<{
        outputDir: z.ZodOptional<z.ZodString>;
        recursive: z.ZodDefault<z.ZodBoolean>;
        pattern: z.ZodOptional<z.ZodString>;
        exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        recursive?: boolean;
        pattern?: string;
        exclude?: string[];
        outputDir?: string;
    }, {
        recursive?: boolean;
        pattern?: string;
        exclude?: string[];
        outputDir?: string;
    }>>;
}, "strip", z.ZodTypeAny, {
    options?: {
        recursive?: boolean;
        pattern?: string;
        exclude?: string[];
        outputDir?: string;
    };
    files?: string[];
}, {
    options?: {
        recursive?: boolean;
        pattern?: string;
        exclude?: string[];
        outputDir?: string;
    };
    files?: string[];
}>;
export type ReScriptConfig = z.infer<typeof reScriptConfigSchema>;
export type PartialConfig = z.infer<typeof partialConfigSchema>;
export type CliOptions = z.infer<typeof cliOptionsSchema>;
export type JobInput = z.infer<typeof jobInputSchema>;
export declare const defaultConfig: ReScriptConfig;
export declare function validateConfig(config: unknown): ReScriptConfig;
export declare function validatePartialConfig(config: unknown): PartialConfig;
export declare function validateCliOptions(options: unknown): CliOptions;
export declare function validateJobInput(input: unknown): JobInput;
export declare function mergeConfig(base: ReScriptConfig, override: PartialConfig): ReScriptConfig;
export declare const envVarMapping: {
    readonly RESCRIPT_PROVIDER: "provider.name";
    readonly RESCRIPT_MODEL: "provider.model";
    readonly OPENAI_API_KEY: "provider.apiKey";
    readonly ANTHROPIC_API_KEY: "provider.apiKey";
    readonly OLLAMA_BASE_URL: "provider.baseUrl";
    readonly RESCRIPT_TEMPERATURE: "provider.temperature";
    readonly RESCRIPT_MAX_TOKENS: "provider.maxTokens";
    readonly RESCRIPT_CONCURRENCY: "processing.concurrency";
    readonly RESCRIPT_DEBUG: "advanced.debugMode";
    readonly RESCRIPT_LOG_LEVEL: "advanced.logLevel";
};
//# sourceMappingURL=schema.d.ts.map