import * as z from 'zod';
import { QueryComposer } from '../core/query-composer';
import type { QueryBuilderOptions } from '../core/types';
/**
 * Extract column names from a Zod object schema
 */
export type InferColumns<T extends z.ZodTypeAny> = T extends z.ZodObject<infer Shape> ? keyof Shape & string : never;
/**
 * Infer the TypeScript type from a Zod schema
 */
export type InferZodType<T extends z.ZodTypeAny> = z.infer<T>;
/**
 * Operator suffixes for typed where
 */
type OperatorSuffix = '' | '__exact' | '__notexact' | '__gt' | '__gte' | '__lt' | '__lte' | '__contains' | '__icontains' | '__startswith' | '__istartswith' | '__endswith' | '__iendswith' | '__in' | '__notin' | '__between' | '__isnull' | '__isnotnull';
/**
 * Generate typed where filter interface
 *
 * Allows both exact matches and operator-based filters
 */
export type TypedWhere<T extends z.ZodTypeAny> = T extends z.ZodObject<infer Shape> ? {
    [K in keyof Shape as K extends string ? K : never]?: z.infer<Shape[K]>;
} & {
    [K in keyof Shape as K extends string ? `${K}${OperatorSuffix}` : never]?: unknown;
} : Record<string, unknown>;
/**
 * Typed select fields
 */
export type TypedSelect<T extends z.ZodTypeAny> = InferColumns<T>[];
/**
 * Typed order by fields (with optional - prefix for DESC)
 */
export type TypedOrderBy<T extends z.ZodTypeAny> = T extends z.ZodObject<infer Shape> ? (keyof Shape extends string ? keyof Shape | `-${keyof Shape & string}` : string)[] : string[];
/**
 * Type-safe QueryComposer wrapper
 *
 * Provides compile-time type checking for:
 * - Column names in where(), select(), orderBy()
 * - Operator syntax validation
 * - Result type inference
 */
export declare class TypedQueryComposer<T extends z.ZodTypeAny> extends QueryComposer {
    private typeSchema;
    constructor(schema: T, table: string, options?: QueryBuilderOptions);
    /**
     * Type-safe where with typed filter object
     */
    where(filters: TypedWhere<T>): this;
    /**
     * Type-safe select with typed column array
     */
    select(fields: TypedSelect<T>): this;
    /**
     * Type-safe orderBy with typed field names
     */
    orderBy(...fields: string[]): this;
    /**
     * Type-safe or with typed filter groups
     */
    or(filterGroups: Array<TypedWhere<T>>): this;
    /**
     * Type-safe not with typed filter object
     */
    not(filters: TypedWhere<T>): this;
    /**
     * Type-safe conditional with typed callback
     */
    when(condition: boolean | (() => boolean) | unknown, callback: (qc: QueryComposer) => QueryComposer): this;
    /**
     * Type-safe unless with typed callback
     */
    unless(condition: boolean | (() => boolean) | unknown, callback: (qc: QueryComposer) => QueryComposer): this;
    /**
     * Clone with preserved types
     */
    clone(): TypedQueryComposer<T>;
    /**
     * Get the typed schema
     */
    getSchema(): T;
    /**
     * Get options for cloning
     */
    private getOptions;
}
/**
 * Create a type-safe query composer
 *
 * @param schema - Zod schema for the table
 * @param table - Table name
 * @param options - Query builder options
 * @returns TypedQueryComposer with full type safety
 *
 * @example
 * ```typescript
 * const UserSchema = z.object({
 *   id: z.string(),
 *   name: z.string(),
 *   age: z.number(),
 *   status: z.enum(['active', 'inactive']),
 * });
 *
 * const qc = createTypedComposer(UserSchema, 'users')
 *   .where({ status: 'active' })      // Type-safe!
 *   .where({ age__gte: 18 })          // Operators work too
 *   .select(['id', 'name'])           // Only valid columns
 *   .orderBy('-created_at');          // With optional - prefix
 * ```
 */
export declare function createTypedComposer<T extends z.ZodTypeAny>(schema: T, table: string, options?: QueryBuilderOptions): TypedQueryComposer<T>;
/**
 * Infer result type based on select fields
 *
 * If no select is specified, returns full type.
 * Otherwise returns pick of selected fields.
 *
 * `& keyof InferZodType<T>` is load-bearing: while `T` is still an unresolved
 * generic, zod v4 collapses `keyof output<T>` to `never`, so a bare
 * `Selected[number]` fails `Pick`'s constraint (TS2344) at the declaration site
 * — breaking the library's own build on v4 and every consumer compiling the
 * shipped `.d.ts` with `skipLibCheck: false`.
 */
export type InferResult<T extends z.ZodTypeAny, Selected extends InferColumns<T>[] | undefined = undefined> = Selected extends InferColumns<T>[] ? Pick<InferZodType<T>, Selected[number] & keyof InferZodType<T>> : InferZodType<T>;
/**
 * Type helper for building typed filters
 */
export declare function typedFilter<T extends z.ZodTypeAny>(_schema: T, filter: TypedWhere<T>): TypedWhere<T>;
export {};
//# sourceMappingURL=infer.d.ts.map