import { QueryComposer } from '../core/query-composer';
import type { ModelDefinition, IncludeOptions, RelationConfig } from './types';
/**
 * Include configuration tracked by ModelQueryComposer
 */
interface TrackedInclude {
    relation: string;
    config: RelationConfig;
    query?: (qc: QueryComposer) => QueryComposer;
    nested?: TrackedInclude[];
}
/**
 * Extended QueryComposer with model-aware features
 *
 * Adds support for:
 * - Eager loading relations with `.include()`
 * - Nested includes
 * - Filtered includes
 */
export declare class ModelQueryComposer extends QueryComposer {
    private model;
    private includes;
    constructor(model: ModelDefinition);
    /**
     * Include a relation for eager loading
     *
     * @param relation - Relation name to include
     * @param queryCallback - Optional callback to filter/modify the relation query
     * @returns this for chaining
     *
     * @example
     * ```typescript
     * // Basic include
     * query.include('posts');
     *
     * // With filtering
     * query.include('posts', q => q.where({ status: 'active' }).limit(10));
     *
     * // Multiple includes
     * query.include('posts').include('country');
     * ```
     */
    include(relation: string, queryCallback?: (qc: QueryComposer) => QueryComposer): this;
    /**
     * Get all tracked includes (returns internal array — treat as readonly)
     */
    getIncludes(): readonly TrackedInclude[];
    /**
     * Get the model definition
     */
    getModel(): ModelDefinition;
    /**
     * Generate queries for all included relations
     *
     * Returns an array of query configurations that can be executed
     * to load related data.
     */
    getIncludeQueries(): Array<{
        relation: string;
        type: RelationConfig['type'];
        query: {
            text: string;
            values: unknown[];
        };
        foreignKey: string;
        primaryKey: string;
    }>;
    /**
     * Clone this query composer
     */
    clone(): ModelQueryComposer;
}
/**
 * Create a model-aware query composer
 *
 * @param model - Model definition with relations
 * @returns ModelQueryComposer instance
 *
 * @example
 * ```typescript
 * const League = defineModel({
 *   name: 'League',
 *   table: 'leagues',
 *   schema: LeagueSchema,
 *   relations: {
 *     posts: { type: 'hasMany', target: 'posts', ... }
 *   }
 * });
 *
 * const query = createModelQuery(League)
 *   .where({ status: 'active' })
 *   .include('posts')
 *   .orderBy('-name');
 * ```
 */
export declare function createModelQuery(model: ModelDefinition): ModelQueryComposer;
/**
 * Build include configuration from options
 *
 * @param options - Include options or relation name
 * @returns Normalized include options
 */
export declare function normalizeIncludeOptions(options: string | IncludeOptions): IncludeOptions;
export {};
//# sourceMappingURL=include.d.ts.map