import { DBEntity, PreparedFilterGroup, PreparedSubQueryFilter, PreparedWhere, PreparedWhereFilter, QueryFilterGroup } from './types.js';
import { EntityStoreQueryEngine } from './query-engine.js';
import { FilterGroup, FilterStatement, QueryWhere, RelationshipExistsExtension, RelationshipExistsFilter, SubQueryFilter, WhereFilter } from './types.js';
import { CollectionNameFromModels, ModelRelationshipPaths, Models } from './schema/index.js';
export declare function satisfiesFilters(entity: DBEntity, filters: PreparedWhere, queryEngine: EntityStoreQueryEngine): Promise<boolean>;
export declare function satisfiesFilter(entity: DBEntity, filter: PreparedWhereFilter, queryEngine: EntityStoreQueryEngine): Promise<boolean>;
export declare function satisfiesNonRelationalFilter(entity: DBEntity, filter: PreparedWhereFilter, ignoreSubQueries?: boolean): boolean;
export declare function isFilterStatement(filter: WhereFilter | PreparedWhereFilter): filter is FilterStatement;
export declare function isIdFilter(filter: WhereFilter): filter is ['id', any, any];
export declare function isIdFilterEqualityStatement(filter: WhereFilter): filter is ['id', '=' | 'in', any];
export declare function isFilterGroup(filter: PreparedWhereFilter): filter is PreparedFilterGroup;
export declare function isFilterGroup(filter: WhereFilter): filter is QueryFilterGroup;
export declare function isSubQueryFilter(filter: PreparedWhereFilter): filter is PreparedSubQueryFilter;
export declare function isSubQueryFilter(filter: WhereFilter): filter is SubQueryFilter;
export declare function isRelationshipExistsFilter(filter: WhereFilter): filter is RelationshipExistsFilter;
export declare function isBooleanFilter(filter: WhereFilter | PreparedWhereFilter): filter is boolean;
export declare function isWhereFilter(filter: any): filter is WhereFilter;
/**
 * Returns true if the filter can be used in an index sorted by the property. It should be a filter statement with a some range scan operator.
 */
export declare function isIndexableFilter(filter: PreparedWhereFilter): filter is FilterStatement;
/**
 * Based on the type of filter, determine its priority in execution
 * 1. Boolean filters
 * 2. Basic filters
 * 3. Group filters (which are then ordered by their own priority)
 * 4. Relational filters (subqueries, will take the longest to execute)
 */
export declare function getFilterPriorityOrder(where: PreparedWhere | undefined): number[];
export declare function or<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, W extends QueryWhere<M, CN> | PreparedWhere = QueryWhere<M, CN> | PreparedWhere>(where: W): {
    mod: "or";
    filters: W;
};
export declare function and<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, W extends QueryWhere<M, CN> | PreparedWhere = QueryWhere<M, CN> | PreparedWhere>(where: W): {
    mod: "and";
    filters: W;
};
export declare function exists<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, P extends ModelRelationshipPaths<M, CN> = ModelRelationshipPaths<M, CN>>(relationship: P): {
    exists: {
        _extends: P;
    };
};
export declare function exists<M extends Models<M> = Models, CN extends CollectionNameFromModels<M> = CollectionNameFromModels<M>, P extends ModelRelationshipPaths<M, CN> = ModelRelationshipPaths<M, CN>, Ext extends RelationshipExistsExtension<M, CN, P> = RelationshipExistsExtension<M, CN, P>>(relationship: P, ext?: Ext): {
    exists: {
        _extends: P;
    };
} & Ext;
/**
 * This will iterate over all statements (even recursively in groups) and return
 * true if any of the statements satisfy the provided function.
 * @param statements
 * @param someFunction
 * @returns
 */
export declare function someFilterStatementsFlat(statements: PreparedWhere, someFunction: (statement: Exclude<PreparedWhereFilter, PreparedFilterGroup>) => boolean): boolean;
export declare function someFilterStatementsFlat(statements: QueryWhere, someFunction: (statement: Exclude<WhereFilter, FilterGroup>) => boolean): boolean;
/**
 * This will iterate over all statements including recursively within groups  of AND and OR
 * but not within subqueries
 * @param statements
 */
export declare function filterStatementIteratorFlat(statements: PreparedWhere): Generator<Exclude<PreparedWhereFilter, PreparedFilterGroup>>;
export declare function filterStatementIteratorFlat(statements: QueryWhere): Generator<Exclude<WhereFilter, FilterGroup>>;
export type StaticFilter = boolean | FilterStatement | FilterGroup<Models, CollectionNameFromModels<Models>, StaticFilter[]>;
/**
 * Returns true if the filter has no relational components
 */
export declare function isStaticFilter(filter: PreparedWhereFilter): filter is StaticFilter;
export declare function isStaticFilter(filter: WhereFilter): filter is StaticFilter;