import { z } from 'zod';

declare const ScanWorkspaceOptionsSchema: z.ZodObject<{
    includeExtensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
    ignoreDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
    useCache: z.ZodOptional<z.ZodBoolean>;
    cacheDir: z.ZodOptional<z.ZodString>;
    smartInvalidation: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;
type ScanWorkspaceOptions = z.infer<typeof ScanWorkspaceOptionsSchema>;
declare const ScanWorkspaceResultSchema: z.ZodObject<{
    files: z.ZodArray<z.ZodObject<{
        file: z.ZodString;
        classes: z.ZodArray<z.ZodString>;
        hash: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
    totalFiles: z.ZodNumber;
    uniqueClasses: z.ZodArray<z.ZodString>;
}, z.core.$strip>;
type ScanWorkspaceResult = z.infer<typeof ScanWorkspaceResultSchema>;

/**
 * Public type contracts for @tailwind-styled/analyzer.
 * Keep this file aligned with the runtime report shape exposed by src/index.ts.
 */

interface ClassUsage {
    readonly name: string;
    readonly count: number;
    readonly isUnused?: boolean;
    readonly isConflict?: boolean;
}
interface ClassConflict {
    readonly className: string;
    readonly variants: readonly string[];
    readonly classes: readonly string[];
    readonly message: string;
}
interface AnalyzerClassStats {
    readonly all: readonly ClassUsage[];
    readonly top: readonly ClassUsage[];
    readonly frequent: readonly ClassUsage[];
    readonly unique: readonly ClassUsage[];
    readonly distribution: Readonly<Record<string, number>>;
}
interface TailwindConfigSummary {
    readonly path: string;
    readonly loaded: boolean;
    readonly safelistCount: number;
    readonly customUtilityCount: number;
    readonly warning?: string;
}
interface AnalyzerSemanticReport {
    readonly unusedClasses: readonly ClassUsage[];
    readonly unknownClasses: readonly ClassUsage[];
    readonly conflicts: readonly ClassConflict[];
    readonly tailwindConfig?: TailwindConfigSummary;
}
interface AnalyzerReport {
    readonly root: string;
    readonly totalFiles: number;
    readonly uniqueClassCount: number;
    readonly totalClassOccurrences: number;
    readonly classStats: AnalyzerClassStats;
    /** Alias for classStats.top — backward compat & test contract */
    readonly topClasses: readonly ClassUsage[];
    readonly safelist: readonly string[];
    readonly semantic?: AnalyzerSemanticReport;
}
interface AnalyzerOptions {
    readonly scanner?: ScanWorkspaceOptions;
    readonly classStats?: {
        readonly top?: number;
        readonly frequentThreshold?: number;
    };
    readonly includeClass?: (className: string) => boolean;
    readonly semantic?: boolean | {
        readonly tailwindConfigPath?: string;
    };
}
interface ClassToCssOptions {
    readonly prefix?: string | null;
    readonly strict?: boolean;
}
interface ClassToCssResult {
    readonly inputClasses: readonly string[];
    readonly css: string;
    readonly declarations: string;
    readonly resolvedClasses: readonly string[];
    readonly unknownClasses: readonly string[];
    readonly sizeBytes: number;
}
interface NativeAnalyzerBinding {
    analyzeClassesWorkspace?(filesJson: string, cwd: string, flags: number): unknown;
    analyzeClasses(filesJson: string, cwd: string, flags: number): unknown;
    compileCss?: (classes: string[], prefix: string | null) => unknown;
    /** Detect conflicting Tailwind utilities in a usage list. */
    detectClassConflicts?(usagesJson: string): {
        conflicts: Array<{
            group: string;
            variantKey: string;
            classes: string[];
            message: string;
        }>;
        conflictedClassNames: string[];
    };
    /** Classify classes as known/unknown Tailwind utilities. */
    classifyKnownClasses?(classes: string[], safelist: string[], customUtilities: string[]): Array<{
        className: string;
        isKnown: boolean;
        variantKey: string;
        baseClass: string;
        utilityPrefix: string;
        isArbitrary: boolean;
    }>;
    /** Map Tailwind class base → conflict group name. Return "" if no group. */
    resolveConflictGroup?(base: string): string;
    /** Aggregate class counts from scan files JSON. */
    collectClassCounts?(filesJson: string): Array<{
        name: string;
        count: number;
    }>;
    /** Compute frequency distribution buckets for class usages. */
    computeClassStats?(usagesJson: string, topLimit: number, frequentThreshold: number): {
        totalClassOccurrences: number;
        topJson: string;
        frequentJson: string;
        uniqueJson: string;
    };
    buildDistribution?(usagesJson: string): {
        once: number;
        few: number;
        moderate: number;
        frequent: number;
    };
}

declare function requireNativeBinding(): Promise<NativeAnalyzerBinding>;

declare function collectClassCounts(scan: ScanWorkspaceResult): Promise<Map<string, number>>;
declare function buildDistribution(usages: ClassUsage[], native?: Awaited<ReturnType<typeof requireNativeBinding>>): Promise<Record<string, number>>;
/**
 * Analyze Tailwind class usage in a workspace and return usage statistics.
 * Set `semantic.tailwindConfigPath` to override Tailwind config lookup.
 * @example
 * const report = await analyzeWorkspace("./src", {
 *   classStats: { top: 20, frequentThreshold: 2 },
 *   semantic: { tailwindConfigPath: "tailwind.config.js" },
 * })
 */
declare function analyzeWorkspace(root: string, options?: AnalyzerOptions): Promise<AnalyzerReport>;

/**
 * Convert Tailwind class input into atomic CSS output via native binding.
 * @example
 * const css = await classToCss("opacity-0 translate-y-2", { strict: true })
 */
declare const classToCss: (input: string | string[], options?: ClassToCssOptions) => Promise<ClassToCssResult>;

/**
 * @tailwind-styled/analyzer v5
 *
 * Native-first async analyzer with semantic reporting.
 */

declare const __internal: {
    normalizeClassInput: (input: string | string[], binding: {
        normalizeClassInput?: (s: string) => string[];
    }) => string[];
    splitVariantAndBase: (className: string) => {
        variantKey: string;
        base: string;
    };
    resolveConflictGroup: (base: string) => Promise<string | null>;
    collectClassCounts: typeof collectClassCounts;
    buildDistribution: typeof buildDistribution;
    utilityPrefix: (baseClass: string) => string;
    parseAnalyzerOptions: (options: unknown) => {
        scanner?: {
            includeExtensions?: string[] | undefined;
            ignoreDirectories?: string[] | undefined;
            useCache?: boolean | undefined;
            cacheDir?: string | undefined;
            smartInvalidation?: boolean | undefined;
        } | undefined;
        classStats?: {
            top?: number | undefined;
            frequentThreshold?: number | undefined;
        } | undefined;
        semantic?: boolean | {
            tailwindConfigPath?: string | undefined;
        } | undefined;
        includeClass?: ((className: string) => boolean) | undefined;
    };
    parseClassToCssOptions: (options: unknown) => {
        prefix?: string | null | undefined;
        strict?: boolean | undefined;
    };
    parseNativeReport: (report: unknown) => {
        root: string;
        totalFiles: number;
        uniqueClassCount: number;
        totalClassOccurrences: number;
        topClasses: {
            name: string;
            count: number;
        }[];
        duplicateCandidates: {
            name: string;
            count: number;
        }[];
        safelist: string[];
    };
    parseNativeCssCompileResult: (result: unknown, className?: string) => {
        css: string;
        resolvedClasses: string[];
        unknownClasses: string[];
        sizeBytes: number;
    };
};

export { type AnalyzerOptions, type AnalyzerReport, type AnalyzerSemanticReport, type ClassConflict, type ClassToCssOptions, type ClassToCssResult, type ClassUsage, __internal, analyzeWorkspace, classToCss };