@eienjs/adonisjs-api-query 1.1.1 → 3.0.0

package/build/src/allowed_filter.d.ts

@@ -1,37 +1,45 @@
-import { type LucidModel, type ModelAttributes, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type StrictValuesWithoutRaw } from '@adonisjs/lucid/types/querybuilder';
-import { Collection } from 'collect.js';
-import { type FilterOperator } from './enums/filter_operator.js';
-import { type ExtractKeys, type Filter } from './types.js';
+import { FilterOperator } from "./enums/filter_operator.js";
+import { EnumType, ExtractKeys, Filter, ScopeUnionKeyParams } from "../types.js";
+import { LucidModel, ModelAttributes, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { StrictValuesWithoutRaw } from "@adonisjs/lucid/types/querybuilder";
+import { SchemaTypes } from "@vinejs/vine/types";
 export declare class AllowedFilter<Model extends LucidModel> {
-    static setFilterArrayValueDelimiter(delimiter?: string): void;
-    static exact<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, addRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    static partial<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, addRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    static beginsWithStrict<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, addRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    static endsWithStrict<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, addRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    static callback<Model extends LucidModel>(name: string, callback: (query: ModelQueryBuilderContract<Model>, value: unknown, property: string) => void, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    static trashed<Model extends LucidModel>(name?: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedFilter<Model>;
-    static custom<Model extends LucidModel>(name: string, filterClass: Filter<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    static operator<Model extends LucidModel>(name: string, filterOperator: FilterOperator, boolean?: 'and' | 'or', internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, addRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
-    protected name: string;
-    protected filterClass: Filter<Model>;
-    protected internalName: string;
-    protected ignored: Collection<unknown>;
-    protected default: unknown;
-    protected $hasDefault: boolean;
-    protected nullable: boolean;
-    constructor(name: string, filterClass: Filter<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>);
-    filter(query: ModelQueryBuilderContract<Model>, value: unknown): void;
-    getFilterClass(): Filter<Model>;
-    getName(): string;
-    isForFilter(filterName: string): boolean;
-    ignore(...values: unknown[]): this;
-    getIgnored(): unknown[];
-    getInternalName(): string;
-    setDefault(defaultValue: unknown): this;
-    getDefault(): unknown;
-    hasDefault(): boolean;
-    setNullable(nullable?: boolean): this;
-    unsetDefault(): this;
-    protected resolveValueForFiltering(value: unknown): StrictValuesWithoutRaw | null;
-}
+  protected name: string;
+  protected filterClass: Filter<Model>;
+  protected internalName: string;
+  protected ignored: unknown[];
+  protected default: unknown;
+  protected $hasDefault: boolean;
+  protected nullable: boolean;
+  protected validationRule?: SchemaTypes;
+  constructor(name: string, filterClass: Filter<Model>, internalName?: string);
+  rule(rule: SchemaTypes): this;
+  getRule(): SchemaTypes | undefined;
+  filter(query: ModelQueryBuilderContract<Model>, value: unknown): void;
+  getFilterClass(): Filter<Model>;
+  getName(): string;
+  isForFilter(filterName: string): boolean;
+  ignore(...values: unknown[]): this;
+  getIgnored(): unknown[];
+  getInternalName(): string;
+  setDefault(defaultValue: unknown): this;
+  getDefault(): unknown;
+  hasDefault(): boolean;
+  setNullable(isNullable?: boolean): this;
+  unsetDefault(): this;
+  protected resolveValueForFiltering(value: unknown): StrictValuesWithoutRaw | null;
+  static setFilterArrayValueDelimiter(delimiter?: string): void;
+  /**
+   * Map of filter name to its Vine rule, for every allowed filter that declares one.
+   */
+  static extractRules(filters: readonly unknown[]): Record<string, SchemaTypes>;
+  static exact<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, shouldAddRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static partial<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, shouldAddRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static beginsWithStrict<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, shouldAddRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static endsWithStrict<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, shouldAddRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static callback<Model extends LucidModel>(name: string, callback: (query: ModelQueryBuilderContract<Model>, value: unknown, property: string) => void, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static trashed<Model extends LucidModel>(name?: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedFilter<Model>;
+  static scope<Model extends LucidModel = LucidModel>(name: string, internalName?: ScopeUnionKeyParams<Model>, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static custom<Model extends LucidModel>(name: string, filterClass: Filter<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, arrayValueDelimiter?: string): AllowedFilter<Model>;
+  static operator<Model extends LucidModel>(name: string, filterOperator: EnumType<typeof FilterOperator>, boolean?: 'and' | 'or', internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>, shouldAddRelationConstraint?: boolean, arrayValueDelimiter?: string): AllowedFilter<Model>;
+}

package/build/src/allowed_filter.js

@@ -0,0 +1,135 @@
+import { ApiQueryBuilderRequest } from "./api_query_builder_request.js";
+import { FiltersExact } from "./filters/filters_exact.js";
+import { FiltersPartial } from "./filters/filters_partial.js";
+import { FiltersBeginWithStrict } from "./filters/filters_begin_with_strict.js";
+import { FiltersCallback } from "./filters/filters_callback.js";
+import { FiltersEndsWithStrict } from "./filters/filters_ends_with_strict.js";
+import { FiltersOperator } from "./filters/filters_operator.js";
+import { FiltersScope } from "./filters/filters_scope.js";
+import { FiltersTrashed } from "./filters/filters_trashed.js";
+// src/allowed_filter.ts
+var AllowedFilter = class AllowedFilter {
+	name;
+	filterClass;
+	internalName;
+	ignored = [];
+	default;
+	$hasDefault = false;
+	nullable = false;
+	validationRule;
+	constructor(name, filterClass, internalName) {
+		this.name = name;
+		this.filterClass = filterClass;
+		this.internalName = internalName ?? this.name;
+	}
+	rule(rule) {
+		this.validationRule = rule;
+		return this;
+	}
+	getRule() {
+		return this.validationRule;
+	}
+	filter(query, value) {
+		const valueToFilter = this.resolveValueForFiltering(value);
+		if (valueToFilter === null && !this.nullable) return;
+		this.filterClass.handle(query, valueToFilter, this.internalName);
+	}
+	getFilterClass() {
+		return this.filterClass;
+	}
+	getName() {
+		return this.name;
+	}
+	isForFilter(filterName) {
+		return this.name === filterName;
+	}
+	ignore(...values) {
+		this.ignored.push(...values.flat(Infinity));
+		return this;
+	}
+	getIgnored() {
+		return this.ignored;
+	}
+	getInternalName() {
+		return this.internalName;
+	}
+	setDefault(defaultValue) {
+		this.default = defaultValue;
+		this.$hasDefault = true;
+		if (defaultValue === null) this.setNullable(true);
+		return this;
+	}
+	getDefault() {
+		return this.default;
+	}
+	hasDefault() {
+		return this.$hasDefault;
+	}
+	setNullable(isNullable = true) {
+		this.nullable = isNullable;
+		return this;
+	}
+	unsetDefault() {
+		this.$hasDefault = false;
+		this.default = void 0;
+		return this;
+	}
+	resolveValueForFiltering(value) {
+		if (Array.isArray(value)) {
+			const remainingProperties = value.map((subValue) => this.resolveValueForFiltering(subValue)).filter((subValue) => subValue !== null);
+			return remainingProperties.length === 0 ? null : remainingProperties;
+		}
+		return this.ignored.includes(value) ? null : value;
+	}
+	static setFilterArrayValueDelimiter(delimiter) {
+		if (delimiter) ApiQueryBuilderRequest.setFilterArrayValueDelimiter(delimiter);
+	}
+	/**
+	* Map of filter name to its Vine rule, for every allowed filter that declares one.
+	*/
+	static extractRules(filters) {
+		const rules = {};
+		for (const filter of filters) {
+			if (!(filter instanceof this)) continue;
+			const rule = filter.getRule();
+			if (rule) rules[filter.getName()] = rule;
+		}
+		return rules;
+	}
+	static exact(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersExact(shouldAddRelationConstraint), internalName);
+	}
+	static partial(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersPartial(shouldAddRelationConstraint), internalName);
+	}
+	static beginsWithStrict(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersBeginWithStrict(shouldAddRelationConstraint), internalName);
+	}
+	static endsWithStrict(name, internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersEndsWithStrict(shouldAddRelationConstraint), internalName);
+	}
+	static callback(name, callback, internalName, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersCallback(callback), internalName);
+	}
+	static trashed(name = "trashed", internalName) {
+		return new AllowedFilter(name, new FiltersTrashed(), internalName);
+	}
+	static scope(name, internalName, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersScope(), internalName);
+	}
+	static custom(name, filterClass, internalName, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, filterClass, internalName);
+	}
+	static operator(name, filterOperator, boolean = "and", internalName, shouldAddRelationConstraint = true, arrayValueDelimiter) {
+		this.setFilterArrayValueDelimiter(arrayValueDelimiter);
+		return new AllowedFilter(name, new FiltersOperator(shouldAddRelationConstraint, filterOperator, boolean), internalName);
+	}
+};
+export { AllowedFilter };

package/build/src/allowed_include.d.ts

@@ -1,17 +1,16 @@
-import { type LucidModel, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type ModelRelations } from '@adonisjs/lucid/types/relations';
-import { Collection } from 'collect.js';
-import { type Include } from './types.js';
+import { Include } from "../types.js";
+import { LucidModel, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
+import { ModelRelations } from "@adonisjs/lucid/types/relations";
 export declare class AllowedInclude<Model extends LucidModel> {
-    static relationship<ParentModel extends LucidModel>(name: string, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    static count<ParentModel extends LucidModel>(name: string, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    static callback<ParentModel extends LucidModel, RelatedModel extends LucidModel>(name: string, callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    static custom<ParentModel extends LucidModel>(name: string, includeClass: Include<ParentModel>, internalName?: string): Collection<AllowedInclude<ParentModel>>;
-    protected internalName: string;
-    protected name: string;
-    protected includeClass: Include<Model>;
-    constructor(name: string, includeClass: Include<Model>, internalName?: string);
-    include(query: ModelQueryBuilderContract<Model>): void;
-    getName(): string;
-    isForInclude(includeName: string): boolean;
-}
+  protected internalName: string;
+  protected name: string;
+  protected includeClass: Include<Model>;
+  constructor(name: string, includeClass: Include<Model>, internalName?: string);
+  include(query: ModelQueryBuilderContract<Model>): void;
+  getName(): string;
+  isForInclude(includeName: string): boolean;
+  static relationship<ParentModel extends LucidModel>(name: string, internalName?: string): AllowedInclude<ParentModel>[];
+  static count<ParentModel extends LucidModel>(name: string, internalName?: string): AllowedInclude<ParentModel>[];
+  static callback<ParentModel extends LucidModel, RelatedModel extends LucidModel>(name: string, callback: (query: ModelRelations<RelatedModel, ParentModel>['builder'] | ModelRelations<RelatedModel, ParentModel>['subQuery']) => void, internalName?: string): AllowedInclude<ParentModel>[];
+  static custom<ParentModel extends LucidModel>(name: string, includeClass: Include<ParentModel>, internalName?: string): AllowedInclude<ParentModel>[];
+}

package/build/src/allowed_include.js

@@ -0,0 +1,47 @@
+import { IncludedCallback } from "./includes/included_callback.js";
+import { IncludedCount } from "./includes/included_count.js";
+import { IncludedRelationship } from "./includes/included_relationship.js";
+import app from "@adonisjs/core/services/app";
+// src/allowed_include.ts
+var AllowedInclude = class AllowedInclude {
+	internalName;
+	name;
+	includeClass;
+	constructor(name, includeClass, internalName) {
+		this.name = name;
+		this.includeClass = includeClass;
+		this.internalName = internalName ?? this.name;
+	}
+	include(query) {
+		this.includeClass.handle(query, this.internalName);
+	}
+	getName() {
+		return this.name;
+	}
+	isForInclude(includeName) {
+		return this.name === includeName;
+	}
+	static relationship(name, internalName) {
+		internalName ??= name;
+		const relationships = IncludedRelationship.getIndividualRelationshipPathsFromInclude(internalName);
+		const aliases = IncludedRelationship.getIndividualRelationshipPathsFromInclude(name);
+		const countSuffix = app.config.get("apiquery.countSuffix", "Count");
+		const includes = [];
+		for (const [index, relationship] of relationships.entries()) {
+			const alias = aliases[index];
+			includes.push(new AllowedInclude(alias, new IncludedRelationship(), relationship));
+			if (!relationship.includes(".")) includes.push(...this.count(`${alias}${countSuffix}`, `${relationship}${countSuffix}`));
+		}
+		return includes;
+	}
+	static count(name, internalName) {
+		return [new AllowedInclude(name, new IncludedCount(), internalName)];
+	}
+	static callback(name, callback, internalName) {
+		return [new AllowedInclude(name, new IncludedCallback(callback), internalName)];
+	}
+	static custom(name, includeClass, internalName) {
+		return [new AllowedInclude(name, includeClass, internalName)];
+	}
+};
+export { AllowedInclude };

package/build/src/allowed_sort.d.ts

@@ -1,18 +1,18 @@
-import { type LucidModel, type ModelAttributes, type ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
-import { type ExtractKeys, type Sort } from './types.js';
+import { ExtractKeys, Sort } from "../types.js";
+import { LucidModel, ModelAttributes, ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
 export declare class AllowedSort<Model extends LucidModel> {
-    static parseSortDirection(name: string): string;
-    static field<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
-    static custom<Model extends LucidModel>(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
-    static callback<Model extends LucidModel>(name: string, callback: (query: ModelQueryBuilderContract<Model>, descending: boolean, property: string) => void, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
-    protected defaultDirection: string;
-    protected internalName: string;
-    protected name: string;
-    protected sortClass: Sort<Model>;
-    constructor(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>);
-    sort(query: ModelQueryBuilderContract<Model>, descending?: boolean): void;
-    getName(): string;
-    isSort(sortName: string): boolean;
-    getInternalName(): string;
-    setDefaultDirection(defaultDirection: string): this;
-}
+  protected defaultDirection: string;
+  protected internalName: string;
+  protected name: string;
+  protected sortClass: Sort<Model>;
+  constructor(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>);
+  sort(query: ModelQueryBuilderContract<Model>, isDescending?: boolean): void;
+  getName(): string;
+  isSort(sortName: string): boolean;
+  getInternalName(): string;
+  setDefaultDirection(defaultDirection: string): this;
+  static parseSortDirection(name: string): string;
+  static field<Model extends LucidModel>(name: string, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
+  static custom<Model extends LucidModel>(name: string, sortClass: Sort<Model>, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
+  static callback<Model extends LucidModel>(name: string, callback: (query: ModelQueryBuilderContract<Model>, isDescending: boolean, property: string) => void, internalName?: ExtractKeys<ModelAttributes<InstanceType<Model>>>): AllowedSort<Model>;
+}

package/build/src/allowed_sort.js

@@ -0,0 +1,49 @@
+import { SortDirection } from "./enums/sort_direction.js";
+import { InvalidDirection } from "./exceptions/invalid_direction.js";
+import { SortsCallback } from "./sorts/sorts_callback.js";
+import { SortsField } from "./sorts/sorts_field.js";
+// src/allowed_sort.ts
+const REMOVE_HYPHEN_STARTING_IN_ANY_POSITION = /^-+/;
+var AllowedSort = class AllowedSort {
+	defaultDirection;
+	internalName;
+	name;
+	sortClass;
+	constructor(name, sortClass, internalName) {
+		this.name = name.replace(REMOVE_HYPHEN_STARTING_IN_ANY_POSITION, "");
+		this.defaultDirection = AllowedSort.parseSortDirection(name);
+		this.sortClass = sortClass;
+		this.internalName = internalName ?? this.name;
+	}
+	sort(query, isDescending) {
+		isDescending ??= this.defaultDirection === SortDirection.Descending;
+		this.sortClass.handle(query, isDescending, this.internalName);
+	}
+	getName() {
+		return this.name;
+	}
+	isSort(sortName) {
+		return this.name === sortName;
+	}
+	getInternalName() {
+		return this.internalName;
+	}
+	setDefaultDirection(defaultDirection) {
+		if (![SortDirection.Ascending, SortDirection.Descending].includes(defaultDirection)) throw InvalidDirection.make(defaultDirection);
+		this.defaultDirection = defaultDirection;
+		return this;
+	}
+	static parseSortDirection(name) {
+		return name.startsWith("-") ? SortDirection.Descending : SortDirection.Ascending;
+	}
+	static field(name, internalName) {
+		return new AllowedSort(name, new SortsField(), internalName);
+	}
+	static custom(name, sortClass, internalName) {
+		return new AllowedSort(name, sortClass, internalName);
+	}
+	static callback(name, callback, internalName) {
+		return new AllowedSort(name, new SortsCallback(callback), internalName);
+	}
+};
+export { AllowedSort };

package/build/src/api_query_builder_request.d.ts

@@ -1,31 +1,56 @@
-import { type Request } from '@adonisjs/core/http';
-import { Collection } from 'collect.js';
+import { QueryValidator, ValidationRules } from "../types.js";
+import { HttpRequest } from "@adonisjs/core/http";
+import { SchemaTypes } from "@vinejs/vine/types";
 export declare class ApiQueryBuilderRequest {
-    protected static includesArrayValueDelimiter: string;
-    protected static appendsArrayValueDelimiter: string;
-    protected static fieldsArrayValueDelimiter: string;
-    protected static sortsArrayValueDelimiter: string;
-    protected static filterArrayValueDelimiter: string;
-    static setArrayValueDelimiter(delimiter: string): void;
-    static setIncludesArrayValueDelimiter(includesArrayValueDelimiter: string): void;
-    static setAppendsArrayValueDelimiter(appendsArrayValueDelimiter: string): void;
-    static setFieldsArrayValueDelimiter(fieldsArrayValueDelimiter: string): void;
-    static setSortsArrayValueDelimiter(sortsArrayValueDelimiter: string): void;
-    static setFilterArrayValueDelimiter(filterArrayValueDelimiter: string): void;
-    static getIncludesArrayValueDelimiter(): string;
-    static getAppendsArrayValueDelimiter(): string;
-    static getFieldsArrayValueDelimiter(): string;
-    static getSortsArrayValueDelimiter(): string;
-    static getFilterArrayValueDelimiter(): string;
-    static resetDelimiters(): void;
-    static fromRequest(request: Request): ApiQueryBuilderRequest;
-    private readonly _request;
-    constructor(request?: Request);
-    includes(): Collection<string>;
-    appends(): Collection<unknown>;
-    fields(): Collection<unknown>;
-    sorts(): Collection<string>;
-    filters(): Collection<unknown>;
-    protected getFilterValue(value: unknown): unknown;
-    protected getRequestData<T = unknown>(key: string, defaultValue?: T): T;
-}
+  protected static includesArrayValueDelimiter: string;
+  protected static appendsArrayValueDelimiter: string;
+  protected static fieldsArrayValueDelimiter: string;
+  protected static sortsArrayValueDelimiter: string;
+  protected static filterArrayValueDelimiter: string;
+  private readonly _request;
+  private _rules?;
+  private _filterRules;
+  private _autoValidate?;
+  private _validation?;
+  private _validatedData?;
+  constructor(request?: HttpRequest);
+  getRequest(): HttpRequest;
+  all(): Record<string, unknown>;
+  setRules(rules: ValidationRules): this;
+  getRules(): ValidationRules | undefined;
+  setFilterRules(rules: Record<string, SchemaTypes>): this;
+  getFilterRules(): Record<string, SchemaTypes>;
+  setAutoValidate(autoValidate: boolean): this;
+  shouldAutoValidate(): boolean;
+  hasValidation(): boolean;
+  toValidator(): Promise<QueryValidator>;
+  /**
+   * Validates the request once (the result is memoized) and returns the validated data.
+   * Returns the raw request data when no rules are configured.
+   */
+  validate<T = Record<string, unknown>>(rules?: ValidationRules): Promise<T>;
+  getValidatedData(): Record<string, unknown> | undefined;
+  isValidated(): boolean;
+  includes(): string[];
+  appends(): string[];
+  sorts(): string[];
+  fields(): Record<string, string[]>;
+  filters(): Record<string, unknown>;
+  protected getArrayParameterData(configKey: string, defaultParam: string, delimiter: string): string[];
+  protected getFilterValue(value: unknown): unknown;
+  protected getRequestData<T = unknown>(key: string, defaultValue?: T): T;
+  protected runValidation(): Promise<Record<string, unknown>>;
+  static setArrayValueDelimiter(delimiter: string): void;
+  static setIncludesArrayValueDelimiter(includesArrayValueDelimiter: string): void;
+  static setAppendsArrayValueDelimiter(appendsArrayValueDelimiter: string): void;
+  static setFieldsArrayValueDelimiter(fieldsArrayValueDelimiter: string): void;
+  static setSortsArrayValueDelimiter(sortsArrayValueDelimiter: string): void;
+  static setFilterArrayValueDelimiter(filterArrayValueDelimiter: string): void;
+  static getIncludesArrayValueDelimiter(): string;
+  static getAppendsArrayValueDelimiter(): string;
+  static getFieldsArrayValueDelimiter(): string;
+  static getSortsArrayValueDelimiter(): string;
+  static getFilterArrayValueDelimiter(): string;
+  static resetDelimiters(): void;
+  static fromRequest(request: HttpRequest): ApiQueryBuilderRequest;
+}