import { WhereConditionBase, SqlBuildContext, FieldRef, SqlFragment } from './conditions';
/**
 * Represents a subquery that can be used in various contexts
 * TResult: The type of data the subquery returns
 * TMode: 'scalar' | 'array' | 'table' - determines how the subquery can be used
 */
export declare class Subquery<TResult = any, TMode extends 'scalar' | 'array' | 'table' = 'table'> {
    /**
     * The SQL generator function - called with context to build SQL
     */
    private sqlBuilder;
    /**
     * Optional alias for the subquery when used as a table source
     */
    private alias?;
    /**
     * Selection metadata - preserves SqlFragments with mappers for table subqueries
     */
    private selectionMetadata?;
    /**
     * Field refs from outer queries used inside this subquery's WHERE condition.
     * These need to be propagated to the outer query so it can add necessary JOINs.
     */
    private outerFieldRefs;
    /**
     * Phantom type marker for type checking
     */
    private __resultType?;
    private __mode?;
    constructor(sqlBuilder: (context: SqlBuildContext & {
        tableAlias?: string;
    }) => string, mode?: TMode, selectionMetadata?: Record<string, any>, outerFieldRefs?: FieldRef[]);
    /**
     * Set an alias for this subquery (used when subquery is a table source)
     */
    as(alias: string): Subquery<TResult, TMode>;
    /**
     * Build the SQL for this subquery
     */
    buildSql(context: SqlBuildContext & {
        tableAlias?: string;
    }): string;
    /**
     * Get the alias for this subquery
     */
    getAlias(): string | undefined;
    /**
     * Get the selection metadata (preserves SqlFragments with mappers)
     */
    getSelectionMetadata(): Record<string, any> | undefined;
    /**
     * Get field refs from outer queries used inside this subquery.
     * These need to be propagated to the outer query for JOIN detection.
     */
    getOuterFieldRefs(): FieldRef[];
    /**
     * Check if this is a scalar subquery
     */
    isScalar(): this is Subquery<TResult, 'scalar'>;
    /**
     * Check if this is an array subquery
     */
    isArray(): this is Subquery<TResult, 'array'>;
    /**
     * Check if this is a table subquery
     */
    isTable(): this is Subquery<TResult, 'table'>;
}
/**
 * Subquery reference - used to reference columns from a subquery in a FROM clause
 * This is similar to FieldRef but for subquery columns
 */
export interface SubqueryFieldRef<TName extends string = string, TValueType = any> extends FieldRef<TName, TValueType> {
    readonly __isSubqueryField: true;
}
/**
 * Helper to check if something is a Subquery
 */
export declare function isSubquery(value: any): value is Subquery;
/**
 * Duck-typed interface for collection-like objects (e.g., CollectionQueryBuilder)
 * that can be used wherever a Subquery is expected.
 * This enables generic function syntax: exists(collection.where(...)), notExists(collection.where(...))
 */
export interface CollectionSubquerySource {
    exists(): SqlFragment<boolean>;
}
/**
 * Base class for EXISTS / NOT EXISTS conditions.
 * Accepts either a Subquery or a collection navigation source (CollectionSubquerySource).
 */
declare abstract class ExistsConditionBase extends SqlFragment<boolean> {
    protected resolved: Subquery | SqlFragment<boolean>;
    constructor(source: Subquery | CollectionSubquerySource);
    getFieldRefs(): FieldRef[];
    protected buildSubquerySql(context: SqlBuildContext): string;
}
/**
 * Condition: EXISTS (subquery)
 * Extends SqlFragment<boolean> so it works in both WHERE clauses and SELECT projections.
 * In SELECT: produces `EXISTS (SELECT ...) as "alias"` with boolean type inference.
 * In WHERE: works as WhereConditionBase since SqlFragment extends it.
 */
export declare class ExistsCondition extends ExistsConditionBase {
    buildSql(context: SqlBuildContext): string;
}
/**
 * Condition: NOT EXISTS (subquery)
 * Extends SqlFragment<boolean> so it works in both WHERE clauses and SELECT projections.
 */
export declare class NotExistsCondition extends ExistsConditionBase {
    buildSql(context: SqlBuildContext): string;
}
/**
 * Condition: field IN (subquery)
 * The subquery must return a single column
 */
export declare class InSubqueryCondition<T> extends WhereConditionBase {
    private field;
    private subquery;
    constructor(field: FieldRef<any, T>, subquery: Subquery<T[], 'array'>);
    getFieldRefs(): FieldRef[];
    buildSql(context: SqlBuildContext): string;
}
/**
 * Condition: field NOT IN (subquery)
 */
export declare class NotInSubqueryCondition<T> extends WhereConditionBase {
    private field;
    private subquery;
    constructor(field: FieldRef<any, T>, subquery: Subquery<T[], 'array'>);
    getFieldRefs(): FieldRef[];
    buildSql(context: SqlBuildContext): string;
}
/**
 * Comparison with scalar subquery
 * Example: field = (SELECT ...)
 */
export declare class ScalarSubqueryComparison<T> extends WhereConditionBase {
    private field;
    private operator;
    private subquery;
    constructor(field: FieldRef<any, T>, operator: '=' | '!=' | '>' | '>=' | '<' | '<=', subquery: Subquery<T, 'scalar'>);
    getFieldRefs(): FieldRef[];
    buildSql(context: SqlBuildContext): string;
}
/**
 * Helper functions to create subquery conditions
 */
/**
 * EXISTS condition
 */
export declare function exists(source: Subquery | CollectionSubquerySource): ExistsCondition;
/**
 * NOT EXISTS condition
 */
export declare function notExists(source: Subquery | CollectionSubquerySource): NotExistsCondition;
/**
 * Extract the non-undefined type from a potentially undefined type
 */
type NonUndefined<T> = T extends undefined ? never : T;
/**
 * IN subquery condition
 *
 * Supports both required and optional fields:
 * - Required field: `inSubquery(p.userId, subquery)` where userId is number
 * - Optional field: `inSubquery(u.age!, agesSubquery)` where age is number | undefined
 *
 * For optional fields, use non-null assertion (!) or check for undefined before calling.
 */
export declare function inSubquery<T>(field: FieldRef<any, NonUndefined<T>>, subquery: Subquery<NonUndefined<T>[], 'array'>): InSubqueryCondition<NonUndefined<T>>;
/**
 * NOT IN subquery condition
 *
 * Supports both required and optional fields:
 * - Required field: `notInSubquery(p.userId, subquery)` where userId is number
 * - Optional field: `notInSubquery(u.age!, agesSubquery)` where age is number | undefined
 *
 * For optional fields, use non-null assertion (!) or check for undefined before calling.
 */
export declare function notInSubquery<T>(field: FieldRef<any, NonUndefined<T>>, subquery: Subquery<NonUndefined<T>[], 'array'>): NotInSubqueryCondition<NonUndefined<T>>;
/**
 * Scalar subquery comparison helpers
 */
export declare function eqSubquery<T>(field: FieldRef<any, T>, subquery: Subquery<T, 'scalar'>): ScalarSubqueryComparison<T>;
export declare function neSubquery<T>(field: FieldRef<any, T>, subquery: Subquery<T, 'scalar'>): ScalarSubqueryComparison<T>;
export declare function gtSubquery<T>(field: FieldRef<any, T>, subquery: Subquery<T, 'scalar'>): ScalarSubqueryComparison<T>;
export declare function gteSubquery<T>(field: FieldRef<any, T>, subquery: Subquery<T, 'scalar'>): ScalarSubqueryComparison<T>;
export declare function ltSubquery<T>(field: FieldRef<any, T>, subquery: Subquery<T, 'scalar'>): ScalarSubqueryComparison<T>;
export declare function lteSubquery<T>(field: FieldRef<any, T>, subquery: Subquery<T, 'scalar'>): ScalarSubqueryComparison<T>;
/**
 * Type helper: Extract result type from a subquery
 */
export type SubqueryResult<T> = T extends Subquery<infer R, any> ? R : never;
/**
 * Type helper: Extract mode from a subquery
 */
export type SubqueryMode<T> = T extends Subquery<any, infer M> ? M : never;
export {};
//# sourceMappingURL=subquery.d.ts.map