@equantic/linq/filtering/CompositeFiltering.d.ts

eQuantic Linq for JavaScript

import { CompositeOperator } from './CompositeOperator.js';
import { Filtering } from './Filtering.js';
import { IFiltering } from './base.js';
import type { FieldPath } from '../base.js';
/**
 * Represents a composite filtering operation that combines multiple filtering conditions using logical operators.
 * Supports And/Or operations for regular conditions and Any/All operations for collection-based filtering.
 *
 * @template TData - The type of data being filtered
 * @template TColumn - The type of column/field path being filtered
 */
export declare class CompositeFiltering<TData extends object = any, TColumn extends FieldPath<TData> = FieldPath<TData>> extends Filtering<TData, TColumn> {
    /** Array of filtering conditions to be combined using the composite operator */
    values: IFiltering<TData>[];
    /** The composite operator used to combine the filtering conditions */
    compositeOperator: CompositeOperator;
    /**
     * Creates a new CompositeFiltering instance with the specified operator and filter values.
     * @param compositeOperator - The composite operator to use for combining the conditions
     * @param values - Array of string filter expressions or filtering instances to be combined
     */
    constructor(compositeOperator: CompositeOperator, values?: IFiltering<TData>[] | string[]);
    /**
     * Creates a new CompositeFiltering instance with a specific column and filter values.
     * This overload is typically used for Any/All operations on collection properties.
     * @param compositeOperator - The composite operator to use for combining the conditions
     * @param column - The column or property this composite filter applies to
     * @param values - Array of string filter expressions or filtering instances to be combined
     */
    constructor(compositeOperator: CompositeOperator, column: TColumn, values: IFiltering<TData>[] | string[]);
    /**
     * Adds a filtering condition to the composite filter.
     * @param filtering - The filtering condition to add
     */
    addValue(filtering: IFiltering<TData>): void;
    /**
     * Converts the composite filtering instance to its string representation.
     * For collection operations (Any/All), formats as 'collection:operator(args)'.
     * For regular operations (And/Or), formats as 'operator(args)'.
     * @returns A string representation of the composite filtering operation
     */
    toString(): string;
    /**
     * Creates a new CompositeFiltering instance using the AND operator.
     * All specified conditions must be true for the filter to match.
     * @template TData - The type of data being filtered
     * @param values - Array of string filter expressions or filtering instances to combine with AND
     * @returns A new CompositeFiltering instance with AND operation
     */
    static and<TData extends object>(...values: IFiltering<TData>[] | string[]): CompositeFiltering<TData>;
    /**
     * Creates a new CompositeFiltering instance using the OR operator.
     * At least one of the specified conditions must be true for the filter to match.
     * @template TData - The type of data being filtered
     * @param values - Array of string filter expressions or filtering instances to combine with OR
     * @returns A new CompositeFiltering instance with OR operation
     */
    static or<TData extends object>(...values: IFiltering<TData>[] | string[]): CompositeFiltering<TData>;
    /**
     * Creates a new CompositeFiltering instance using the ANY operator for collections.
     * Returns true if any item in the collection matches the specified conditions.
     * @template TData - The type of data being filtered
     * @param values - Array of string filter expressions or filtering instances for collection items
     * @returns A new CompositeFiltering instance with ANY operation
     */
    static any<TData extends object>(...values: IFiltering<TData>[] | string[]): CompositeFiltering<TData>;
    /**
     * Creates a new CompositeFiltering instance using the ALL operator for collections.
     * Returns true if all items in the collection match the specified conditions.
     * @template TData - The type of data being filtered
     * @param values - Array of string filter expressions or filtering instances for collection items
     * @returns A new CompositeFiltering instance with ALL operation
     */
    static all<TData extends object>(...values: IFiltering<TData>[] | string[]): CompositeFiltering<TData>;
}
/**
 * Alias for CompositeFiltering class for more concise usage.
 * @example
 * ```typescript
 * // Using full class name
 * const filter1 = CompositeFiltering.and('name:eq(John)', 'age:gt(25)');
 *
 * // Using alias
 * const filter2 = CF.and('name:eq(John)', 'age:gt(25)');
 * ```
 */
export declare const CF: typeof CompositeFiltering;