import type { RegistryIndex, Component, RegistryComponent } from '../schemas/registry.js';
/**
 * Fetch the registry index containing all components
 * @returns Promise resolving to registry index
 */
export declare function fetchRegistryIndex(): Promise<RegistryIndex>;
/**
 * Fetch a specific component by name
 * @param componentName - Name of the component to fetch
 * @returns Promise resolving to component data
 */
export declare function fetchComponent(componentName: string): Promise<Component>;
/**
 * Search components by query and filters
 * @param query - Search query
 * @param category - Optional category filter
 * @param featured - Optional featured filter
 * @returns Promise resolving to search results
 */
export declare function searchComponents(query: string, category?: string, featured?: boolean): Promise<{
    results: RegistryComponent[];
    total: number;
    query: string;
    filters: {
        category?: string;
        featured?: boolean;
    };
}>;
/**
 * Get all components in a specific category
 * @param category - Category name
 * @returns Promise resolving to category components
 */
export declare function getComponentsByCategory(category: string): Promise<{
    category: string;
    categoryInfo: {
        title: string;
        description: string;
    } | null;
    components: RegistryComponent[];
    total: number;
}>;
/**
 * Get all available categories with component counts
 * @returns Promise resolving to categories data
 */
export declare function getCategories(): Promise<{
    categories: Record<string, {
        title: string;
        description: string;
        count: number;
    }>;
    total: number;
}>;
/**
 * Get all featured components
 * @returns Promise resolving to featured components
 */
export declare function getFeaturedComponents(): Promise<{
    components: RegistryComponent[];
    total: number;
}>;
/**
 * Get registry information and statistics
 * @returns Promise resolving to registry info
 */
export declare function getRegistryInfo(): Promise<{
    registry: RegistryIndex;
    stats: {
        totalComponents: number;
        featuredComponents: number;
        categoriesCount: number;
        lastUpdated: string | null;
    };
}>;
/**
 * Interface for utility class information
 */
export interface UtilityClass {
    pattern?: string;
    description?: string;
    values?: string[];
    examples?: string[];
}
export interface UtilityCategory {
    description: string;
    classes: Record<string, UtilityClass>;
}
export interface UtilitiesData {
    version: string;
    description: string;
    lastUpdated: string;
    cssVariables: {
        colors: Record<string, string>;
        spacing: Record<string, string>;
        fonts: Record<string, string>;
        shadows: Record<string, string>;
    };
    categories: Record<string, UtilityCategory>;
    usage: {
        basic: string;
        examples: Array<{
            description: string;
            code: string;
        }>;
    };
    responsive: {
        description: string;
        note: string;
    };
    customization: {
        description: string;
        note: string;
    };
}
/**
 * Fetch utilities.json containing all utility class information
 * @returns Promise resolving to utilities data
 */
export declare function fetchUtilities(): Promise<UtilitiesData>;
/**
 * Search utility classes by name, pattern, or description
 * @param query - Search query
 * @param category - Optional category filter
 * @returns Promise resolving to matching utilities
 */
export declare function searchUtilities(query: string, category?: string): Promise<{
    results: Array<{
        name: string;
        category: string;
        pattern?: string;
        description?: string;
        values?: string[];
        examples?: string[];
    }>;
    total: number;
    query: string;
    category?: string;
}>;
/**
 * Get all utility classes in a specific category
 * @param categoryName - Category name
 * @returns Promise resolving to category utilities
 */
export declare function getUtilitiesByCategory(categoryName: string): Promise<{
    category: string;
    categoryData: UtilityCategory;
    classes: Array<{
        name: string;
        pattern?: string;
        description?: string;
        values?: string[];
        examples?: string[];
    }>;
    total: number;
}>;
/**
 * Get all available utility categories
 * @returns Promise resolving to categories data
 */
export declare function getUtilityCategories(): Promise<{
    categories: Record<string, {
        description: string;
        classCount: number;
    }>;
    total: number;
}>;