import HasAttributes from './HasAttributes';
import type { MaybeArray, StaticToThis as BaseStaticToThis } from '../../Support/type';
type StaticToThis = BaseStaticToThis & {
    newQuery: typeof BuildsQuery['newQuery'];
};
type BooleanOperator = 'and' | 'or';
type Direction = 'asc' | 'desc';
type Operator = '!=' | '<' | '<=' | '=' | '>' | '>=' | 'between' | 'in' | 'like' | 'notBetween' | 'notIn';
type Order = {
    column: string;
    direction: Direction;
};
type WhereDescription = {
    column: string;
    operator: Operator;
    value: any;
    boolean: BooleanOperator;
};
export type QueryParams = Partial<{
    wheres: WhereDescription[];
    columns: string[];
    with: string[];
    scopes: string[];
    relationsExists: string[];
    orders: Order[];
    distinct: string[];
    offset: number;
    limit: number;
    page: number;
}>;
export default class BuildsQuery extends HasAttributes {
    protected queryParameters: Required<QueryParams> & {
        without: string[];
    };
    /**
     * The relations that should be included on every request.
     *
     * @protected
     *
     * @type {string}
     */
    protected withRelations: string[];
    /**
     * Return the instantiated class.
     *
     * @return {BuildsQuery}
     */
    static newQuery<T extends StaticToThis>(this: T): T['prototype'];
    /**
     * Compiles the query parameters into a single object.
     *
     * @protected
     *
     * @return {object}
     */
    protected compileQueryParameters(): QueryParams;
    /**
     * Reset the request parameters.
     *
     * @protected
     *
     * @return {this}
     */
    resetQueryParameters(): this;
    /**
     * Add a where constraint to the wheres.
     *
     * @param {string} column
     * @param {string} operator
     * @param {any} value
     * @param {'and'|'or'} boolean
     *
     * @protected
     *
     * @return {this}
     */
    protected addWhereConstraint(column: string, operator: Operator, value: any, boolean: BooleanOperator): this;
    /**
     * Add a where constraint to the query.
     *
     * @param {string} column
     * @param {any} operator
     * @param {any=} value
     * @param {'and'|'or'} boolean
     *
     * @return {this}
     */
    where(column: string, value?: unknown): this;
    where(column: string, operator: Operator, value: unknown, boolean?: BooleanOperator): this;
    /**
     * The static version of the where method.
     *
     * @param {string} column
     * @param {any} operator
     * @param {any=} value
     * @param {'and'|'or'} boolean
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.where
     */
    static where<T extends StaticToThis>(this: T, column: string, value: unknown): T['prototype'];
    static where<T extends StaticToThis>(this: T, column: string, operator: Operator, value: unknown, boolean?: BooleanOperator): T['prototype'];
    /**
     * Add an or where closure to the query.
     *
     * @param {string} column
     * @param {any} operator
     * @param {any} value
     *
     * @return {this}
     */
    orWhere(column: string, value: any): this;
    orWhere(column: string, operator: Operator, value: any): this;
    /**
     * Add a where key closure to the query.
     *
     * @param {string|number|(string|number)[]} value
     * @param {'and'|'or'} boolean
     *
     * @return {this}
     */
    whereKey(value: MaybeArray<number | string>, boolean?: BooleanOperator): this;
    /**
     * The static version of the whereKey method.
     *
     * @param {string|number|(string|number)[]} value
     * @param {'and'|'or'} boolean
     *
     * @see BuildsQuery.prototype.whereKey
     */
    static whereKey<T extends StaticToThis>(this: T, value: MaybeArray<number | string>, boolean?: BooleanOperator): T['prototype'];
    /**
     * Add an or where key closure to the query.
     *
     * @param {string|number|(string|number)[]} value
     *
     * @return {this}
     */
    orWhereKey(value: MaybeArray<number | string>): this;
    /**
     * Add a where key not closure to the query.
     *
     * @param {string|number|(string|number)[]} value
     * @param {'and'|'or'} boolean
     *
     * @return {this}
     */
    whereKeyNot(value: MaybeArray<number | string>, boolean?: BooleanOperator): this;
    /**
     * The static version of the whereKeyNot method.
     *
     * @param {string|number|(string|number)[]} value
     * @param {'and'|'or'} boolean
     *
     * @see BuildsQuery.prototype.whereNotIn
     */
    static whereKeyNot<T extends StaticToThis>(this: T, value: MaybeArray<number | string>, boolean?: BooleanOperator): T['prototype'];
    /**
     * Add a where key not closure to the query.
     *
     * @param {string|number|(string|number)[]} value
     *
     * @return {this}
     */
    orWhereKeyNot(value: MaybeArray<number | string>): this;
    /**
     * Add a where null closure to the query.
     *
     * @param {string|string[]} columns
     * @param {'and'|'or'} boolean
     *
     * @return {this}
     */
    whereNull(columns: MaybeArray<string>, boolean?: BooleanOperator): this;
    /**
     * The static version of the whereNull method.
     *
     * @param {string} columns
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.whereNull
     */
    static whereNull<T extends StaticToThis>(this: T, columns: MaybeArray<string>): T['prototype'];
    /**
     * Add an or where null closure to the query.
     *
     * @param {string} columns
     *
     * @return {this}
     */
    orWhereNull(columns: MaybeArray<string>): this;
    /**
     * Add a where not null closure to the query.
     *
     * @param {string} columns
     * @param {'and'|'or'} boolean
     *
     * @return {this}
     */
    whereNotNull(columns: MaybeArray<string>, boolean?: BooleanOperator): this;
    /**
     * The static version of the whereNotNull method.
     *
     * @param {string} columns
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.whereNotNull
     */
    static whereNotNull<T extends StaticToThis>(this: T, columns: MaybeArray<string>): T['prototype'];
    /**
     * Add an or where not null closure to the query.
     *
     * @param {string} columns
     *
     * @return {this}
     */
    orWhereNotNull(columns: MaybeArray<string>): this;
    /**
     * Add a where in closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @return {this}
     */
    whereIn(column: string, values: any[], boolean?: BooleanOperator): this;
    /**
     * The static version of the whereIn method.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @see BuildsQuery.prototype.whereIn
     */
    static whereIn<T extends StaticToThis>(this: T, column: string, values: any[], boolean?: BooleanOperator): T['prototype'];
    /**
     * Add an or where in closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     *
     * @return {this}
     */
    orWhereIn(column: string, values: any[]): this;
    /**
     * Add a where not in closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @return {this}
     */
    whereNotIn(column: string, values: any[], boolean?: BooleanOperator): this;
    /**
     * The static version of the whereNotIn method.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @see BuildsQuery.prototype.whereNotIn
     */
    static whereNotIn<T extends StaticToThis>(this: T, column: string, values: any[], boolean?: BooleanOperator): T['prototype'];
    /**
     * Add an or where not in closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     *
     * @return {this}
     */
    orWhereNotIn(column: string, values: any[]): this;
    /**
     * Add a where between closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @return {this}
     */
    whereBetween(column: string, values: any[], boolean?: BooleanOperator): this;
    /**
     * The static version of the whereBetween method.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @see BuildsQuery.prototype.whereBetween
     */
    static whereBetween<T extends StaticToThis>(this: T, column: string, values: any[], boolean?: BooleanOperator): T['prototype'];
    /**
     * Add an or where between closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     *
     * @return {this}
     */
    orWhereBetween(column: string, values: any[]): this;
    /**
     * Add a where not between closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @return {this}
     */
    whereNotBetween(column: string, values: any[], boolean?: BooleanOperator): this;
    /**
     * The static version of the whereNotBetween method.
     *
     * @param {string} column
     * @param {any[]} values
     * @param {'and'|'or} boolean
     *
     * @see BuildsQuery.prototype.whereNotBetween
     */
    static whereNotBetween<T extends StaticToThis>(this: T, column: string, values: any[], boolean?: BooleanOperator): T['prototype'];
    /**
     * Add an or where not between closure to the query.
     *
     * @param {string} column
     * @param {any[]} values
     *
     * @return {this}
     */
    orWhereNotBetween(column: string, values: any[]): this;
    /**
     * Set the limit for the returned models on the next request.
     *
     * @param {number} count
     */
    limit(count: number): this;
    /**
     * The static version of the limit method.
     *
     * @param {number} count
     *
     * @see BuildsQuery.prototype.limit
     */
    static limit<T extends StaticToThis>(this: T, count: number): T['prototype'];
    /**
     * Set the page of the returned models for the next request.
     *
     * @param {number} pageNumber
     */
    page(pageNumber: number): this;
    /**
     * The static version of the page method.
     *
     * @param {number} pageNumber
     *
     * @see BuildsQuery.prototype.page
     */
    static page<T extends StaticToThis>(this: T, pageNumber: number): T['prototype'];
    /**
     * Request only distinct values on the query based on the given columns.
     *
     * @return {this}
     */
    distinct(columns: MaybeArray<string>): this;
    /**
     * The static version of the distinct method.
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.distinct
     */
    static distinct<T extends StaticToThis>(this: T, columns: MaybeArray<string>): T['prototype'];
    /**
     * Tell the api which columns are required.
     *
     * @param {string[]} columns
     *
     * @return {this}
     */
    select(columns: MaybeArray<string>): this;
    /**
     * The static version of the select method.
     *
     * @param {string[]} columns
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.select
     */
    static select<T extends StaticToThis>(this: T, columns: MaybeArray<string>): T['prototype'];
    /**
     * Add a has check of the related records
     *
     * @param {string[]} relations
     *
     * @return {this}
     */
    has(relations: MaybeArray<string>): this;
    /**
     * The static version of the has method.
     *
     * @param {string[]} relations
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.has
     */
    static has<T extends StaticToThis>(this: T, relations: MaybeArray<string>): T['prototype'];
    /**
     * Add eager loaded relations to the query.
     *
     * @param {string[]} relations
     *
     * @return {this}
     */
    with(relations: MaybeArray<string>): this;
    /**
     * The static version of the with method.
     *
     * @param {string[]} relations
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.with
     */
    static with<T extends StaticToThis>(this: T, relations: MaybeArray<string>): T['prototype'];
    /**
     * Remove eager loaded relations from the query.
     *
     * @param relations
     */
    without(relations: MaybeArray<string>): this;
    /**
     * The static version of the with method.
     *
     * @param {string[]} relations
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.without
     */
    static without<T extends StaticToThis>(this: T, relations: MaybeArray<string>): T['prototype'];
    /**
     * Add eager loaded relations to the query.
     *
     * @param {string[]} scopes
     *
     * @return {this}
     */
    scope(scopes: MaybeArray<string>): this;
    /**
     * The static version of the scope method.
     *
     * @param {string[]} scopes
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.scope
     */
    static scope<T extends StaticToThis>(this: T, scopes: MaybeArray<string>): T['prototype'];
    /**
     * Add an ordering of the records for the query.
     *
     * @param {string} column
     * @param {'asc'|'desc'} direction
     *
     * @return {this}
     */
    orderBy(column: string, direction?: Direction): this;
    /**
     * The static version of the orderBy method.
     *
     * @param {string} column
     * @param {'asc'|'desc'}direction
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.orderBy
     */
    static orderBy<T extends StaticToThis>(this: T, column: string, direction?: Direction): T['prototype'];
    /**
     * Add an ordering by descending of the records for the query.
     *
     * @param {string} column
     *
     * @return {this}
     */
    orderByDesc(column: string): this;
    /**
     * The static version of the orderByDesc method.
     *
     * @param {string} column
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.orderByDesc
     */
    static orderByDesc<T extends StaticToThis>(this: T, column: string): T['prototype'];
    /**
     * An alias for the orderByDesc method.
     *
     * @param {string=} column
     *
     * @return {this}
     */
    latest(column?: string): this;
    /**
     * The static version of the latest method.
     *
     * @param {string=} column
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.latest
     */
    static latest<T extends StaticToThis>(this: T, column?: string): T['prototype'];
    /**
     * Add an ordering by ascending of the records for the query.
     *
     * @param {string} column
     *
     * @return {this}
     */
    oldest(column?: string): this;
    /**
     * The static version of the oldest method.
     *
     * @param {string} column
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.oldest
     */
    static oldest<T extends StaticToThis>(this: T, column?: string): T['prototype'];
    /**
     * The offset of the records sent back.
     *
     * @param {number} count
     *
     * @return {this}
     */
    offset(count: number): this;
    /**
     * The static version of the offset method.
     *
     * @param {number} count
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.offset
     */
    static offset<T extends StaticToThis>(this: T, count: number): T['prototype'];
    /**
     * An alias for the offset method.
     *
     * @param {number} count
     *
     * @return {this}
     *
     * @see BuildsQuery.prototype.offset
     */
    skip(count: number): this;
    /**
     * The static version of the skip method.
     *
     * @param {number} count
     *
     * @return {BuildsQuery}
     *
     * @see BuildsQuery.prototype.skip
     */
    static skip<T extends StaticToThis>(this: T, count: number): T['prototype'];
}
export {};
//# sourceMappingURL=BuildsQuery.d.ts.map