@zudojs/database 0.1.0 → 1.0.0

package/dist/pagination/pagination.core.d.ts

@@ -0,0 +1,163 @@
+import type { PaginationInput, PaginationMeta, PaginatedResult } from "../databaseType/databaseType.type.js";
+/**
+ * Default pagination values.
+ */
+export declare const DEFAULT_PAGE = 1;
+export declare const DEFAULT_LIMIT = 20;
+export declare const MAX_LIMIT = 100;
+/**
+ * Normalized pagination configuration.
+ */
+export interface NormalizedPagination {
+    readonly page: number;
+    readonly limit: number;
+    readonly offset: number;
+}
+/**
+ * Cursor pagination request.
+ */
+export interface CursorPaginationInput {
+    readonly cursor?: string | null;
+    readonly limit?: number;
+}
+/**
+ * Cursor pagination metadata.
+ */
+export interface CursorPaginationMeta {
+    readonly limit: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly nextCursor?: string;
+    readonly previousCursor?: string;
+}
+/**
+ * Cursor paginated result.
+ */
+export interface CursorPaginatedResult<TEntity> {
+    readonly data: readonly TEntity[];
+    readonly meta: CursorPaginationMeta;
+}
+/**
+ * Normalizes page and limit values.
+ */
+export declare function normalizePagination(input?: PaginationInput): NormalizedPagination;
+/**
+ * Normalizes a page number.
+ */
+export declare function normalizePage(page?: number): number;
+/**
+ * Normalizes a page size.
+ */
+export declare function normalizeLimit(limit?: number): number;
+/**
+ * Calculates the database offset for a page.
+ */
+export declare function calculateOffset(page: number, limit: number): number;
+/**
+ * Calculates the total number of pages.
+ */
+export declare function calculateTotalPages(total: number, limit: number): number;
+/**
+ * Creates pagination metadata.
+ */
+export declare function createPaginationMeta(page: number, limit: number, total: number): PaginationMeta;
+/**
+ * Creates a paginated result.
+ */
+export declare function createPaginatedResult<TEntity>(data: readonly TEntity[], page: number, limit: number, total: number): PaginatedResult<TEntity>;
+/**
+ * Gets the next page number.
+ */
+export declare function getNextPage(meta: PaginationMeta): number | null;
+/**
+ * Gets the previous page number.
+ */
+export declare function getPreviousPage(meta: PaginationMeta): number | null;
+/**
+ * Checks whether a page number is valid for the result set.
+ */
+export declare function isValidPage(page: number, totalPages: number): boolean;
+/**
+ * Calculates the item range represented by a page.
+ *
+ * For example, page 2 with a limit of 20 and total of 55 returns
+ * `{ start: 21, end: 40 }`.
+ */
+export declare function getItemRange(page: number, limit: number, total: number): {
+    readonly start: number;
+    readonly end: number;
+};
+/**
+ * Applies offset pagination to an in-memory collection.
+ *
+ * This is useful for adapters and tests that need the same pagination
+ * semantics without querying the database directly.
+ */
+export declare function paginateCollection<TEntity>(items: readonly TEntity[], input?: PaginationInput): PaginatedResult<TEntity>;
+/**
+ * Normalizes cursor pagination input.
+ */
+export declare function normalizeCursorPagination(input?: CursorPaginationInput): Required<Pick<CursorPaginationInput, "limit">> & Pick<CursorPaginationInput, "cursor">;
+/**
+ * Creates cursor pagination metadata.
+ */
+export declare function createCursorPaginationMeta(limit: number, options: {
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage?: boolean;
+    readonly nextCursor?: string | null;
+    readonly previousCursor?: string | null;
+}): CursorPaginationMeta;
+/**
+ * Creates a cursor paginated result.
+ */
+export declare function createCursorPaginatedResult<TEntity>(data: readonly TEntity[], limit: number, options: {
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage?: boolean;
+    readonly nextCursor?: string | null;
+    readonly previousCursor?: string | null;
+}): CursorPaginatedResult<TEntity>;
+/**
+ * Options for encoding a cursor.
+ */
+export interface EncodeCursorOptions {
+    /**
+     * When supplied the cursor is signed with HMAC-SHA256 so clients cannot
+     * forge or tamper with its payload.
+     */
+    readonly secret?: string;
+}
+/**
+ * Options for decoding a cursor.
+ */
+export interface DecodeCursorOptions extends EncodeCursorOptions {
+    /**
+     * Keys the decoded payload may contain. Any other key is rejected.
+     */
+    readonly allowedFields?: readonly string[];
+}
+/**
+ * A validated cursor payload: a flat object of primitive values.
+ */
+export type CursorPayload = Readonly<Record<string, string | number | boolean | null>>;
+/**
+ * Encodes a cursor value.
+ *
+ * Without a `secret` the cursor is plain base64url JSON and must be treated
+ * as client-controlled input; pass `allowedFields` to `decodeCursor` (or
+ * use a secret) before feeding it to a query.
+ */
+export declare function encodeCursor(value: unknown, options?: EncodeCursorOptions): string;
+/**
+ * Decodes a cursor value.
+ *
+ * When `secret` is supplied the signature is verified; when
+ * `allowedFields` is supplied the payload must be a flat object whose keys
+ * are all allowed and whose values are primitives.
+ */
+export declare function decodeCursor<T = unknown>(cursor: string, options?: DecodeCursorOptions): T;
+/**
+ * Validates that a decoded cursor is a flat object of primitive values
+ * restricted to the allowed fields.
+ */
+export declare function validateCursorPayload(value: unknown, allowedFields: readonly string[]): asserts value is CursorPayload;
+//# sourceMappingURL=pagination.core.d.ts.map

package/dist/pagination/pagination.core.js

@@ -1,3 +1,4 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
 /**
  * Default pagination values.
  */
@@ -59,13 +60,17 @@ export function createPaginationMeta(page, limit, total) {
     const normalizedLimit = normalizeLimit(limit);
     const normalizedTotal = Math.max(0, Math.floor(total));
     const totalPages = calculateTotalPages(normalizedTotal, normalizedLimit);
+    const hasNextPage = totalPages > 0 && normalizedPage < totalPages;
+    const hasPreviousPage = normalizedPage > 1 && totalPages > 0;
     return {
         page: normalizedPage,
         limit: normalizedLimit,
         total: normalizedTotal,
         totalPages,
-        hasNextPage: totalPages > 0 && normalizedPage < totalPages,
-        hasPreviousPage: normalizedPage > 1 && totalPages > 0,
+        hasNextPage,
+        hasPreviousPage,
+        hasNext: hasNextPage,
+        hasPrev: hasPreviousPage,
     };
 }
 /**
@@ -128,9 +133,10 @@ export function getItemRange(page, limit, total) {
     const start = calculateOffset(normalizedPage, normalizedLimit) + 1;
     const end = Math.min(start + normalizedLimit - 1, normalizedTotal);
     if (start > normalizedTotal) {
+        // The page lies past the end of the data set: there is no item range.
         return {
-            start: normalizedTotal,
-            end: normalizedTotal,
+            start: 0,
+            end: 0,
         };
     }
     return {
@@ -180,31 +186,94 @@ export function createCursorPaginatedResult(data, limit, options) {
         meta: createCursorPaginationMeta(limit, options),
     };
 }
+const CURSOR_SIGNATURE_SEPARATOR = ".";
+const FORBIDDEN_CURSOR_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 /**
  * Encodes a cursor value.
+ *
+ * Without a `secret` the cursor is plain base64url JSON and must be treated
+ * as client-controlled input; pass `allowedFields` to `decodeCursor` (or
+ * use a secret) before feeding it to a query.
  */
-export function encodeCursor(value) {
+export function encodeCursor(value, options = {}) {
     const serialized = JSON.stringify(value);
     if (typeof serialized !== "string") {
         throw new TypeError("Cursor value could not be serialized.");
     }
-    return Buffer.from(serialized, "utf8").toString("base64url");
+    const payload = Buffer.from(serialized, "utf8").toString("base64url");
+    if (options.secret === undefined) {
+        return payload;
+    }
+    validateSecret(options.secret);
+    return `${payload}${CURSOR_SIGNATURE_SEPARATOR}${signCursor(payload, options.secret)}`;
 }
 /**
  * Decodes a cursor value.
+ *
+ * When `secret` is supplied the signature is verified; when
+ * `allowedFields` is supplied the payload must be a flat object whose keys
+ * are all allowed and whose values are primitives.
  */
-export function decodeCursor(cursor) {
+export function decodeCursor(cursor, options = {}) {
     if (typeof cursor !== "string" || cursor.trim().length === 0) {
         throw new TypeError("A cursor value is required.");
     }
+    let payload = cursor;
+    if (options.secret !== undefined) {
+        validateSecret(options.secret);
+        const separator = cursor.lastIndexOf(CURSOR_SIGNATURE_SEPARATOR);
+        if (separator <= 0) {
+            throw new TypeError("Invalid pagination cursor signature.");
+        }
+        payload = cursor.slice(0, separator);
+        const signature = cursor.slice(separator + 1);
+        const expected = signCursor(payload, options.secret);
+        if (signature.length !== expected.length ||
+            !timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
+            throw new TypeError("Invalid pagination cursor signature.");
+        }
+    }
+    let decoded;
     try {
-        const decoded = Buffer.from(cursor, "base64url").toString("utf8");
-        return JSON.parse(decoded);
+        decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
     }
     catch (error) {
         throw new TypeError("Invalid pagination cursor.", {
             cause: error,
         });
     }
+    if (options.allowedFields !== undefined) {
+        validateCursorPayload(decoded, options.allowedFields);
+    }
+    return decoded;
+}
+/**
+ * Validates that a decoded cursor is a flat object of primitive values
+ * restricted to the allowed fields.
+ */
+export function validateCursorPayload(value, allowedFields) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("Pagination cursor payload must be an object.");
+    }
+    const allowed = new Set(allowedFields);
+    for (const [key, entry] of Object.entries(value)) {
+        if (FORBIDDEN_CURSOR_KEYS.has(key) || !allowed.has(key)) {
+            throw new TypeError(`Pagination cursor contains an unexpected field "${key}".`);
+        }
+        if (entry !== null &&
+            typeof entry !== "string" &&
+            typeof entry !== "number" &&
+            typeof entry !== "boolean") {
+            throw new TypeError(`Pagination cursor field "${key}" must be a primitive value.`);
+        }
+    }
+}
+function signCursor(payload, secret) {
+    return createHmac("sha256", secret).update(payload).digest("base64url");
+}
+function validateSecret(secret) {
+    if (typeof secret !== "string" || secret.length === 0) {
+        throw new TypeError("A cursor secret must be a non-empty string.");
+    }
 }
 //# sourceMappingURL=pagination.core.js.map

package/dist/pagination/pagination.keyset.d.ts

@@ -0,0 +1,55 @@
+import type { SortInput } from "../databaseType/databaseType.type.js";
+import { type CursorPaginatedResult, type CursorPayload } from "./pagination.core.js";
+/**
+ * Options for building a keyset page.
+ */
+export interface KeysetPageOptions<TField extends string = string> {
+    /**
+     * The sort definition the rows were fetched with. The cursor is derived
+     * from these fields, in order.
+     */
+    readonly sort: readonly SortInput<TField>[];
+    /**
+     * The requested page size. Rows beyond this size indicate a next page.
+     */
+    readonly limit: number;
+    /**
+     * The cursor the page was requested with, if any.
+     */
+    readonly cursor?: string | null;
+    /**
+     * Secret used to sign cursors. Strongly recommended for public APIs.
+     */
+    readonly secret?: string;
+}
+/**
+ * A Prisma-style filter object produced by the keyset helpers.
+ */
+export type KeysetWhere = Readonly<Record<string, unknown>>;
+/**
+ * Decodes and validates a keyset cursor against the sort definition.
+ *
+ * The payload may only contain the sort fields and primitive values.
+ */
+export declare function decodeKeysetCursor<TField extends string = string>(cursor: string, sort: readonly SortInput<TField>[], secret?: string): CursorPayload;
+/**
+ * Builds a Prisma-compatible `where` fragment that selects the rows that
+ * come strictly after the cursor position in the given sort order.
+ *
+ * For a sort of `[a asc, b desc]` the result is
+ * `OR: [{ a: { gt: A } }, { AND: [{ a: A }, { b: { lt: B } }] }]`.
+ */
+export declare function buildKeysetWhere<TField extends string = string>(cursor: CursorPayload, sort: readonly SortInput<TField>[]): KeysetWhere;
+/**
+ * Derives the cursor payload for a row from the sort fields.
+ */
+export declare function createKeysetCursor<TField extends string = string>(row: Readonly<Record<string, unknown>>, sort: readonly SortInput<TField>[], secret?: string): string;
+/**
+ * Turns `limit + 1` fetched rows into a cursor-paginated result.
+ *
+ * Fetch `limit + 1` rows ordered by `sort`, then pass them here: the extra
+ * row signals a next page and is dropped, and `nextCursor` is derived from
+ * the last returned row.
+ */
+export declare function createKeysetPage<TEntity extends Readonly<Record<string, unknown>>, TField extends string = string>(rows: readonly TEntity[], options: KeysetPageOptions<TField>): CursorPaginatedResult<TEntity>;
+//# sourceMappingURL=pagination.keyset.d.ts.map

package/dist/pagination/pagination.keyset.js

@@ -0,0 +1,108 @@
+import { createCursorPaginatedResult, decodeCursor, encodeCursor, normalizeLimit, } from "./pagination.core.js";
+/**
+ * Decodes and validates a keyset cursor against the sort definition.
+ *
+ * The payload may only contain the sort fields and primitive values.
+ */
+export function decodeKeysetCursor(cursor, sort, secret) {
+    validateSort(sort);
+    const payload = decodeCursor(cursor, {
+        secret,
+        allowedFields: sort.map((entry) => entry.field),
+    });
+    for (const entry of sort) {
+        if (!(entry.field in payload)) {
+            throw new TypeError(`Pagination cursor is missing sort field "${entry.field}".`);
+        }
+    }
+    return payload;
+}
+/**
+ * Builds a Prisma-compatible `where` fragment that selects the rows that
+ * come strictly after the cursor position in the given sort order.
+ *
+ * For a sort of `[a asc, b desc]` the result is
+ * `OR: [{ a: { gt: A } }, { AND: [{ a: A }, { b: { lt: B } }] }]`.
+ */
+export function buildKeysetWhere(cursor, sort) {
+    validateSort(sort);
+    const branches = [];
+    sort.forEach((entry, index) => {
+        const comparison = entry.direction === "desc" ? "lt" : "gt";
+        const conditions = sort
+            .slice(0, index)
+            .map((previous) => ({
+            [previous.field]: { equals: cursor[previous.field] },
+        }));
+        conditions.push({
+            [entry.field]: { [comparison]: cursor[entry.field] },
+        });
+        branches.push(conditions.length === 1 ? conditions[0] : { AND: conditions });
+    });
+    return branches.length === 1 ? branches[0] : { OR: branches };
+}
+/**
+ * Derives the cursor payload for a row from the sort fields.
+ */
+export function createKeysetCursor(row, sort, secret) {
+    validateSort(sort);
+    const payload = {};
+    for (const entry of sort) {
+        payload[entry.field] = toCursorValue(row[entry.field], entry.field);
+    }
+    return encodeCursor(payload, { secret });
+}
+/**
+ * Turns `limit + 1` fetched rows into a cursor-paginated result.
+ *
+ * Fetch `limit + 1` rows ordered by `sort`, then pass them here: the extra
+ * row signals a next page and is dropped, and `nextCursor` is derived from
+ * the last returned row.
+ */
+export function createKeysetPage(rows, options) {
+    const limit = normalizeLimit(options.limit);
+    const hasNextPage = rows.length > limit;
+    const data = rows.slice(0, limit);
+    const last = data[data.length - 1];
+    return createCursorPaginatedResult(data, limit, {
+        hasNextPage,
+        hasPreviousPage: options.cursor !== undefined && options.cursor !== null,
+        nextCursor: hasNextPage && last
+            ? createKeysetCursor(last, options.sort, options.secret)
+            : null,
+    });
+}
+function toCursorValue(value, field) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    throw new TypeError(`Cannot build a cursor from field "${field}": unsupported value type.`);
+}
+function validateSort(sort) {
+    if (!Array.isArray(sort) || sort.length === 0) {
+        throw new TypeError("Keyset pagination requires at least one sort field.");
+    }
+    const seen = new Set();
+    for (const entry of sort) {
+        if (typeof entry.field !== "string" || entry.field.trim().length === 0) {
+            throw new TypeError("Keyset sort fields must be non-empty strings.");
+        }
+        if (entry.direction !== "asc" && entry.direction !== "desc") {
+            throw new TypeError(`Keyset sort field "${entry.field}" has an invalid direction.`);
+        }
+        if (seen.has(entry.field)) {
+            throw new TypeError(`Keyset sort field "${entry.field}" is duplicated.`);
+        }
+        seen.add(entry.field);
+    }
+}
+//# sourceMappingURL=pagination.keyset.js.map

package/dist/queryBuilder/index.d.ts

@@ -4,7 +4,8 @@
  * Database-neutral query construction and filter helpers.
  */
 export { QueryBuilder } from "./queryBuilder.core.js";
-export { createQueryBuilder, cloneFilter } from "./queryBuilder.factory.js";
-export type { QueryCondition, QueryFilter, QueryOperator, QueryBuilderState, } from "./queryBuilder.type.js";
-export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, } from "./queryBuilder.filter.js";
+export { createQueryBuilder } from "./queryBuilder.factory.js";
+export { toPrismaWhere, toPrismaArgs, toPrismaOrderBy, toPrismaSelect, toPrismaSkipTake, type PrismaWhere, type PrismaQueryArgs, type ToPrismaArgsOptions, } from "./queryBuilder.prisma.js";
+export type { QueryCondition, QueryFilter, QueryOperator, RelationOperator, QueryBuilderState, } from "./queryBuilder.type.js";
+export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, cloneFilter, between, matchesPattern, isEmpty, isNotEmpty, dateOnly, isBefore, isAfter, isBetween, notCondition, relational, } from "./queryBuilder.filter.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/queryBuilder/index.js

@@ -4,6 +4,7 @@
  * Database-neutral query construction and filter helpers.
  */
 export { QueryBuilder } from "./queryBuilder.core.js";
-export { createQueryBuilder, cloneFilter } from "./queryBuilder.factory.js";
-export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, } from "./queryBuilder.filter.js";
+export { createQueryBuilder } from "./queryBuilder.factory.js";
+export { toPrismaWhere, toPrismaArgs, toPrismaOrderBy, toPrismaSelect, toPrismaSkipTake, } from "./queryBuilder.prisma.js";
+export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, cloneFilter, between, matchesPattern, isEmpty, isNotEmpty, dateOnly, isBefore, isAfter, isBetween, notCondition, relational, } from "./queryBuilder.filter.js";
 //# sourceMappingURL=index.js.map

package/dist/queryBuilder/queryBuilder.core.d.ts

@@ -0,0 +1,178 @@
+import type { QueryOperator, QueryFilter, QueryBuilderState, PaginationInput, SortDirection, SortInput, QueryOptions } from "./queryBuilder.type.js";
+import { type PrismaQueryArgs, type ToPrismaArgsOptions } from "./queryBuilder.prisma.js";
+import { type RelationInclude } from "../relations/relations.definition.js";
+/**
+ * Query builder used to construct database-neutral query definitions.
+ *
+ * The builder does not execute queries. It produces a plain query
+ * definition that repositories or adapters can translate into their
+ * ORM-specific representation.
+ */
+export declare class QueryBuilder<TField extends string = string> {
+    private filterState?;
+    private paginationState?;
+    private sortState;
+    private selectState;
+    private offsetState?;
+    private includeState;
+    private _cachedBuild?;
+    private invalidateCache;
+    /**
+     * Adds an equality condition.
+     */
+    where(field: TField, value: unknown): this;
+    /**
+     * Adds a condition using a specific operator.
+     */
+    whereOperator(field: TField, operator: QueryOperator, value?: unknown): this;
+    /**
+     * Adds a not-equal condition.
+     */
+    whereNot(field: TField, value: unknown): this;
+    /**
+     * Adds an IN condition.
+     */
+    whereIn(field: TField, values: readonly unknown[]): this;
+    /**
+     * Adds a NOT IN condition.
+     */
+    whereNotIn(field: TField, values: readonly unknown[]): this;
+    /**
+     * Adds a less-than condition.
+     */
+    whereLessThan(field: TField, value: unknown): this;
+    /**
+     * Adds a less-than-or-equal condition.
+     */
+    whereLessThanOrEqual(field: TField, value: unknown): this;
+    /**
+     * Adds a greater-than condition.
+     */
+    whereGreaterThan(field: TField, value: unknown): this;
+    /**
+     * Adds a greater-than-or-equal condition.
+     */
+    whereGreaterThanOrEqual(field: TField, value: unknown): this;
+    /**
+     * Adds a contains condition.
+     */
+    whereContains(field: TField, value: string): this;
+    /**
+     * Adds a starts-with condition.
+     */
+    whereStartsWith(field: TField, value: string): this;
+    /**
+     * Adds an ends-with condition.
+     */
+    whereEndsWith(field: TField, value: string): this;
+    /**
+     * Adds an IS NULL condition.
+     */
+    whereNull(field: TField): this;
+    /**
+     * Adds an IS NOT NULL condition.
+     */
+    whereNotNull(field: TField): this;
+    /**
+     * Adds an AND group.
+     */
+    and(...filters: QueryFilter[]): this;
+    /**
+     * Adds an OR group.
+     */
+    or(...filters: QueryFilter[]): this;
+    /**
+     * Adds a NOT group.
+     */
+    not(filter: QueryFilter): this;
+    /**
+     * Sets the requested page.
+     */
+    page(page: number): this;
+    /**
+     * Sets the requested page size.
+     */
+    limit(limit: number): this;
+    /**
+     * Sets pagination.
+     */
+    paginate(pagination: PaginationInput): this;
+    /**
+     * Sets an explicit row offset. Takes precedence over `page()`.
+     */
+    offset(offset: number): this;
+    /**
+     * Adds relations to include. Accepts relation names or include
+     * definitions created with `includeRelation`.
+     */
+    include(...relations: readonly (string | RelationInclude)[]): this;
+    /**
+     * Sorts ascending by a field.
+     */
+    orderByAsc(field: TField): this;
+    /**
+     * Sorts descending by a field.
+     */
+    orderByDesc(field: TField): this;
+    /**
+     * Adds a sort definition.
+     */
+    orderBy(field: TField, direction?: SortDirection): this;
+    /**
+     * Replaces all sort definitions.
+     */
+    sort(sort: readonly SortInput<TField>[]): this;
+    /**
+     * Selects specific fields.
+     */
+    select(...fields: TField[]): this;
+    /**
+     * Clears all filters.
+     */
+    clearFilters(): this;
+    /**
+     * Clears pagination.
+     */
+    clearPagination(): this;
+    /**
+     * Clears sorting.
+     */
+    clearSort(): this;
+    /**
+     * Clears selected fields.
+     */
+    clearSelect(): this;
+    /**
+     * Clears included relations.
+     */
+    clearInclude(): this;
+    /**
+     * Resets the builder to its initial empty state.
+     */
+    reset(): this;
+    /**
+     * Returns the immutable query definition.
+     */
+    build(): QueryBuilderState<TField>;
+    /**
+     * Converts the builder into generic query options (pagination, sort and
+     * the built filter).
+     */
+    toQueryOptions(): QueryOptions<TField> & {
+        readonly filter?: QueryFilter;
+        readonly offset?: number;
+    };
+    /**
+     * Translates the builder into Prisma `findMany`-style arguments.
+     */
+    toPrismaArgs(options?: ToPrismaArgsOptions): PrismaQueryArgs;
+    /**
+     * Creates an independent copy of the builder.
+     */
+    clone(): QueryBuilder<TField>;
+    /**
+     * Adds a condition to the current filter.
+     */
+    private addCondition;
+}
+//# sourceMappingURL=queryBuilder.core.d.ts.map