interface MatchOptions {
    partial?: boolean;
}
interface CompileOptions {
    partial?: boolean;
}
interface MatcherOptions {
    partial?: boolean;
}
/**
 * Check if a glob pattern matches a path
 * @param pattern - The glob pattern to match against
 * @param input - The input string to test
 * @param options - Optional configuration
 * @returns True if the pattern matches the input
 */
export declare const match: (pattern: string, input: string, options?: MatchOptions) => boolean;
/**
 * Check if a glob pattern matches a path (alias for match)
 * @param pattern - The glob pattern to match against
 * @param input - The input string to test
 * @param options - Optional configuration
 * @returns True if the pattern matches the input
 */
export declare const isMatch: (pattern: string, input: string, options?: MatchOptions) => boolean;
/**
 * Create a matcher function for a specific pattern
 * @param pattern - The glob pattern to compile
 * @param options - Optional configuration
 * @returns A function that tests input against the pattern
 */
export declare const createMatcher: (pattern: string, options?: MatcherOptions) => (input: string) => boolean;
/**
 * Create multiple matcher functions for multiple patterns
 * @param patterns - Array of glob patterns to compile
 * @param options - Optional configuration
 * @returns Array of matcher functions
 */
export declare const createMatchers: (patterns: string[], options?: MatcherOptions) => ((input: string) => boolean)[];
/**
 * Test if any of the patterns match the input
 * @param patterns - Array of glob patterns to test
 * @param input - The input string to test
 * @param options - Optional configuration
 * @returns True if any pattern matches
 */
export declare const matchAny: (patterns: string[], input: string, options?: MatchOptions) => boolean;
/**
 * Test if all patterns match the input
 * @param patterns - Array of glob patterns to test
 * @param input - The input string to test
 * @param options - Optional configuration
 * @returns True if all patterns match
 */
export declare const matchAll: (patterns: string[], input: string, options?: MatchOptions) => boolean;
/**
 * Filter an array of strings based on glob patterns
 * @param patterns - Array of glob patterns to match against
 * @param inputs - Array of strings to filter
 * @param options - Optional configuration
 * @returns Array of strings that match any of the patterns
 */
export declare const filter: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
/**
 * Filter an array of strings, excluding those that match glob patterns
 * @param patterns - Array of glob patterns to exclude
 * @param inputs - Array of strings to filter
 * @param options - Optional configuration
 * @returns Array of strings that don't match any of the patterns
 */
export declare const exclude: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
/**
 * Compile a glob pattern to a regular expression
 * @param pattern - The glob pattern to compile
 * @param options - Optional configuration
 * @returns Compiled regular expression
 */
export declare const compile: (pattern: string, options?: CompileOptions) => RegExp;
/**
 * Compile multiple glob patterns to a single regular expression
 * @param patterns - Array of glob patterns to compile
 * @param options - Optional configuration
 * @returns Compiled regular expression that matches any of the patterns
 */
export declare const compileAny: (patterns: string[], options?: CompileOptions) => RegExp;
/**
 * Normalize glob patterns by splitting on whitespace and filtering empty strings
 * @param patterns - String or array of patterns to normalize
 * @returns Normalized array of patterns
 */
export declare const normalizePatterns: (patterns: string | string[]) => string[];
/**
 * Create a filter function that excludes patterns
 * @param ignorePatterns - Patterns to ignore (string or array)
 * @param options - Optional configuration
 * @returns Function that filters out matching items
 */
export declare const createIgnoreFilter: (ignorePatterns: string | string[], options?: MatcherOptions) => <T extends {
    name: string;
}>(items: T[]) => T[];
/**
 * Create a filter function that includes only matching patterns
 * @param includePatterns - Patterns to include (string or array)
 * @param options - Optional configuration
 * @returns Function that filters to only matching items
 */
export declare const createIncludeFilter: (includePatterns: string | string[], options?: MatcherOptions) => <T extends {
    name: string;
}>(items: T[]) => T[];
declare const _default: {
    match: (pattern: string, input: string, options?: MatchOptions) => boolean;
    isMatch: (pattern: string, input: string, options?: MatchOptions) => boolean;
    createMatcher: (pattern: string, options?: MatcherOptions) => (input: string) => boolean;
    createMatchers: (patterns: string[], options?: MatcherOptions) => ((input: string) => boolean)[];
    matchAny: (patterns: string[], input: string, options?: MatchOptions) => boolean;
    matchAll: (patterns: string[], input: string, options?: MatchOptions) => boolean;
    filter: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
    exclude: (patterns: string[], inputs: string[], options?: MatchOptions) => string[];
    compile: (pattern: string, options?: CompileOptions) => RegExp;
    compileAny: (patterns: string[], options?: CompileOptions) => RegExp;
    normalizePatterns: (patterns: string | string[]) => string[];
    createIgnoreFilter: (ignorePatterns: string | string[], options?: MatcherOptions) => <T extends {
        name: string;
    }>(items: T[]) => T[];
    createIncludeFilter: (includePatterns: string | string[], options?: MatcherOptions) => <T extends {
        name: string;
    }>(items: T[]) => T[];
};
export default _default;