ng-qubee 3.6.0 → 3.7.0

package/types/ng-qubee.d.ts

@@ -40,39 +40,52 @@ declare class PaginatedCollection<T extends IPaginatedObject> {
 }
 
 /**
- * Enum representing the available pagination driver types
+ * Configuration interface for customizing request query parameter key names
  *
- * Each driver encapsulates the full format knowledge for both
- * request building (URI generation) and response parsing.
+ * Each property maps a logical query concept to the actual query parameter name
+ * used in the generated URI. The defaults depend on the selected driver.
  */
-declare enum DriverEnum {
-    DRF = "drf",
-    JSON_API = "json-api",
-    LARAVEL = "laravel",
-    NESTJS = "nestjs",
-    NESTJSX_CRUD = "nestjsx-crud",
-    POSTGREST = "postgrest",
-    SIEVE = "sieve",
-    SPATIE = "spatie",
-    SPRING = "spring",
-    STRAPI = "strapi"
+interface IQueryBuilderConfig {
+    /** Key for the appends parameter (Laravel only, default: 'append') */
+    appends?: string;
+    /** Key for the fields parameter (Laravel: 'fields', NestJS: 'select') */
+    fields?: string;
+    /** Key for the filters parameter (default: 'filter') */
+    filters?: string;
+    /** Key for the includes parameter (Laravel only, default: 'include') */
+    includes?: string;
+    /** Key for the limit parameter (default: 'limit') */
+    limit?: string;
+    /** Key for the page parameter (default: 'page') */
+    page?: string;
+    /** Key for the search parameter (NestJS only, default: 'search') */
+    search?: string;
+    /** Key for the select parameter (NestJS only, default: 'select') */
+    select?: string;
+    /** Key for the sort parameter (Laravel: 'sort', NestJS: 'sortBy') */
+    sort?: string;
+    /** Key for the sortBy parameter (NestJS only, default: 'sortBy') */
+    sortBy?: string;
 }
 
 /**
- * Enum representing the wire-level pagination mechanism
- *
- * `QUERY` (default) — the request strategy emits `limit` and `offset` (or
- * equivalent) query parameters on the URL.
+ * Resolved query parameter key names with defaults applied
  *
- * `RANGE` — the request strategy omits URL-based pagination and the
- * consumer instead applies HTTP request headers returned by
- * `NgQubeeService.paginationHeaders()`. Currently honoured only by the
- * PostgREST driver, which maps it to `Range-Unit: items` + `Range: 0-9`.
- * Other drivers ignore the setting.
+ * Maps logical query concepts to the actual query parameter names
+ * used in the generated URI. Unset values fall back to defaults.
  */
-declare enum PaginationModeEnum {
-    QUERY = "query",
-    RANGE = "range"
+declare class QueryBuilderOptions {
+    readonly appends: string;
+    readonly fields: string;
+    readonly filters: string;
+    readonly includes: string;
+    readonly limit: string;
+    readonly page: string;
+    readonly search: string;
+    readonly select: string;
+    readonly sort: string;
+    readonly sortBy: string;
+    constructor(options: IQueryBuilderConfig);
 }
 
 /**
@@ -112,32 +125,264 @@ interface IPaginationConfig {
 }
 
 /**
- * Configuration interface for customizing request query parameter key names
+ * Resolved response field key names with defaults applied
  *
- * Each property maps a logical query concept to the actual query parameter name
- * used in the generated URI. The defaults depend on the selected driver.
+ * Maps logical pagination concepts to the actual key names
+ * used in the API response. Unset values fall back to Laravel defaults.
+ *
+ * For NestJS responses, use dot-notation paths:
+ * ```typescript
+ * new ResponseOptions({
+ *   currentPage: 'meta.currentPage',
+ *   total: 'meta.totalItems'
+ * });
+ * ```
  */
-interface IQueryBuilderConfig {
-    /** Key for the appends parameter (Laravel only, default: 'append') */
-    appends?: string;
-    /** Key for the fields parameter (Laravel: 'fields', NestJS: 'select') */
-    fields?: string;
-    /** Key for the filters parameter (default: 'filter') */
-    filters?: string;
-    /** Key for the includes parameter (Laravel only, default: 'include') */
-    includes?: string;
-    /** Key for the limit parameter (default: 'limit') */
-    limit?: string;
-    /** Key for the page parameter (default: 'page') */
-    page?: string;
-    /** Key for the search parameter (NestJS only, default: 'search') */
-    search?: string;
-    /** Key for the select parameter (NestJS only, default: 'select') */
-    select?: string;
-    /** Key for the sort parameter (Laravel: 'sort', NestJS: 'sortBy') */
-    sort?: string;
-    /** Key for the sortBy parameter (NestJS only, default: 'sortBy') */
-    sortBy?: string;
+declare class ResponseOptions {
+    readonly currentPage: string;
+    readonly data: string;
+    readonly firstPageUrl: string;
+    readonly from: string;
+    readonly lastPage: string;
+    readonly lastPageUrl: string;
+    readonly nextPageUrl: string;
+    readonly path: string;
+    readonly perPage: string;
+    readonly prevPageUrl: string;
+    readonly to: string;
+    readonly total: string;
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the API Platform (Symfony) driver
+ *
+ * Uses dot-notation paths into the Hydra/JSON-LD envelope — the Hydra
+ * keys contain colons but no dots, so `hydra:view.hydra:next` traverses
+ * `response['hydra:view']['hydra:next']`. The `path` slot points at the
+ * view's `@id`, which the strategy parses for the current page and page
+ * size; `currentPage` / `perPage` / `lastPage` have no body field and
+ * default to empty paths (derived from the view URLs instead).
+ */
+declare class ApiPlatformResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the Directus driver
+ *
+ * The Directus envelope is `{ data, meta: { total_count, filter_count } }`
+ * (with `meta=total_count,filter_count` requested — the request strategy
+ * always emits it). `total` defaults to `meta.filter_count`, the count of
+ * items matching the current filter; point it at `meta.total_count` via
+ * `IPaginationConfig` for the unfiltered collection size. The envelope
+ * names no current page, page size, or navigation URLs, so those paths
+ * default to empty strings — the strategy falls back to page 1 and
+ * derives `lastPage`/`from`/`to` only when the response provably holds
+ * the whole filtered set. All paths are overridable (dot notation
+ * supported) for custom wrappers that do include paging fields.
+ */
+declare class DirectusResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the Django REST Framework (DRF) driver
+ *
+ * DRF's `PageNumberPagination` envelope is `{ count, next, previous,
+ * results }`, with no body field naming the current page, per-page, or
+ * last-page. The strategy parses those from the `next` / `previous`
+ * URLs, so the corresponding key paths default to empty strings; the
+ * strategy ignores `options.currentPage`, `options.perPage`,
+ * `options.lastPage`, `options.from`, `options.to`, `options.path`,
+ * `options.firstPageUrl`, and `options.lastPageUrl`.
+ */
+declare class DrfResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the FeathersJS driver
+ *
+ * The Feathers adapter envelope is `{ total, limit, skip, data }` —
+ * offset-based, with no page number and no navigation URLs. `perPage`
+ * maps to the envelope's `limit` key and `total` to `total`; the
+ * strategy derives `currentPage` / `lastPage` / `from` / `to` from
+ * `skip` and `limit`, so the corresponding key paths default to empty
+ * strings (the `skip` key itself is fixed by the envelope and read
+ * directly by the strategy).
+ */
+declare class FeathersResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the JSON:API driver
+ *
+ * Uses dot-notation paths to access nested values in the JSON:API response format.
+ * JSON:API meta key names vary by implementation; these defaults cover the most
+ * common conventions and can be fully customised via `IPaginationConfig`.
+ */
+declare class JsonApiResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the json-server driver
+ *
+ * The json-server v1 envelope is `{ first, prev, next, last, pages,
+ * items, data }`, where `first`/`prev`/`next`/`last` are **page
+ * numbers**, not URLs — the strategy reads `prev`/`next` directly for
+ * position derivation and leaves the URL slots `undefined`, so the
+ * navigation-URL paths default to empty strings. `total` maps to
+ * `items` and `lastPage` to `pages`; `currentPage` and `perPage` have
+ * no body field and are derived.
+ */
+declare class JsonServerResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the NestJS driver
+ *
+ * Uses dot-notation paths to access nested values in the NestJS response format.
+ */
+declare class NestjsResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the @nestjsx/crud driver
+ *
+ * The `getMany` envelope is flat: `{ data, count, total, page,
+ * pageCount }`. `perPage` defaults to the `count` field — the number of
+ * entities on the **current** page, which equals the requested limit on
+ * every page except a partial last one. The envelope carries no
+ * `from`/`to` indices and no navigation links, so those paths default to
+ * empty strings (the strategy derives `from`/`to` and leaves the URLs
+ * `undefined`); consumers can override any path via `IPaginationConfig`.
+ */
+declare class NestjsxCrudResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the OData v4 driver
+ *
+ * The OData collection envelope is `{ "@odata.count", "@odata.nextLink",
+ * "value" }` — flat keys that contain **literal dots**, so the strategy
+ * reads them with flat bracket access (never dot-path traversal). No body
+ * field names the current page, per-page, or last-page; the strategy
+ * derives those from the `@odata.nextLink` URL's `$skip` / `$top`
+ * params, so the corresponding key paths default to empty strings and
+ * are ignored.
+ */
+declare class OdataResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the Payload CMS driver
+ *
+ * The envelope is the flat `mongoose-paginate-v2` shape: `{ docs,
+ * totalDocs, limit, totalPages, page, pagingCounter, hasPrevPage,
+ * hasNextPage, prevPage, nextPage }`. `pagingCounter` is the 1-indexed
+ * offset of the first doc on the page and maps onto `from`; `to` has no
+ * body field and is derived. `prevPage`/`nextPage` are page numbers,
+ * not URLs, so the navigation-URL paths default to empty strings. All
+ * paths are overridable via `IPaginationConfig` (dot notation
+ * supported) for custom wrappers.
+ */
+declare class PayloadResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the PocketBase driver
+ *
+ * The records-list envelope is flat: `{ page, perPage, totalItems,
+ * totalPages, items }`. The envelope carries no `from`/`to` indices and
+ * no navigation links, so those paths default to empty strings (the
+ * strategy derives `from`/`to` from `page` × `perPage` and leaves the
+ * URLs `undefined`); all paths are overridable via `IPaginationConfig`
+ * (dot notation supported) for custom wrappers.
+ */
+declare class PocketbaseResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the Sieve (.NET) driver
+ *
+ * Sieve defines no response envelope (it returns an `IQueryable` the
+ * developer wraps), so these defaults target the common hand-rolled
+ * `PagedResult<T>` shape: `{ data, page, pageSize, total, totalPages }`.
+ * Every path is overridable via `IPaginationConfig` — dot notation is
+ * supported, so nested wrappers (`meta.page`, `pagination.total`) map
+ * without subclassing. `from`/`to` default to empty paths and are
+ * derived; the navigation-URL slots resolve to `undefined` unless paths
+ * are provided.
+ */
+declare class SieveResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the Spring Data REST driver
+ *
+ * Uses dot-notation paths into the HAL envelope: pagination metadata
+ * lives under `page.*` and navigation links under `_links.*.href`.
+ * `currentPage` points at the **0-indexed** `page.number`; the strategy
+ * adds 1 when reading it. `data` defaults to plain `_embedded` because
+ * the collection key underneath is the resource rel name (e.g.
+ * `_embedded.users`) and cannot be known statically — the strategy picks
+ * the first array inside; pin an exact path via `IPaginationConfig` when
+ * needed. `from`/`to` default to empty paths and are derived.
+ */
+declare class SpringResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+/**
+ * Pre-configured ResponseOptions for the Strapi driver
+ *
+ * Uses dot-notation paths to access the nested `meta.pagination.*` envelope
+ * Strapi v4/v5 emits. Strapi does not include navigation links by default,
+ * so the URL paths point at locations that will resolve to `undefined`
+ * unless the consumer overrides them.
+ */
+declare class StrapiResponseOptions extends ResponseOptions {
+    constructor(options: IPaginationConfig);
+}
+
+/**
+ * Enum representing the available pagination driver types
+ *
+ * Each driver encapsulates the full format knowledge for both
+ * request building (URI generation) and response parsing.
+ */
+declare enum DriverEnum {
+    API_PLATFORM = "api-platform",
+    DIRECTUS = "directus",
+    DRF = "drf",
+    FEATHERS = "feathers",
+    JSON_API = "json-api",
+    JSON_SERVER = "json-server",
+    LARAVEL = "laravel",
+    NESTJS = "nestjs",
+    NESTJSX_CRUD = "nestjsx-crud",
+    ODATA = "odata",
+    PAYLOAD = "payload",
+    POCKETBASE = "pocketbase",
+    POSTGREST = "postgrest",
+    SIEVE = "sieve",
+    SPATIE = "spatie",
+    SPRING = "spring",
+    STRAPI = "strapi",
+    WORDPRESS = "wordpress"
+}
+
+/**
+ * Enum representing the wire-level pagination mechanism
+ *
+ * `QUERY` (default) — the request strategy emits `limit` and `offset` (or
+ * equivalent) query parameters on the URL.
+ *
+ * `RANGE` — the request strategy omits URL-based pagination and the
+ * consumer instead applies HTTP request headers returned by
+ * `NgQubeeService.paginationHeaders()`. Currently honoured only by the
+ * PostgREST driver, which maps it to `Range-Unit: items` + `Range: 0-9`.
+ * Other drivers ignore the setting.
+ */
+declare enum PaginationModeEnum {
+    QUERY = "query",
+    RANGE = "range"
 }
 
 /**
@@ -352,6 +597,19 @@ interface ISort {
     order: SortEnum;
 }
 
+/**
+ * Embedded-resource selection map (PostgREST only)
+ *
+ * Maps a related table / foreign-key name (as PostgREST sees it) to the
+ * columns to project from it. An empty array means "all columns" and
+ * emits `relation(*)`; a non-empty array emits `relation(col1,col2)`.
+ * The PostgREST request strategy splices these fragments into the single
+ * `select=` query parameter alongside flat columns from `addSelect`.
+ */
+type Embedded = {
+    [relation: string]: string[];
+};
+
 /**
  * Represents the complete query builder state
  *
@@ -361,6 +619,8 @@ interface ISort {
 interface IQueryBuilderState {
     /** The base URL to prepend to generated URIs */
     baseUrl: string;
+    /** Embedded-resource selection (PostgREST only) */
+    embedded: Embedded;
     /** Per-model field selection (Spatie only) */
     fields: IFields;
     /** Simple key-value filters (Spatie and NestJS) */
@@ -398,6 +658,8 @@ interface IQueryBuilderState {
  * strategy class — `NgQubeeService` does not need to be touched.
  */
 interface IStrategyCapabilities {
+    /** Embedded-resource selection inside `select` (PostgREST `select=col,rel(col1)`) */
+    readonly embedded: boolean;
     /** Per-model field selection (e.g. JSON:API `fields[type]=col1,col2`) */
     readonly fields: boolean;
     /** Simple key-value filters (e.g. `filter.status=active`) */
@@ -414,26 +676,6 @@ interface IStrategyCapabilities {
     readonly sort: boolean;
 }
 
-/**
- * Resolved query parameter key names with defaults applied
- *
- * Maps logical query concepts to the actual query parameter names
- * used in the generated URI. Unset values fall back to defaults.
- */
-declare class QueryBuilderOptions {
-    readonly appends: string;
-    readonly fields: string;
-    readonly filters: string;
-    readonly includes: string;
-    readonly limit: string;
-    readonly page: string;
-    readonly search: string;
-    readonly select: string;
-    readonly sort: string;
-    readonly sortBy: string;
-    constructor(options: IQueryBuilderConfig);
-}
-
 /**
  * Strategy interface for building request URIs
  *
@@ -559,6 +801,21 @@ declare class NestService {
      * @private
      */
     private _validateResourceName;
+    /**
+     * Add embedded-resource selections to the request (PostgREST only)
+     * Automatically prevents duplicate columns for each relation
+     *
+     * An empty column array means "all columns" (`relation(*)`); merging an
+     * empty array into a relation that already has explicit columns keeps
+     * the explicit columns.
+     *
+     * @param {Embedded} embedded - Object mapping relation names to arrays of columns to project
+     * @return {void}
+     * @example
+     * service.addEmbedded({ author: ['id', 'name'] });
+     * service.addEmbedded({ comments: [] });
+     */
+    addEmbedded(embedded: Embedded): void;
     /**
      * Add selectable fields for the given model to the request
      * Automatically prevents duplicate fields for each model
@@ -624,6 +881,18 @@ declare class NestService {
      * service.addSort({ field: 'name', order: SortEnum.ASC });
      */
     addSort(sort: ISort): void;
+    /**
+     * Remove embedded-resource relations from the state (PostgREST only)
+     *
+     * Removes the whole relation entry, columns included.
+     *
+     * @param {...string[]} relations - Relation names to remove
+     * @return {void}
+     * @example
+     * service.deleteEmbedded('author');
+     * service.deleteEmbedded('comments', 'tags');
+     */
+    deleteEmbedded(...relations: string[]): void;
     /**
      * Remove fields for the given model
      * Uses deep cloning to prevent mutations to the original state
@@ -764,6 +1033,29 @@ declare class NgQubeeService {
      * @throws The provided error if the active strategy lacks the capability
      */
     private _assertCapability;
+    /**
+     * Add an embedded resource to the select statement (PostgREST only)
+     *
+     * Splices `relation(col1,col2)` into the single `select=` query
+     * parameter alongside flat columns from `addSelect`. Omit the columns
+     * to project all of them (`relation(*)`):
+     *
+     * ```
+     * qb.addEmbedded('author', 'id', 'name')
+     *   .addEmbedded('comments')
+     *   .addSelect('title');
+     * // → select=title,author(id,name),comments(*)
+     * ```
+     *
+     * Calling repeatedly with the same relation merge-dedups the columns.
+     * Does not reset the page (column shape change, not record-set change).
+     *
+     * @param {string} relation - The related table / foreign-key name as PostgREST sees it
+     * @param {string[]} columns - Optional column projection; omit for `relation(*)`
+     * @returns {this}
+     * @throws {UnsupportedEmbeddedError} If the active driver does not support embedded resources
+     */
+    addEmbedded(relation: string, ...columns: string[]): this;
     /**
      * Add fields to the select statement for the given model (JSON:API and Spatie only)
      *
@@ -831,11 +1123,21 @@ declare class NgQubeeService {
      */
     currentPage(): number;
     /**
-     * Delete selected fields for the given models in the current query builder state (JSON:API and Spatie only)
+     * Remove embedded resources from the current query builder state (PostgREST only)
      *
-     * ```
-     * ngQubeeService.deleteFields({
-     *   users: ['email', 'password'],
+     * Removes the whole relation entry, columns included.
+     *
+     * @param {string[]} relations - Relation names to remove
+     * @returns {this}
+     * @throws {UnsupportedEmbeddedError} If the active driver does not support embedded resources
+     */
+    deleteEmbedded(...relations: string[]): this;
+    /**
+     * Delete selected fields for the given models in the current query builder state (JSON:API and Spatie only)
+     *
+     * ```
+     * ngQubeeService.deleteFields({
+     *   users: ['email', 'password'],
      *   address: ['zipcode']
      * });
      * ```
@@ -1076,36 +1378,6 @@ type HeaderBag = {
  */
 declare function readHeader(bag: HeaderBag | null | undefined, name: string): string | null;
 
-/**
- * Resolved response field key names with defaults applied
- *
- * Maps logical pagination concepts to the actual key names
- * used in the API response. Unset values fall back to Laravel defaults.
- *
- * For NestJS responses, use dot-notation paths:
- * ```typescript
- * new ResponseOptions({
- *   currentPage: 'meta.currentPage',
- *   total: 'meta.totalItems'
- * });
- * ```
- */
-declare class ResponseOptions {
-    readonly currentPage: string;
-    readonly data: string;
-    readonly firstPageUrl: string;
-    readonly from: string;
-    readonly lastPage: string;
-    readonly lastPageUrl: string;
-    readonly nextPageUrl: string;
-    readonly path: string;
-    readonly perPage: string;
-    readonly prevPageUrl: string;
-    readonly to: string;
-    readonly total: string;
-    constructor(options: IPaginationConfig);
-}
-
 /**
  * Strategy interface for parsing paginated API responses
  *
@@ -1250,6 +1522,19 @@ declare class UnselectableModelError extends Error {
     constructor(model: string);
 }
 
+/**
+ * Error thrown when embedded resources are attempted with a driver that
+ * does not support them
+ *
+ * Embedded-resource fetching (`select=col,relation(col1,col2)`) is a
+ * PostgREST-native join mechanism and is only supported by the PostgREST
+ * driver. Drivers with a standalone relation parameter expose it through
+ * `addIncludes()` instead (JSON:API, Spatie, Strapi, @nestjsx/crud).
+ */
+declare class UnsupportedEmbeddedError extends Error {
+    constructor();
+}
+
 /**
  * Error thrown when per-model field selection is attempted with a driver that does not support it
  *
@@ -1449,294 +1734,382 @@ declare abstract class AbstractRequestStrategy implements IRequestStrategy {
 }
 
 /**
- * Request strategy for the Django REST Framework (DRF) driver
- *
- * Generates URIs in DRF's flat query-parameter format, augmented by
- * django-filter's double-underscore lookup convention:
- *
- * - Simple filters: `field=value` (multi-value collapses to `field__in=v1,v2`)
- * - Operator filters: `field__lookup=value` (translated from
- *   `FilterOperatorEnum` — `GTE`→`__gte`, `ILIKE`→`__icontains`,
- *   `BTW`→`__range`, `NULL`→`__isnull`, etc.)
- * - Ordering: `ordering=-field1,field2` (`-` prefix = DESC)
- * - Search: `search=term` (DRF's SearchFilter)
- * - Pagination: `page=N&page_size=M` (PageNumberPagination)
- *
- * `ordering` and `page_size` are DRF-idiomatic param names and are
- * intentionally not configurable via `QueryBuilderOptions` — same
- * precedent as PostgREST's `order` and `offset`. PostgREST's full-text
- * search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) and the generic
- * `NOT` have no django-filter equivalent and throw
- * `UnsupportedFilterOperatorError`.
- *
- * @see https://www.django-rest-framework.org/api-guide/filtering/
- * @see https://django-filter.readthedocs.io/
+ * Request strategy for the API Platform (Symfony) driver
+ *
+ * Generates URIs in [API Platform's filter format](https://api-platform.com/docs/core/filters/):
+ * - Filters: `field=value` (exact); multi-value uses the array syntax
+ *   (`field[]=v1&field[]=v2`, OR semantics)
+ * - Operator filters: bracket syntax `field[op]=value` — RangeFilter
+ *   (`gt`/`gte`/`lt`/`lte`/`between`), SearchFilter strategies
+ *   (`partial`/`ipartial`/`start`), ExistsFilter (`exists`) — see the
+ *   mapping on `_formatOperatorSegments`
+ * - Relation filtering: dot paths pass through (`author.name=John` via
+ *   `addFilter('author.name', 'John')`)
+ * - Sorts: `order[field]=asc` / `order[field]=desc` (one param per rule)
+ * - Pagination: `page=N&itemsPerPage=M`
+ *
+ * The `order` and `itemsPerPage` keys are API Platform conventions and
+ * intentionally not configurable through `QueryBuilderOptions`; `page`
+ * honours the existing option key (its default matches the wire format).
+ *
+ * Date fields use API Platform's DateFilter (`field[after]=…`,
+ * `field[before]=…`) — there is no `FilterOperatorEnum` counterpart, but
+ * the bracket key passes through `addFilter` directly:
+ * `addFilter('createdAt[after]', '2023-01-01')`.
+ *
+ * `NOT` (no negation filter in API Platform core) and the
+ * PostgREST-native full-text operators (`FTS`, `PHFTS`, `PLFTS`,
+ * `WFTS`) throw `UnsupportedFilterOperatorError`.
+ *
+ * @see https://api-platform.com/docs/core/filters/
  */
-declare class DrfRequestStrategy extends AbstractRequestStrategy {
+declare class ApiPlatformRequestStrategy extends AbstractRequestStrategy {
     /**
-     * Simple filters, operator filters (django-filter lookups), sorts, and
-     * global search — no per-model fields, no relation includes, no flat
-     * select (django-restql adds it but is not core DRF)
+     * Filters, operator filters, sorts — no per-model fields, no
+     * includes (relations embed via serialization groups server-side),
+     * no flat select, no global search parameter
      */
     readonly capabilities: IStrategyCapabilities;
     /**
-     * DRF-native names of the three hardcoded query keys
+     * API Platform-native names of the two hardcoded query keys
      *
-     * `ordering` and `page_size` are DRF/django-filter conventions and are
-     * intentionally not configurable through `QueryBuilderOptions`. `page`
-     * matches the default `QueryBuilderOptions.page`, and `search` matches
-     * the default `QueryBuilderOptions.search`, so those flow through the
-     * shared options object.
+     * `order[...]` and `itemsPerPage` are fixed conventions of API
+     * Platform's OrderFilter and pagination; they are intentionally not
+     * configurable through `QueryBuilderOptions` and live as private
+     * statics so they are visible in one place.
      */
-    private static readonly _orderingKey;
-    private static readonly _pageSizeKey;
+    private static readonly _itemsPerPageKey;
+    private static readonly _orderKey;
     /**
-     * Emit DRF-format query-string segments in canonical order:
-     * filters → operator filters → ordering → search → pagination
+     * Emit API Platform-format query-string segments in canonical order:
+     * filters → operator filters → order → page → itemsPerPage
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
+     * @param options - The query parameter key name configuration (used
+     * for `page`, whose default matches the wire format)
      * @returns Ordered query-string fragments
      */
     protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
     /**
      * Append simple filter parameters
      *
-     * Single-value filters emit `field=value` (django-filter's default
-     * exact match). Multi-value filters collapse to django-filter's
-     * `field__in=v1,v2,v3` form, which is the idiomatic way to express
-     * "value in list" in DRF.
+     * A single value emits the bare exact-match form (`field=value`);
+     * multiple values use API Platform's array syntax with OR semantics
+     * (`field[]=v1&field[]=v2`).
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
      */
     private _appendFilters;
     /**
-     * Append operator-filter parameters as `field__lookup=value`
-     *
-     * Maps each `FilterOperatorEnum` value to a django-filter lookup
-     * suffix. `BTW` expands to `field__range=min,max`; `NULL` emits
-     * `field__isnull=true|false`; the generic `NOT` and PostgREST-only
-     * FTS operators are unsupported.
+     * Append the itemsPerPage parameter
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
-     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
-     * exactly two values, or `NULL` does not receive exactly one boolean
-     * @throws {UnsupportedFilterOperatorError} If the operator has no
-     * django-filter equivalent
      */
-    private _appendOperatorFilters;
+    private _appendItemsPerPage;
     /**
-     * Append `ordering=-field1,field2` (django's `-` prefix = DESC)
+     * Append explicit operator filters in the bracket syntax
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendOrdering;
+    private _appendOperatorFilters;
     /**
-     * Append `page=N&page_size=M`
-     *
-     * `page` follows `options.page` (default `page`, matching DRF); the
-     * size key is hardcoded to DRF's idiomatic `page_size`.
+     * Append `order[field]=asc` / `order[field]=desc` params, one per rule
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendPagination;
+    private _appendOrder;
     /**
-     * Append `search=term` when a search term is set
+     * Append the page parameter
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendSearch;
+    private _appendPage;
     /**
-     * Translate a `FilterOperatorEnum` operator filter into a
-     * `[suffix, serializedValue]` pair
-     *
-     * The suffix is appended to the field name with a `__` separator on the
-     * wire side (`field__gte=18`). The empty string means "no suffix" —
-     * django-filter's implicit `exact` lookup.
-     *
-     * Mapping:
-     * - `EQ` → `''` (no suffix; default exact match)
-     * - `GT`/`GTE`/`LT`/`LTE`/`CONTAINS` → identity (lowercased name)
-     * - `ILIKE` → `icontains` (closest case-insensitive analog)
-     * - `IN` → `in` with comma-joined values
-     * - `SW` → `startswith`
-     * - `BTW` → `range` with comma-joined `[min, max]` (arity-checked)
-     * - `NULL` → `isnull` with boolean value (arity- and type-checked)
-     * - `NOT` → `UnsupportedFilterOperatorError` (no generic negation in
-     *   django-filter; use `__exclude` on the queryset instead)
-     * - `FTS`/`PLFTS`/`PHFTS`/`WFTS` → `UnsupportedFilterOperatorError`
+     * Translate a `FilterOperatorEnum` operator filter into one or more
+     * API Platform bracket segments
+     *
+     * The mapping is library-canonical → API Platform-native:
+     * - `EQ` → bare exact match (`field=value`, SearchFilter exact)
+     * - `GT`/`GTE`/`LT`/`LTE` → RangeFilter (`field[gt]=v`, …)
+     * - `BTW` → RangeFilter `field[between]=min..max` (arity-checked)
+     * - `CONTAINS` → SearchFilter partial (`field[partial]=v`)
+     * - `ILIKE` → SearchFilter ipartial (`field[ipartial]=v`,
+     *   case-insensitive)
+     * - `SW` → SearchFilter start (`field[start]=v`)
+     * - `IN` → array syntax (`field[]=v1&field[]=v2`)
+     * - `NULL` → ExistsFilter — **inverted**: `true` (IS NULL) emits
+     *   `field[exists]=false`, `false` (IS NOT NULL) emits
+     *   `field[exists]=true`; arity- and type-checked
+     *
+     * `NOT` (API Platform core ships no negation filter) and PostgREST's
+     * full-text-search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+     * `UnsupportedFilterOperatorError`.
      *
      * @param filter - The operator filter to translate
-     * @returns A `[lookupSuffix, serializedValue]` tuple
+     * @returns One or more bracket-syntax query-string segments
      * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
      * exactly two values, or `NULL` does not receive exactly one boolean
-     * @throws {UnsupportedFilterOperatorError} If the operator has no
-     * django-filter equivalent
+     * @throws {UnsupportedFilterOperatorError} If the operator has no API
+     * Platform equivalent
      */
-    private _formatOperatorPayload;
+    private _formatOperatorSegments;
 }
 
 /**
- * Response strategy for the Django REST Framework (DRF) driver
+ * Base class for response strategies whose pagination metadata lives at
+ * dot-notation paths inside the response body
  *
- * Parses DRF `PageNumberPagination` responses:
+ * JSON:API and NestJS share an identical body-traversal algorithm: the
+ * total / current-page / etc. live at nested keys like `meta.total`, and
+ * `from`/`to` are either present directly or must be derived from
+ * `currentPage` × `perPage`. Both strategies were duplicating this
+ * verbatim before this base existed; concrete classes now extend and
+ * provide only the docstring describing their driver's specific path
+ * conventions (see `JsonApiResponseStrategy`, `NestjsResponseStrategy`).
+ *
+ * Drivers whose pagination metadata travels via HTTP headers (PostgREST)
+ * or whose body has a flat shape with no dot paths (Laravel, Spatie) do
+ * not extend this class — they implement `IResponseStrategy` directly.
+ */
+declare abstract class AbstractDotPathResponseStrategy implements IResponseStrategy {
+    /**
+     * Parse a nested-envelope pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration (dot-notation paths supported)
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+    /**
+     * Resolve a value from a response object using a dot-notation path
+     *
+     * Supports both flat keys (`'data'`) and nested paths (`'meta.totalItems'`).
+     *
+     * @param response - The raw response object
+     * @param path - The dot-notation path to resolve
+     * @returns The resolved value, or undefined if any segment is missing
+     */
+    protected resolve(response: Record<string, any>, path: string): unknown;
+    /**
+     * Resolve the "from" index value
+     *
+     * If `options.from` resolves to a value in the response, use it.
+     * Otherwise compute `(currentPage - 1) * perPage + 1` when both are known.
+     *
+     * @param response - The raw response object
+     * @param options - The response key name configuration
+     * @param currentPage - The current page number
+     * @param perPage - The number of items per page
+     * @returns The "from" index, or `undefined` when neither path nor inputs suffice
+     */
+    protected resolveFrom(response: Record<string, any>, options: ResponseOptions, currentPage: number, perPage?: number): number | undefined;
+    /**
+     * Resolve the "to" index value
+     *
+     * If `options.to` resolves to a value in the response, use it.
+     * Otherwise compute `Math.min(currentPage * perPage, total)` when all
+     * three are known.
+     *
+     * @param response - The raw response object
+     * @param options - The response key name configuration
+     * @param currentPage - The current page number
+     * @param perPage - The number of items per page
+     * @param total - The total number of items
+     * @returns The "to" index, or `undefined` when neither path nor inputs suffice
+     */
+    protected resolveTo(response: Record<string, any>, options: ResponseOptions, currentPage: number, perPage?: number, total?: number): number | undefined;
+}
+
+/**
+ * Response strategy for the API Platform (Symfony) driver
+ *
+ * Parses API Platform's default Hydra/JSON-LD collection envelope:
  *
  * ```json
  * {
- *   "count": 100,
- *   "next": "http://api.example.com/items/?page=3",
- *   "previous": "http://api.example.com/items/?page=1",
- *   "results": [...]
+ *   "@context": "/contexts/Book",
+ *   "@type": "hydra:Collection",
+ *   "hydra:totalItems": 48,
+ *   "hydra:member": [...],
+ *   "hydra:view": {
+ *     "@id": "/books?page=3&itemsPerPage=10",
+ *     "hydra:first": "/books?page=1",
+ *     "hydra:previous": "/books?page=2",
+ *     "hydra:next": "/books?page=4",
+ *     "hydra:last": "/books?page=5"
+ *   }
  * }
  * ```
  *
- * DRF emits no `current_page` field in the body, so this strategy
- * **derives** the current page (and the page size) by inspecting the
- * `next` / `previous` URLs:
- *
- * - `previous === null` → current page is **1**.
- * - `previous` set but has no `?page=N` param → DRF omits `page=1` from
- *   URLs when the previous page is the first, so we infer **2**.
- * - `previous` has `?page=N` → current page is **N + 1**.
- *
- * Similarly, `perPage` is parsed from any `?page_size=N` query param on
- * `next` or `previous`, and `lastPage` is computed as
- * `ceil(count / perPage)`. When `perPage` cannot be discovered (e.g. on a
- * single-page response that emits both URLs as `null`), `perPage` and
- * `lastPage` are left undefined.
- *
- * Key paths are resolved through `DrfResponseOptions`, which defaults
- * `data → 'results'`, `total → 'count'`, `nextPageUrl → 'next'`,
- * `prevPageUrl → 'previous'`. The current-page / per-page / last-page
- * paths default to empty strings — the strategy ignores `options` for
- * those slots and uses URL inspection instead.
- *
- * @see https://www.django-rest-framework.org/api-guide/pagination/#pagenumberpagination
+ * The Hydra keys contain colons but no dots, so the inherited
+ * dot-notation resolver traverses them cleanly (`hydra:view.hydra:next`
+ * → `response['hydra:view']['hydra:next']`). The body names no
+ * current-page or page-size field, so both are **derived from the
+ * `hydra:view` URLs**:
+ *
+ * - `currentPage` from the `page` param of the view's `@id` (the
+ *   `path` option slot points there); missing view → page **1**.
+ * - `perPage` from the `itemsPerPage` param of the view's `@id`
+ *   (echoed whenever the request set it — this driver's request
+ *   strategy always does), falling back to the item count of a page
+ *   that has a `hydra:next` successor.
+ * - `lastPage` from the `page` param of `hydra:last`, falling back to
+ *   `ceil(total ÷ perPage)`; a view-less response holding the whole
+ *   collection resolves to 1.
+ *
+ * URLs are typically **relative** (`/books?page=4`) — parsing retries
+ * against a placeholder base, and the links are surfaced as-is on the
+ * collection. JSON:API and HAL serialization formats are out of scope
+ * (use the JSON:API driver for the former).
+ *
+ * @see https://api-platform.com/docs/core/pagination/
  */
-declare class DrfResponseStrategy implements IResponseStrategy {
+declare class ApiPlatformResponseStrategy extends AbstractDotPathResponseStrategy {
     /**
-     * Parse a DRF pagination response into a PaginatedCollection
+     * Parse a Hydra collection response into a PaginatedCollection
      *
      * @param response - The raw API response body
-     * @param options - The response key name configuration
+     * @param options - The response key name configuration (dot-notation paths supported)
      * @returns A typed PaginatedCollection instance
      */
     paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
     /**
-     * Derive the current page number from the `previous` URL
+     * Derive the current page number from the `hydra:view` `@id` URL
      *
-     * - `null` → page 1
-     * - URL without `?page=N` → page 2 (DRF omits `page=1` from URLs)
-     * - URL with `?page=N` → N + 1
+     * Reads the `page` query param; a missing view (pagination disabled
+     * or a single-page collection without a partial view) or a link
+     * without the param resolves to page 1.
      *
-     * @param prevPageUrl - The `previous` link from the DRF response, or null
+     * @param viewUrl - The `hydra:view.@id` URL, or null
      * @returns The current page number
      */
     private _deriveCurrentPage;
     /**
-     * Derive `from` as the 1-indexed offset of the first item on this page
-     *
-     * @param currentPage - The current page number
-     * @param perPage - The page size (may be undefined)
-     * @returns The 1-indexed `from` index, or undefined when perPage is unknown
-     */
-    private _deriveFrom;
-    /**
-     * Derive the last page number as `ceil(total / perPage)`
+     * Derive the last page number
      *
-     * Both inputs must be defined; an empty result set (`total === 0`)
-     * yields `lastPage = 0` which the caller treats as "no useful info"
-     * and skips the sync to `NestService.lastPage`.
+     * Resolution order: the `page` param of `hydra:last`, then
+     * `ceil(total ÷ perPage)`, then 1 for a view-less response that
+     * provably holds the entire non-empty collection.
      *
+     * @param lastPageUrl - The `hydra:view.hydra:last` URL (may be undefined)
+     * @param viewUrl - The `hydra:view.@id` URL, or null
+     * @param data - The items on the current page
      * @param total - The total item count
      * @param perPage - The page size
-     * @returns The last page number, or undefined when either input is missing
+     * @returns The last page number, or undefined when inputs insufficient
      */
     private _deriveLastPage;
     /**
-     * Derive `perPage` by parsing `?page_size=N` from any available URL
+     * Derive `perPage` from the `hydra:view` `@id` URL
      *
-     * Tries `next` first (page 1 always has a `next` URL with `page_size`
-     * if any non-default size was requested), then falls back to
-     * `previous`. Returns undefined when neither URL contains the param —
-     * the consumer is then on a single-page result with the server's
-     * default page size, which is not introspectable from the body alone.
+     * Reads the `itemsPerPage` query param (echoed whenever the request
+     * set it). When absent, a page with a `hydra:next` successor is
+     * necessarily full, so its item count equals the page size.
      *
-     * @param nextPageUrl - The `next` link from the response, or null
-     * @param prevPageUrl - The `previous` link from the response, or null
+     * @param viewUrl - The `hydra:view.@id` URL, or null
+     * @param nextPageUrl - The `hydra:view.hydra:next` URL (may be undefined)
+     * @param data - The items on the current page
      * @returns The page size, or undefined
      */
     private _derivePerPage;
     /**
-     * Derive `to` as the 1-indexed offset of the last item on this page
+     * Extract an integer query parameter from a Hydra URL
      *
-     * Clamped to `total` so the last page does not report past the end.
-     *
-     * @param currentPage - The current page number
-     * @param perPage - The page size (may be undefined)
-     * @param total - The total item count (may be undefined)
-     * @returns The 1-indexed `to` index, or undefined when inputs insufficient
+     * @param url - The URL to parse
+     * @param name - The query-parameter name to look up (e.g. `page`)
+     * @returns The integer value, or undefined
      */
-    private _deriveTo;
+    private _extractNumberParam;
     /**
-     * Extract the `page` query parameter from a DRF pagination URL
+     * Extract a single query parameter from a URL via the WHATWG URL parser
      *
-     * Returns the integer value of `?page=N`, or undefined when the URL is
-     * malformed or has no `page` param (which, by DRF convention, means
-     * page 1 — the caller infers the semantics).
+     * Hydra links are typically **relative** (`/books?page=4`), so parsing
+     * retries against a placeholder base before giving up. Returns
+     * undefined when the URL is unparseable or the parameter is absent.
      *
      * @param url - The URL to parse
-     * @returns The integer page value, or undefined
+     * @param name - The query-parameter name to look up
+     * @returns The raw string value of the parameter, or undefined
      */
-    private _extractPageParam;
+    private _extractQueryParam;
     /**
-     * Extract the `page_size` query parameter from a DRF pagination URL
+     * Derive `from` for a view-less response holding the whole collection
      *
-     * @param url - The URL to parse (or null)
-     * @returns The integer page-size value, or undefined
+     * @param viewUrl - The `hydra:view.@id` URL, or null
+     * @param data - The items on the current page
+     * @param total - The total item count
+     * @returns 1 when the response provably holds all items, undefined otherwise
      */
-    private _extractPageSizeParam;
+    private _wholeSetFrom;
     /**
-     * Extract a single query parameter from a URL via the WHATWG URL parser
+     * Derive `to` for a view-less response holding the whole collection
      *
-     * Returns undefined when the URL is unparseable (relative URL without a
-     * base, or malformed) or when the parameter is absent.
-     *
-     * @param url - The URL to parse
-     * @param name - The query-parameter name to look up
-     * @returns The raw string value of the parameter, or undefined
+     * @param viewUrl - The `hydra:view.@id` URL, or null
+     * @param data - The items on the current page
+     * @param total - The total item count
+     * @returns The item count when the response provably holds all items, undefined otherwise
      */
-    private _extractQueryParam;
+    private _wholeSetTo;
 }
 
 /**
- * Request strategy for the JSON:API driver
- *
- * Generates URIs in the JSON:API format:
- * - Fields: `fields[articles]=title,body&fields[people]=name`
- * - Filters: `filter[status]=active`
- * - Includes: `include=author,comments.author`
- * - Pagination: `page[number]=1&page[size]=15`
- * - Sort: `sort=-created_at,name` (- prefix = DESC)
- *
- * @see https://jsonapi.org/format/
+ * Request strategy for the Directus driver
+ *
+ * Generates URIs in [Directus' query format](https://docs.directus.io/reference/query.html):
+ * - Filters: `filter[field][_eq]=value` (multi-value collapses to `_in`)
+ * - Operator filters: `filter[field][_op]=value` (translated from
+ *   `FilterOperatorEnum` — `BTW`→`_between`, `SW`→`_starts_with`,
+ *   `ILIKE`→`_icontains`, `NOT`→`_neq`/`_nin`, `NULL`→`_null`/`_nnull`)
+ * - Sorts: `sort=-created_at,name` (CSV, `-` prefix = DESC)
+ * - Field selection / relations: a single `fields=` CSV — flat columns
+ *   from `addSelect`, whole relations from `addIncludes` (`rel.*`), and
+ *   column-projected relations from `addEmbedded` (`rel.col1,rel.col2`)
+ * - Search: `search=term` (global full-text search)
+ * - Metadata: a constant `meta=total_count,filter_count` so responses
+ *   carry the totals the response strategy needs
+ * - Pagination (page-based): `limit=N&page=N`
+ *
+ * The `filter` / `sort` / `fields` / `search` / `limit` / `page` keys
+ * honour the existing `QueryBuilderOptions` names (their defaults match
+ * the Directus wire format); `meta` is fixed by the server and lives as
+ * a private static. Directus' `deep[...]` relational query options and
+ * nested relation filtering are out of scope.
+ *
+ * PostgREST-native full-text search operators (`FTS`, `PHFTS`, `PLFTS`,
+ * `WFTS`) throw `UnsupportedFilterOperatorError` — use `search` or the
+ * `CONTAINS` / `ILIKE` operator filters instead.
+ *
+ * @see https://docs.directus.io/reference/query.html
+ * @see https://docs.directus.io/reference/filter-rules.html
  */
-declare class JsonApiRequestStrategy extends AbstractRequestStrategy {
+declare class DirectusRequestStrategy extends AbstractRequestStrategy {
     /**
-     * Filters, sorts, includes, per-model fields — same shape as Spatie
-     * but with bracket-style pagination
+     * Filters, operator filters, sorts, flat select, includes and embedded
+     * (both folding into `fields=`), global search — no per-model fields
+     * (Directus scopes relational projections with dot paths, not a
+     * `fields[model]` map)
      */
     readonly capabilities: IStrategyCapabilities;
     /**
-     * Emit JSON:API-format query-string segments in canonical order:
-     * include → fields → filters → pagination → sort
+     * Directus-native name of the metadata query key
+     *
+     * `meta` has no `QueryBuilderOptions` slot and is fixed by the server,
+     * so it lives as a private static to be visible in one place.
+     */
+    private static readonly _metaKey;
+    /**
+     * Emit Directus-format query-string segments in canonical order:
+     * filter (merged) → sort → fields → search → meta → limit → page
+     *
+     * Simple filters and operator filters share a single `filter` wrapper
+     * so qs emits one ordered, deeply-nested bracket structure rather than
+     * two duplicate top-level `filter[...]` blocks.
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
@@ -1744,17 +2117,31 @@ declare class JsonApiRequestStrategy extends AbstractRequestStrategy {
      */
     protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
     /**
-     * Append per-type field selection in bracket notation
+     * Append the single `fields=` CSV combining flat columns, whole
+     * relations, and column-projected relations
+     *
+     * Flat columns come from `addSelect`; relations from `addIncludes`
+     * emit as `rel.*`; embedded relations from `addEmbedded` emit one
+     * `rel.col` entry per column (or `rel.*` when no columns were given).
+     * A relation present in both folds into the embedded fragment, which
+     * carries the column information. When relations are present but no
+     * flat columns were selected, the flat part defaults to `*` so the
+     * base item's columns are not silently dropped from the projection.
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
-     * @throws Error if the resource is missing from the fields object
-     * @throws UnselectableModelError if a field type is not the resource or in includes
      */
     private _appendFields;
     /**
-     * Append filter parameters in bracket notation: `filter[key]=value`
+     * Append the unified `filter[...]` wrapper combining simple filters
+     * and operator filters
+     *
+     * Both kinds emit into the same nested object under the filter key so
+     * qs produces a single deeply-bracketed block per request. Simple
+     * single-value filters fold to `_eq`; simple multi-value filters fold
+     * to `_in` (CSV). Operator filters then merge into the same per-field
+     * map, potentially co-existing with a simple filter on the same field.
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
@@ -1762,523 +2149,1989 @@ declare class JsonApiRequestStrategy extends AbstractRequestStrategy {
      */
     private _appendFilters;
     /**
-     * Append include parameter as `include=author,comments.author`
+     * Append the limit parameter
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendIncludes;
+    private _appendLimit;
     /**
-     * Append JSON:API bracket pagination as `page[number]=1&page[size]=15`
+     * Append the constant `meta=total_count,filter_count` parameter
      *
-     * `qs.stringify` already returns the two segments joined with `&`, so we
-     * push the whole string as one accumulator entry — `_join` will glue
-     * it onto the rest with the same separator.
+     * Always emitted: the Directus response strategy reads the totals from
+     * `meta`, which the server only includes when the request asks for it.
+     *
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendMeta;
+    /**
+     * Append the page parameter
+     *
+     * Directus pages are 1-indexed, matching the library state directly.
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendPagination;
+    private _appendPage;
     /**
-     * Append sort parameter as `sort=-field1,field2` (`-` prefix = DESC)
+     * Append the `search=` global full-text search parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSearch;
+    /**
+     * Append the `sort=-created_at,name` CSV parameter
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
     private _appendSort;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into Directus'
+     * `_operator → value` payload shape
+     *
+     * The mapping is library-canonical → Directus-native:
+     * - `EQ`/`GT`/`GTE`/`LT`/`LTE` → `_eq`/`_gt`/`_gte`/`_lt`/`_lte`
+     * - `CONTAINS` → `_contains`; `ILIKE` → `_icontains` (case-insensitive)
+     * - `SW` → `_starts_with`
+     * - `IN` → `_in` (CSV)
+     * - `BTW` → `_between` with `min,max` (arity-checked)
+     * - `NOT` → `_neq` (single value) / `_nin` (multi-value, CSV)
+     * - `NULL` → `_null=true` (when value is `true`) / `_nnull=true` (when
+     *   value is `false`); arity- and type-checked
+     *
+     * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
+     * `WFTS`) have no Directus equivalent and throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns A `{ _operator: value }` payload ready to merge under
+     * `filter[field]`
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator is a
+     * PostgREST-only FTS variant
+     */
+    private _formatOperatorPayload;
 }
 
 /**
- * Base class for response strategies whose pagination metadata lives at
- * dot-notation paths inside the response body
+ * Response strategy for the Directus driver
  *
- * JSON:API and NestJS share an identical body-traversal algorithm: the
- * total / current-page / etc. live at nested keys like `meta.total`, and
- * `from`/`to` are either present directly or must be derived from
- * `currentPage` × `perPage`. Both strategies were duplicating this
- * verbatim before this base existed; concrete classes now extend and
- * provide only the docstring describing their driver's specific path
- * conventions (see `JsonApiResponseStrategy`, `NestjsResponseStrategy`).
+ * Parses Directus collection responses (with `meta=total_count,filter_count`
+ * requested, which the request strategy always does):
  *
- * Drivers whose pagination metadata travels via HTTP headers (PostgREST)
- * or whose body has a flat shape with no dot paths (Laravel, Spatie) do
- * not extend this class — they implement `IResponseStrategy` directly.
+ * ```json
+ * {
+ *   "data": [{ "id": 1, "title": "Hello" }],
+ *   "meta": { "total_count": 48, "filter_count": 12 }
+ * }
+ * ```
+ *
+ * The default `total` path is `meta.filter_count` — the number of items
+ * matching the current filter, which is the relevant total for paging a
+ * filtered collection (`meta.total_count` ignores filters; point the
+ * `total` path at it via `IPaginationConfig` if that is what you want).
+ *
+ * The envelope carries **no current-page or page-size field**, so:
+ *
+ * - `currentPage` falls back to **1** unless a `currentPage` path is
+ *   configured and resolves (only guaranteed correct for single-page
+ *   results — track the requested page in your own state for multi-page
+ *   UIs).
+ * - `perPage` resolves only when a `perPage` path is configured.
+ * - `lastPage` is `ceil(total ÷ perPage)` when both are known; on a
+ *   response that provably holds the whole filtered set it resolves
+ *   to 1.
+ *
+ * Every key path is overridable via `IPaginationConfig` (dot notation
+ * supported), so custom wrappers that do include paging fields map
+ * without subclassing.
+ *
+ * @see https://docs.directus.io/reference/query.html#meta
  */
-declare abstract class AbstractDotPathResponseStrategy implements IResponseStrategy {
+declare class DirectusResponseStrategy extends AbstractDotPathResponseStrategy {
     /**
-     * Parse a nested-envelope pagination response into a PaginatedCollection
+     * Parse a Directus collection response into a PaginatedCollection
      *
-     * @param response - The raw API response object
+     * @param response - The raw API response body
      * @param options - The response key name configuration (dot-notation paths supported)
      * @returns A typed PaginatedCollection instance
      */
     paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
     /**
-     * Resolve a value from a response object using a dot-notation path
+     * Derive the last page number
      *
-     * Supports both flat keys (`'data'`) and nested paths (`'meta.totalItems'`).
+     * Resolution order: the configured `lastPage` path, then
+     * `ceil(total ÷ perPage)` when both are known, then 1 when the
+     * response provably holds the entire non-empty filtered set.
      *
      * @param response - The raw response object
-     * @param path - The dot-notation path to resolve
-     * @returns The resolved value, or undefined if any segment is missing
+     * @param options - The response key name configuration
+     * @param data - The items on the current page
+     * @param total - The total item count
+     * @param perPage - The page size
+     * @returns The last page number, or undefined when inputs insufficient
      */
-    protected resolve(response: Record<string, any>, path: string): unknown;
+    private _deriveLastPage;
     /**
-     * Resolve the "from" index value
+     * Derive `from` for a response that holds the whole filtered set
      *
-     * If `options.from` resolves to a value in the response, use it.
-     * Otherwise compute `(currentPage - 1) * perPage + 1` when both are known.
-     *
-     * @param response - The raw response object
-     * @param options - The response key name configuration
-     * @param currentPage - The current page number
-     * @param perPage - The number of items per page
-     * @returns The "from" index, or `undefined` when neither path nor inputs suffice
+     * @param data - The items on the current page
+     * @param total - The total item count
+     * @returns 1 when the page provably holds all items, undefined otherwise
      */
-    protected resolveFrom(response: Record<string, any>, options: ResponseOptions, currentPage: number, perPage?: number): number | undefined;
+    private _singlePageFrom;
     /**
-     * Resolve the "to" index value
-     *
-     * If `options.to` resolves to a value in the response, use it.
-     * Otherwise compute `Math.min(currentPage * perPage, total)` when all
-     * three are known.
+     * Derive `to` for a response that holds the whole filtered set
      *
-     * @param response - The raw response object
-     * @param options - The response key name configuration
-     * @param currentPage - The current page number
-     * @param perPage - The number of items per page
-     * @param total - The total number of items
-     * @returns The "to" index, or `undefined` when neither path nor inputs suffice
+     * @param data - The items on the current page
+     * @param total - The total item count
+     * @returns The item count when the page provably holds all items, undefined otherwise
      */
-    protected resolveTo(response: Record<string, any>, options: ResponseOptions, currentPage: number, perPage?: number, total?: number): number | undefined;
+    private _singlePageTo;
 }
 
 /**
- * Response strategy for the JSON:API driver
- *
- * Parses JSON:API pagination responses:
- * ```json
- * {
- *   "data": [...],
- *   "meta": {
- *     "current-page": 1,
- *     "per-page": 10,
- *     "total": 100,
- *     "page-count": 10,
- *     "from": 1,
- *     "to": 10
- *   },
- *   "links": {
- *     "first": "url",
- *     "prev": "url",
- *     "next": "url",
- *     "last": "url"
- *   }
- * }
- * ```
+ * Request strategy for the Django REST Framework (DRF) driver
  *
- * Default key paths are configured in `JsonApiResponseOptions`. The
- * traversal algorithm (dot-notation resolution + computed `from`/`to`) is
- * inherited from `AbstractDotPathResponseStrategy`; this class exists so
- * `DriverEnum.JSON_API` resolves to a distinct identity at the DI layer
- * even though the parsing logic is shared with NestJS.
+ * Generates URIs in DRF's flat query-parameter format, augmented by
+ * django-filter's double-underscore lookup convention:
  *
- * @see https://jsonapi.org/format/
- */
-declare class JsonApiResponseStrategy extends AbstractDotPathResponseStrategy {
-}
-
-/**
- * Request strategy for the Laravel (pagination-only) driver
+ * - Simple filters: `field=value` (multi-value collapses to `field__in=v1,v2`)
+ * - Operator filters: `field__lookup=value` (translated from
+ *   `FilterOperatorEnum` — `GTE`→`__gte`, `ILIKE`→`__icontains`,
+ *   `BTW`→`__range`, `NULL`→`__isnull`, etc.)
+ * - Ordering: `ordering=-field1,field2` (`-` prefix = DESC)
+ * - Search: `search=term` (DRF's SearchFilter)
+ * - Pagination: `page=N&page_size=M` (PageNumberPagination)
  *
- * Generates simple pagination URIs:
- * - `/{resource}?limit=N&page=N`
+ * `ordering` and `page_size` are DRF-idiomatic param names and are
+ * intentionally not configurable via `QueryBuilderOptions` — same
+ * precedent as PostgREST's `order` and `offset`. PostgREST's full-text
+ * search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) and the generic
+ * `NOT` have no django-filter equivalent and throw
+ * `UnsupportedFilterOperatorError`.
  *
- * Filters, sorts, fields, includes, search, and select in state are ignored.
+ * @see https://www.django-rest-framework.org/api-guide/filtering/
+ * @see https://django-filter.readthedocs.io/
  */
-declare class LaravelRequestStrategy extends AbstractRequestStrategy {
+declare class DrfRequestStrategy extends AbstractRequestStrategy {
     /**
-     * Pagination-only driver — no filtering, sorting, or column selection
+     * Simple filters, operator filters (django-filter lookups), sorts, and
+     * global search — no per-model fields, no relation includes, no flat
+     * select (django-restql adds it but is not core DRF)
      */
     readonly capabilities: IStrategyCapabilities;
     /**
-     * Emit only the pagination params; filters/sorts/etc. are ignored
+     * DRF-native names of the three hardcoded query keys
+     *
+     * `ordering` and `page_size` are DRF/django-filter conventions and are
+     * intentionally not configurable through `QueryBuilderOptions`. `page`
+     * matches the default `QueryBuilderOptions.page`, and `search` matches
+     * the default `QueryBuilderOptions.search`, so those flow through the
+     * shared options object.
+     */
+    private static readonly _orderingKey;
+    private static readonly _pageSizeKey;
+    /**
+     * Emit DRF-format query-string segments in canonical order:
+     * filters → operator filters → ordering → search → pagination
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
-     * @returns The two pagination query-string fragments
+     * @returns Ordered query-string fragments
      */
     protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
-}
-
-/**
- * Base class for response strategies whose pagination metadata is a flat
- * key-value envelope on the response body
- *
- * Laravel's stock pagination and Spatie's `QueryBuilder` both emit the
- * same flat shape — `{ data, current_page, total, per_page, from, to,
- * next_page_url, prev_page_url, first_page_url, last_page, last_page_url
- * }` — and both response strategies were duplicating the byte-identical
- * `new PaginatedCollection(response[options.X], ...)` body before this
- * base existed. Concrete classes now extend and provide only the
- * docstring describing their driver's specific shape (see
- * `LaravelResponseStrategy`, `SpatieResponseStrategy`).
- *
- * Drivers whose pagination metadata is a nested envelope (JSON:API,
+    /**
+     * Append simple filter parameters
+     *
+     * Single-value filters emit `field=value` (django-filter's default
+     * exact match). Multi-value filters collapse to django-filter's
+     * `field__in=v1,v2,v3` form, which is the idiomatic way to express
+     * "value in list" in DRF.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append operator-filter parameters as `field__lookup=value`
+     *
+     * Maps each `FilterOperatorEnum` value to a django-filter lookup
+     * suffix. `BTW` expands to `field__range=min,max`; `NULL` emits
+     * `field__isnull=true|false`; the generic `NOT` and PostgREST-only
+     * FTS operators are unsupported.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * django-filter equivalent
+     */
+    private _appendOperatorFilters;
+    /**
+     * Append `ordering=-field1,field2` (django's `-` prefix = DESC)
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendOrdering;
+    /**
+     * Append `page=N&page_size=M`
+     *
+     * `page` follows `options.page` (default `page`, matching DRF); the
+     * size key is hardcoded to DRF's idiomatic `page_size`.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPagination;
+    /**
+     * Append `search=term` when a search term is set
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSearch;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into a
+     * `[suffix, serializedValue]` pair
+     *
+     * The suffix is appended to the field name with a `__` separator on the
+     * wire side (`field__gte=18`). The empty string means "no suffix" —
+     * django-filter's implicit `exact` lookup.
+     *
+     * Mapping:
+     * - `EQ` → `''` (no suffix; default exact match)
+     * - `GT`/`GTE`/`LT`/`LTE`/`CONTAINS` → identity (lowercased name)
+     * - `ILIKE` → `icontains` (closest case-insensitive analog)
+     * - `IN` → `in` with comma-joined values
+     * - `SW` → `startswith`
+     * - `BTW` → `range` with comma-joined `[min, max]` (arity-checked)
+     * - `NULL` → `isnull` with boolean value (arity- and type-checked)
+     * - `NOT` → `UnsupportedFilterOperatorError` (no generic negation in
+     *   django-filter; use `__exclude` on the queryset instead)
+     * - `FTS`/`PLFTS`/`PHFTS`/`WFTS` → `UnsupportedFilterOperatorError`
+     *
+     * @param filter - The operator filter to translate
+     * @returns A `[lookupSuffix, serializedValue]` tuple
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * django-filter equivalent
+     */
+    private _formatOperatorPayload;
+}
+
+/**
+ * Response strategy for the Django REST Framework (DRF) driver
+ *
+ * Parses DRF `PageNumberPagination` responses:
+ *
+ * ```json
+ * {
+ *   "count": 100,
+ *   "next": "http://api.example.com/items/?page=3",
+ *   "previous": "http://api.example.com/items/?page=1",
+ *   "results": [...]
+ * }
+ * ```
+ *
+ * DRF emits no `current_page` field in the body, so this strategy
+ * **derives** the current page (and the page size) by inspecting the
+ * `next` / `previous` URLs:
+ *
+ * - `previous === null` → current page is **1**.
+ * - `previous` set but has no `?page=N` param → DRF omits `page=1` from
+ *   URLs when the previous page is the first, so we infer **2**.
+ * - `previous` has `?page=N` → current page is **N + 1**.
+ *
+ * Similarly, `perPage` is parsed from any `?page_size=N` query param on
+ * `next` or `previous`, and `lastPage` is computed as
+ * `ceil(count / perPage)`. When `perPage` cannot be discovered (e.g. on a
+ * single-page response that emits both URLs as `null`), `perPage` and
+ * `lastPage` are left undefined.
+ *
+ * Key paths are resolved through `DrfResponseOptions`, which defaults
+ * `data → 'results'`, `total → 'count'`, `nextPageUrl → 'next'`,
+ * `prevPageUrl → 'previous'`. The current-page / per-page / last-page
+ * paths default to empty strings — the strategy ignores `options` for
+ * those slots and uses URL inspection instead.
+ *
+ * @see https://www.django-rest-framework.org/api-guide/pagination/#pagenumberpagination
+ */
+declare class DrfResponseStrategy implements IResponseStrategy {
+    /**
+     * Parse a DRF pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response body
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+    /**
+     * Derive the current page number from the `previous` URL
+     *
+     * - `null` → page 1
+     * - URL without `?page=N` → page 2 (DRF omits `page=1` from URLs)
+     * - URL with `?page=N` → N + 1
+     *
+     * @param prevPageUrl - The `previous` link from the DRF response, or null
+     * @returns The current page number
+     */
+    private _deriveCurrentPage;
+    /**
+     * Derive `from` as the 1-indexed offset of the first item on this page
+     *
+     * @param currentPage - The current page number
+     * @param perPage - The page size (may be undefined)
+     * @returns The 1-indexed `from` index, or undefined when perPage is unknown
+     */
+    private _deriveFrom;
+    /**
+     * Derive the last page number as `ceil(total / perPage)`
+     *
+     * Both inputs must be defined; an empty result set (`total === 0`)
+     * yields `lastPage = 0` which the caller treats as "no useful info"
+     * and skips the sync to `NestService.lastPage`.
+     *
+     * @param total - The total item count
+     * @param perPage - The page size
+     * @returns The last page number, or undefined when either input is missing
+     */
+    private _deriveLastPage;
+    /**
+     * Derive `perPage` by parsing `?page_size=N` from any available URL
+     *
+     * Tries `next` first (page 1 always has a `next` URL with `page_size`
+     * if any non-default size was requested), then falls back to
+     * `previous`. Returns undefined when neither URL contains the param —
+     * the consumer is then on a single-page result with the server's
+     * default page size, which is not introspectable from the body alone.
+     *
+     * @param nextPageUrl - The `next` link from the response, or null
+     * @param prevPageUrl - The `previous` link from the response, or null
+     * @returns The page size, or undefined
+     */
+    private _derivePerPage;
+    /**
+     * Derive `to` as the 1-indexed offset of the last item on this page
+     *
+     * Clamped to `total` so the last page does not report past the end.
+     *
+     * @param currentPage - The current page number
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `to` index, or undefined when inputs insufficient
+     */
+    private _deriveTo;
+    /**
+     * Extract the `page` query parameter from a DRF pagination URL
+     *
+     * Returns the integer value of `?page=N`, or undefined when the URL is
+     * malformed or has no `page` param (which, by DRF convention, means
+     * page 1 — the caller infers the semantics).
+     *
+     * @param url - The URL to parse
+     * @returns The integer page value, or undefined
+     */
+    private _extractPageParam;
+    /**
+     * Extract the `page_size` query parameter from a DRF pagination URL
+     *
+     * @param url - The URL to parse (or null)
+     * @returns The integer page-size value, or undefined
+     */
+    private _extractPageSizeParam;
+    /**
+     * Extract a single query parameter from a URL via the WHATWG URL parser
+     *
+     * Returns undefined when the URL is unparseable (relative URL without a
+     * base, or malformed) or when the parameter is absent.
+     *
+     * @param url - The URL to parse
+     * @param name - The query-parameter name to look up
+     * @returns The raw string value of the parameter, or undefined
+     */
+    private _extractQueryParam;
+}
+
+/**
+ * Request strategy for the FeathersJS driver
+ *
+ * Generates URIs in [Feathers' common database adapter query syntax](https://feathersjs.com/api/databases/querying):
+ * - Filters: `field=value` (exact match); multi-value folds to `$in`
+ *   (`field[$in][0]=v1&field[$in][1]=v2`)
+ * - Operator filters: `field[$op]=value` (translated from
+ *   `FilterOperatorEnum` — `BTW`→`$gte`+`$lte` pair, `NOT`→`$ne`/`$nin`)
+ * - Sorts: `$sort[field]=1` (ASC) / `$sort[field]=-1` (DESC)
+ * - Flat field selection: `$select[0]=col1&$select[1]=col2`
+ * - Pagination (offset-based): `$limit=N&$skip=M` with
+ *   `skip = (page - 1) × limit`
+ *
+ * The dollar-prefixed query keys (`$limit`, `$skip`, `$sort`, `$select`)
+ * are fixed by the Feathers adapter-commons parser and intentionally not
+ * configurable through `QueryBuilderOptions`; they live as private
+ * statics so they are visible in one place.
+ *
+ * Feathers' core adapter syntax has no relation includes, no per-model
+ * field selection, and no global search — the corresponding fluent
+ * methods throw the matching `Unsupported*Error`. `CONTAINS` / `ILIKE` /
+ * `SW` (LIKE-style matching is adapter-specific, not core), `NULL` (no
+ * null-check operator on the wire), and the PostgREST-native full-text
+ * operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://feathersjs.com/api/databases/querying
+ */
+declare class FeathersRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, sorts, flat field selection (`select`) —
+     * no per-model fields, no includes, no global search, no embedded
+     * resources
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Feathers-native names of the four hardcoded query keys
+     *
+     * The dollar prefix marks adapter-commons system params apart from
+     * filter fields; these keys are fixed by the server and intentionally
+     * not configurable through `QueryBuilderOptions`.
+     */
+    private static readonly _limitKey;
+    private static readonly _selectKey;
+    private static readonly _skipKey;
+    private static readonly _sortKey;
+    /**
+     * Emit Feathers-format query-string segments in canonical order:
+     * filters → operator filters → $sort → $select → $limit → $skip
+     *
+     * @param state - The current query builder state
+     * @param _options - The query parameter key name configuration (unused;
+     * Feathers' system keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, _options: QueryBuilderOptions): string[];
+    /**
+     * Append simple filter parameters
+     *
+     * A single value emits the bare exact-match form (`field=value`);
+     * multiple values fold to the `$in` list
+     * (`field[$in][0]=v1&field[$in][1]=v2`).
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append explicit operator filters in the `field[$op]=value` syntax
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendOperatorFilters;
+    /**
+     * Append the `$limit` / `$skip` pagination pair
+     *
+     * Feathers paginates by offset, so the 1-based page number from state
+     * converts to `skip = (page - 1) × limit`.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPagination;
+    /**
+     * Append the `$select[0]=col1&$select[1]=col2` array from the flat
+     * select state
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSelect;
+    /**
+     * Append the `$sort[field]=1|-1` map
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSort;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into Feathers'
+     * `$operator → value` payload shape (or a bare primitive for `EQ`)
+     *
+     * The mapping is library-canonical → Feathers-native:
+     * - `EQ` → bare `field=value` (no operator wrapper)
+     * - `GT`/`GTE`/`LT`/`LTE` → `$gt` / `$gte` / `$lt` / `$lte`
+     * - `IN` → `$in` (array)
+     * - `BTW` → `$gte` + `$lte` pair in one payload (arity-checked)
+     * - `NOT` → `$ne` (single value) / `$nin` (multi-value)
+     *
+     * `CONTAINS`, `ILIKE`, and `SW` (LIKE-style matching is
+     * adapter-specific in Feathers, not part of the common syntax),
+     * `NULL` (no null-check operator), and PostgREST's full-text-search
+     * operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns A `{ $operator: value }` payload ready to nest under
+     * `field[...]`, or a bare primitive for `EQ`
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * Feathers equivalent
+     */
+    private _formatOperatorPayload;
+}
+
+/**
+ * Response strategy for the FeathersJS driver
+ *
+ * Parses the paginated envelope emitted by Feathers database adapters:
+ *
+ * ```json
+ * {
+ *   "total": 48,
+ *   "limit": 10,
+ *   "skip": 10,
+ *   "data": [...]
+ * }
+ * ```
+ *
+ * The envelope is offset-based — no page number, no navigation URLs —
+ * so position derives arithmetically:
+ *
+ * - `currentPage` is `skip / limit + 1` (integer division; a zero or
+ *   missing `limit` falls back to page **1**).
+ * - `perPage` comes straight from `limit`; `lastPage` is
+ *   `ceil(total / limit)`.
+ * - `from`/`to` are 1-indexed offsets derived from `skip` and the item
+ *   count of the current page (`from = skip + 1`,
+ *   `to = skip + data.length`); both stay `undefined` on an empty page.
+ *
+ * The `data` / `total` / `limit` key names are configurable through
+ * `FeathersResponseOptions`; the `skip` key is fixed by the Feathers
+ * envelope and lives as a private static.
+ *
+ * @see https://feathersjs.com/api/databases/common#pagination
+ */
+declare class FeathersResponseStrategy implements IResponseStrategy {
+    /**
+     * Feathers-native name of the offset key
+     *
+     * Fixed by the adapter envelope; read for page derivation only.
+     */
+    private static readonly _skipKey;
+    /**
+     * Parse a Feathers pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response body
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+}
+
+/**
+ * Request strategy for the JSON:API driver
+ *
+ * Generates URIs in the JSON:API format:
+ * - Fields: `fields[articles]=title,body&fields[people]=name`
+ * - Filters: `filter[status]=active`
+ * - Includes: `include=author,comments.author`
+ * - Pagination: `page[number]=1&page[size]=15`
+ * - Sort: `sort=-created_at,name` (- prefix = DESC)
+ *
+ * @see https://jsonapi.org/format/
+ */
+declare class JsonApiRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, sorts, includes, per-model fields — same shape as Spatie
+     * but with bracket-style pagination
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Emit JSON:API-format query-string segments in canonical order:
+     * include → fields → filters → pagination → sort
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+    /**
+     * Append per-type field selection in bracket notation
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     * @throws Error if the resource is missing from the fields object
+     * @throws UnselectableModelError if a field type is not the resource or in includes
+     */
+    private _appendFields;
+    /**
+     * Append filter parameters in bracket notation: `filter[key]=value`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append include parameter as `include=author,comments.author`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendIncludes;
+    /**
+     * Append JSON:API bracket pagination as `page[number]=1&page[size]=15`
+     *
+     * `qs.stringify` already returns the two segments joined with `&`, so we
+     * push the whole string as one accumulator entry — `_join` will glue
+     * it onto the rest with the same separator.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPagination;
+    /**
+     * Append sort parameter as `sort=-field1,field2` (`-` prefix = DESC)
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSort;
+}
+
+/**
+ * Response strategy for the JSON:API driver
+ *
+ * Parses JSON:API pagination responses:
+ * ```json
+ * {
+ *   "data": [...],
+ *   "meta": {
+ *     "current-page": 1,
+ *     "per-page": 10,
+ *     "total": 100,
+ *     "page-count": 10,
+ *     "from": 1,
+ *     "to": 10
+ *   },
+ *   "links": {
+ *     "first": "url",
+ *     "prev": "url",
+ *     "next": "url",
+ *     "last": "url"
+ *   }
+ * }
+ * ```
+ *
+ * Default key paths are configured in `JsonApiResponseOptions`. The
+ * traversal algorithm (dot-notation resolution + computed `from`/`to`) is
+ * inherited from `AbstractDotPathResponseStrategy`; this class exists so
+ * `DriverEnum.JSON_API` resolves to a distinct identity at the DI layer
+ * even though the parsing logic is shared with NestJS.
+ *
+ * @see https://jsonapi.org/format/
+ */
+declare class JsonApiResponseStrategy extends AbstractDotPathResponseStrategy {
+}
+
+/**
+ * Request strategy for the json-server driver
+ *
+ * Generates URIs in [json-server's](https://github.com/typicode/json-server)
+ * query format — the de-facto standard mock REST API for prototyping:
+ * - Filters: `field=value` (exact, no operator); multi-value folds to the
+ *   `in` list (`field:in=v1,v2`)
+ * - Operator filters: colon syntax `field:op=value` — see the mapping on
+ *   `_formatOperatorSegments`
+ * - Sorts: `_sort=-views,title` (CSV, `-` prefix = DESC)
+ * - Search: `q=term` (full-text search)
+ * - Pagination: `_page=N&_per_page=M`
+ *
+ * The underscore-prefixed system params (`_page`, `_per_page`, `_sort`)
+ * and the `q` search key are fixed by the server and intentionally not
+ * configurable through `QueryBuilderOptions`; they live as private
+ * statics so they are visible in one place.
+ *
+ * json-server has no per-model field selection, no relation includes,
+ * no column projection — the corresponding fluent methods throw the
+ * matching `Unsupported*Error`. `ILIKE` (no case-insensitive variant),
+ * `NULL` (no null check), and the PostgREST-native full-text operators
+ * (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://github.com/typicode/json-server
+ */
+declare class JsonServerRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, sorts, global search — no per-model
+     * fields, no includes, no flat select, no embedded resources
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * json-server-native names of the four hardcoded query keys
+     *
+     * The underscore prefix marks system params apart from filter fields;
+     * these keys are fixed by the server and intentionally not
+     * configurable through `QueryBuilderOptions`.
+     */
+    private static readonly _pageKey;
+    private static readonly _perPageKey;
+    private static readonly _qKey;
+    private static readonly _sortKey;
+    /**
+     * Emit json-server-format query-string segments in canonical order:
+     * filters → operator filters → _sort → q → _page → _per_page
+     *
+     * @param state - The current query builder state
+     * @param _options - The query parameter key name configuration (unused;
+     * json-server's system keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, _options: QueryBuilderOptions): string[];
+    /**
+     * Append simple filter parameters
+     *
+     * A single value emits the bare exact-match form (`field=value`);
+     * multiple values fold to the `in` list (`field:in=v1,v2`).
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append explicit operator filters in the colon syntax
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendOperatorFilters;
+    /**
+     * Append the _page parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPage;
+    /**
+     * Append the _per_page parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPerPage;
+    /**
+     * Append the `q=` full-text search parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSearch;
+    /**
+     * Append the `_sort=-views,title` CSV parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSort;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into one or more
+     * json-server `field:op=value` segments
+     *
+     * The mapping is library-canonical → json-server-native:
+     * - `EQ` → `:eq`; `GT`/`GTE`/`LT`/`LTE` → `:gt` / `:gte` / `:lt` / `:lte`
+     * - `CONTAINS` → `:contains`
+     * - `SW` → `:startsWith`
+     * - `IN` → `:in` (CSV)
+     * - `BTW` → **two** AND-ed segments (`field:gte=min` and
+     *   `field:lte=max`, arity-checked)
+     * - `NOT` → `:ne` — one segment per value, AND-ed
+     *
+     * `ILIKE` (json-server has no case-insensitive variant), `NULL` (no
+     * null-check operator), and PostgREST's full-text-search operators
+     * (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns One or more `field:op=value` query-string segments
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * json-server equivalent
+     */
+    private _formatOperatorSegments;
+}
+
+/**
+ * Response strategy for the json-server driver
+ *
+ * Parses json-server v1 paginated responses:
+ *
+ * ```json
+ * {
+ *   "first": 1,
+ *   "prev": null,
+ *   "next": 2,
+ *   "last": 5,
+ *   "pages": 5,
+ *   "items": 48,
+ *   "data": [...]
+ * }
+ * ```
+ *
+ * Uniquely among the drivers, `first` / `prev` / `next` / `last` are
+ * **page numbers**, not URLs — so the navigation-URL slots on
+ * `PaginatedCollection` stay `undefined` and the strategy instead uses
+ * the numbers to derive position:
+ *
+ * - `currentPage` is `prev + 1` (`prev === null` → page **1**).
+ * - `perPage` is the item count of the current page whenever `next` is
+ *   set (a page with a successor is necessarily full); on the last page
+ *   of a multi-page set it is not introspectable and stays `undefined`.
+ * - `lastPage` comes straight from `pages`; `from`/`to` derive from
+ *   `currentPage` × `perPage` on full pages, or count back from the
+ *   total on the last page (`from = total - items + 1`, `to = total`).
+ *
+ * The `data` / `items` / `pages` key paths are configurable through
+ * `JsonServerResponseOptions`; the `prev` / `next` keys are fixed by the
+ * json-server envelope and live as private statics.
+ *
+ * @see https://github.com/typicode/json-server
+ */
+declare class JsonServerResponseStrategy implements IResponseStrategy {
+    /**
+     * json-server-native names of the page-number navigation keys
+     *
+     * Fixed by the v1 envelope; read for derivation only and never
+     * surfaced as URLs.
+     */
+    private static readonly _nextKey;
+    private static readonly _prevKey;
+    /**
+     * Parse a json-server pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response body
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+    /**
+     * Derive `from` as the 1-indexed offset of the first item on this page
+     *
+     * Computed from `currentPage` × `perPage` on full pages; on the last
+     * page (no `next`) it counts back from the total
+     * (`total - items + 1`), which also covers single-page responses.
+     *
+     * @param data - The items on the current page
+     * @param currentPage - The current page number
+     * @param next - The next page number, or null
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `from` index, or undefined when inputs insufficient
+     */
+    private _deriveFrom;
+    /**
+     * Derive `perPage` from the current page's item count
+     *
+     * A page with a `next` successor is necessarily full, so its item
+     * count equals the page size. Without a successor the page may be
+     * partial and the size is not introspectable from the body alone.
+     *
+     * @param next - The next page number, or null
+     * @param data - The items on the current page
+     * @returns The page size, or undefined
+     */
+    private _derivePerPage;
+    /**
+     * Derive `to` as the 1-indexed offset of the last item on this page
+     *
+     * Clamped to `total` so the last page does not report past the end;
+     * on the last page (no `next`) it is simply the total.
+     *
+     * @param data - The items on the current page
+     * @param currentPage - The current page number
+     * @param next - The next page number, or null
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `to` index, or undefined when inputs insufficient
+     */
+    private _deriveTo;
+}
+
+/**
+ * Request strategy for the Laravel (pagination-only) driver
+ *
+ * Generates simple pagination URIs:
+ * - `/{resource}?limit=N&page=N`
+ *
+ * Filters, sorts, fields, includes, search, and select in state are ignored.
+ */
+declare class LaravelRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Pagination-only driver — no filtering, sorting, or column selection
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Emit only the pagination params; filters/sorts/etc. are ignored
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The two pagination query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+}
+
+/**
+ * Base class for response strategies whose pagination metadata is a flat
+ * key-value envelope on the response body
+ *
+ * Laravel's stock pagination and Spatie's `QueryBuilder` both emit the
+ * same flat shape — `{ data, current_page, total, per_page, from, to,
+ * next_page_url, prev_page_url, first_page_url, last_page, last_page_url
+ * }` — and both response strategies were duplicating the byte-identical
+ * `new PaginatedCollection(response[options.X], ...)` body before this
+ * base existed. Concrete classes now extend and provide only the
+ * docstring describing their driver's specific shape (see
+ * `LaravelResponseStrategy`, `SpatieResponseStrategy`).
+ *
+ * Drivers whose pagination metadata is a nested envelope (JSON:API,
  * NestJS, Strapi) extend `AbstractDotPathResponseStrategy` instead.
  * Drivers whose metadata comes from HTTP headers (PostgREST) or is
  * derived from response URLs (DRF) implement `IResponseStrategy`
  * directly.
  */
-declare abstract class AbstractFlatResponseStrategy implements IResponseStrategy {
+declare abstract class AbstractFlatResponseStrategy implements IResponseStrategy {
+    /**
+     * Parse a flat-envelope pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+}
+
+/**
+ * Response strategy for the Laravel (pagination-only) driver
+ *
+ * Parses flat Laravel pagination responses:
+ * ```json
+ * {
+ *   "data": [...],
+ *   "current_page": 1,
+ *   "total": 100,
+ *   "per_page": 15,
+ *   "from": 1,
+ *   "to": 15,
+ *   "next_page_url": "...",
+ *   "prev_page_url": "...",
+ *   "first_page_url": "...",
+ *   "last_page": 7,
+ *   "last_page_url": "..."
+ * }
+ * ```
+ *
+ * The traversal algorithm (flat `response[options.X]` lookups) is
+ * inherited from `AbstractFlatResponseStrategy`; this class exists so
+ * `DriverEnum.LARAVEL` resolves to a distinct identity at the DI layer
+ * even though the parsing logic is shared with Spatie.
+ */
+declare class LaravelResponseStrategy extends AbstractFlatResponseStrategy {
+}
+
+/**
+ * Request strategy for the NestJS (nestjs-paginate) driver
+ *
+ * Generates URIs in the NestJS paginate format:
+ * - Simple filters: `filter.field=value`
+ * - Operator filters: `filter.field=$operator:value`
+ * - Sorts: `sortBy=field1:DESC,field2:ASC`
+ * - Select: `select=col1,col2`
+ * - Search: `search=term`
+ * - Pagination: `limit=N&page=N`
+ *
+ * @see https://github.com/ppetzold/nestjs-paginate
+ */
+declare class NestjsRequestStrategy extends AbstractRequestStrategy {
     /**
-     * Parse a flat-envelope pagination response into a PaginatedCollection
+     * Filters, operator filters, sorts, flat select, global search — no
+     * per-model fields, no includes
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Validate that the given limit is accepted by nestjs-paginate
+     *
+     * Accepts any integer `>= 1` as a page size, plus `-1` which nestjs-paginate
+     * interprets as "fetch all items" (server must opt-in via `maxLimit: -1`).
+     *
+     * @param limit - The limit value to validate
+     * @throws {InvalidLimitError} If the value is not an integer, or is 0, or is a negative number other than -1
+     */
+    validateLimit(limit: number): void;
+    /**
+     * Emit NestJS-format query-string segments in canonical order:
+     * filters → operator filters → sortBy → select → search → limit → page
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+    /**
+     * Append simple filter parameters as `filter.field=value1,value2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append the limit parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendLimit;
+    /**
+     * Append operator-filter parameters as `filter.field=$op:value`
+     *
+     * Groups by field; multi-value operators ($in, $btw) join values with commas.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendOperatorFilters;
+    /**
+     * Append the page parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPage;
+    /**
+     * Append the search parameter as `search=term`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSearch;
+    /**
+     * Append the select parameter as `select=col1,col2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSelect;
+    /**
+     * Append sort parameter as `sortBy=field1:DESC,field2:ASC`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSort;
+}
+
+/**
+ * Response strategy for the NestJS (nestjs-paginate) driver
+ *
+ * Parses nested NestJS pagination responses:
+ * ```json
+ * {
+ *   "data": [...],
+ *   "meta": {
+ *     "currentPage": 1,
+ *     "totalItems": 100,
+ *     "itemsPerPage": 10,
+ *     "totalPages": 10
+ *   },
+ *   "links": {
+ *     "first": "url",
+ *     "previous": "url",
+ *     "next": "url",
+ *     "last": "url",
+ *     "current": "url"
+ *   }
+ * }
+ * ```
+ *
+ * Default key paths are configured in `NestjsResponseOptions`. The
+ * traversal algorithm (dot-notation resolution + computed `from`/`to`) is
+ * inherited from `AbstractDotPathResponseStrategy`; this class exists so
+ * `DriverEnum.NESTJS` resolves to a distinct identity at the DI layer
+ * even though the parsing logic is shared with JSON:API.
+ *
+ * @see https://github.com/ppetzold/nestjs-paginate
+ */
+declare class NestjsResponseStrategy extends AbstractDotPathResponseStrategy {
+}
+
+/**
+ * Request strategy for the @nestjsx/crud driver
+ *
+ * Generates URIs in [@nestjsx/crud's pipe-delimited query format](https://github.com/nestjsx/crud/wiki/Requests):
+ * - Filters: `filter=field||$eq||value` (repeatable; multi-value
+ *   collapses to `filter=field||$in||v1,v2`)
+ * - Operator filters: `filter=field||$op||value` (translated from
+ *   `FilterOperatorEnum` — `CONTAINS`→`$cont`, `ILIKE`→`$contL`,
+ *   `SW`→`$starts`, `BTW`→`$between`, `NOT`→`$ne`/`$notin`,
+ *   `NULL`→`$isnull`/`$notnull` with no value segment)
+ * - Joins: `join=relation` (repeatable, from `addIncludes`)
+ * - Field selection (flat): `fields=col1,col2` (from `addSelect`)
+ * - Sorts: `sort=field,ASC` (repeatable, uppercase direction)
+ * - Pagination (page-based): `page=N&limit=N`
+ *
+ * The JSON-shaped `s={...}` search parameter is intentionally out of
+ * scope: it is not a plain search term, so `setSearch` throws
+ * `UnsupportedSearchError` on this driver. PostgREST-native full-text
+ * search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://github.com/nestjsx/crud/wiki/Requests
+ */
+declare class NestjsxCrudRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, joins (`includes`), flat field selection
+     * (`select`), sorts — no per-model fields, no global search (the `s`
+     * parameter is JSON-shaped, not a plain term)
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * @nestjsx/crud-native names of the four hardcoded query keys
+     *
+     * The wire format is fixed (the server's `CrudRequestInterceptor`
+     * reads `fields`, `filter`, `join`, and `sort`); these keys are
+     * intentionally not configurable through `QueryBuilderOptions` and
+     * live as private statics so they are visible in one place.
+     */
+    private static readonly _fieldsKey;
+    private static readonly _filterKey;
+    private static readonly _joinKey;
+    private static readonly _sortKey;
+    /**
+     * Pipe delimiter separating field, operator, and value segments
+     */
+    private static readonly _separator;
+    /**
+     * Emit @nestjsx/crud-format query-string segments in canonical order:
+     * fields → filters → operator filters → join → sort → limit → page
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration (used
+     * for `page` / `limit`, whose defaults match the wire format; the
+     * `fields` / `filter` / `join` / `sort` keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+    /**
+     * Append `fields=col1,col2` from the flat select array
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFields;
+    /**
+     * Append simple filters as repeatable `filter=field||$eq||value` params
+     *
+     * Single-value filters fold to `$eq`; multi-value filters fold to
+     * `$in` with comma-joined values.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append `join=relation` params from the includes array
+     *
+     * Per-relation field projection (`join=relation||f1,f2`) is not
+     * expressible through the current state shape and is out of scope.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendJoin;
+    /**
+     * Append the limit parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendLimit;
+    /**
+     * Append operator filters as repeatable `filter=field||$op||value` params
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendOperatorFilters;
+    /**
+     * Append the page parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPage;
+    /**
+     * Append `sort=field,ASC` params, one per sort rule
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSort;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into @nestjsx/crud's
+     * `$operator||value` condition segment
+     *
+     * The mapping is library-canonical → @nestjsx/crud-native:
+     * - `EQ`/`GT`/`GTE`/`LT`/`LTE`/`IN` → identity (same operator name)
+     * - `CONTAINS` → `$cont`; `ILIKE` → `$contL` (case-insensitive contains)
+     * - `SW` → `$starts`
+     * - `BTW` → `$between` with `min,max` (arity-checked)
+     * - `NOT` → `$ne` (single value) / `$notin` (multi-value)
+     * - `NULL` → `$isnull` (when value is `true`) / `$notnull` (when value
+     *   is `false`); both emit **no value segment**; arity- and type-checked
+     *
+     * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
+     * `WFTS`) have no @nestjsx/crud equivalent and throw
+     * `UnsupportedFilterOperatorError`.
      *
-     * @param response - The raw API response object
-     * @param options - The response key name configuration
-     * @returns A typed PaginatedCollection instance
+     * @param filter - The operator filter to translate
+     * @returns The `$operator||value` (or bare `$operator`) condition segment
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator is a
+     * PostgREST-only FTS variant
      */
-    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+    private _formatOperatorCondition;
 }
 
 /**
- * Response strategy for the Laravel (pagination-only) driver
+ * Response strategy for the @nestjsx/crud driver
  *
- * Parses flat Laravel pagination responses:
+ * Parses @nestjsx/crud's `getMany` envelope:
  * ```json
  * {
- *   "data": [...],
- *   "current_page": 1,
- *   "total": 100,
- *   "per_page": 15,
- *   "from": 1,
- *   "to": 15,
- *   "next_page_url": "...",
- *   "prev_page_url": "...",
- *   "first_page_url": "...",
- *   "last_page": 7,
- *   "last_page_url": "..."
+ *   "data": [{ "id": 1, "name": "John" }],
+ *   "count": 10,
+ *   "total": 48,
+ *   "page": 2,
+ *   "pageCount": 5
  * }
  * ```
  *
- * The traversal algorithm (flat `response[options.X]` lookups) is
- * inherited from `AbstractFlatResponseStrategy`; this class exists so
- * `DriverEnum.LARAVEL` resolves to a distinct identity at the DI layer
- * even though the parsing logic is shared with Spatie.
+ * Default key paths are configured in `NestjsxCrudResponseOptions`. The
+ * envelope carries no `from`/`to` indices and no navigation links, so
+ * `from`/`to` are computed from `page` × `count` by the inherited
+ * traversal algorithm and the URL slots resolve to `undefined` unless
+ * the consumer overrides their paths via `IPaginationConfig`.
+ *
+ * Note that `count` is the number of entities **on the current page**,
+ * not the requested page size — on the last page of a result set the
+ * derived `from`/`to` can underestimate. Consumers needing exact
+ * indices should compute them from the requested limit instead.
+ *
+ * The dot-notation traversal is inherited from
+ * `AbstractDotPathResponseStrategy`; this class exists so
+ * `DriverEnum.NESTJSX_CRUD` resolves to a distinct identity at the DI
+ * layer even though the parsing logic is shared with JSON:API, NestJS,
+ * and Strapi.
+ *
+ * @see https://github.com/nestjsx/crud/wiki/Requests
  */
-declare class LaravelResponseStrategy extends AbstractFlatResponseStrategy {
+declare class NestjsxCrudResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
 /**
- * Request strategy for the NestJS (nestjs-paginate) driver
- *
- * Generates URIs in the NestJS paginate format:
- * - Simple filters: `filter.field=value`
- * - Operator filters: `filter.field=$operator:value`
- * - Sorts: `sortBy=field1:DESC,field2:ASC`
- * - Select: `select=col1,col2`
- * - Search: `search=term`
- * - Pagination: `limit=N&page=N`
+ * Request strategy for the OData v4 driver
  *
- * @see https://github.com/ppetzold/nestjs-paginate
+ * Generates URIs using [OData's system query options](https://www.odata.org/getting-started/basic-tutorial/#queryData):
+ * - Filters: a single `$filter=` parameter holding ` and `-joined terms in
+ *   OData's expression language (`Price gt 20 and Category eq 'Electronics'`)
+ * - Operator filters: translated from `FilterOperatorEnum` — see the
+ *   mapping on `_formatOperatorTerms`
+ * - Sorts: `$orderby=field asc,other desc` (CSV with explicit direction)
+ * - Select: `$select=col1,col2`
+ * - Expand: `$expand=rel,other($select=col1,col2)` — plain relations come
+ *   from `addIncludes`, column-projected ones from `addEmbedded`
+ * - Search: `$search=term` (OData v4 free-text search)
+ * - Pagination: `$top=N&$skip=M` (skip derived from state.page) plus a
+ *   constant `$count=true` so responses carry the `@odata.count` total
+ *   the response strategy needs
+ *
+ * The `$`-prefixed parameter names are fixed by the OData specification
+ * and intentionally not configurable through `QueryBuilderOptions`; they
+ * live as private statics so they are visible in one place. String
+ * literals are single-quoted with embedded quotes doubled (`'O''Brien'`)
+ * per the OData ABNF; numbers and booleans are emitted bare.
+ *
+ * PostgREST-native full-text search operators (`FTS`, `PHFTS`, `PLFTS`,
+ * `WFTS`) throw `UnsupportedFilterOperatorError` — use `$search` or the
+ * `CONTAINS` / `ILIKE` operator filters instead.
+ *
+ * @see https://www.odata.org/
+ * @see https://docs.oasis-open.org/odata/odata/v4.01/odata-v4.01-part2-url-conventions.html
  */
-declare class NestjsRequestStrategy extends AbstractRequestStrategy {
+declare class OdataRequestStrategy extends AbstractRequestStrategy {
     /**
-     * Filters, operator filters, sorts, flat select, global search — no
-     * per-model fields, no includes
+     * Filters, operator filters, sorts, flat select, includes and embedded
+     * (both folding into `$expand`), global search — no per-model fields
+     * (OData has no JSON:API-style `fields[type]` projection)
      */
     readonly capabilities: IStrategyCapabilities;
     /**
-     * Validate that the given limit is accepted by nestjs-paginate
+     * OData-native names of the system query options
      *
-     * Accepts any integer `>= 1` as a page size, plus `-1` which nestjs-paginate
-     * interprets as "fetch all items" (server must opt-in via `maxLimit: -1`).
-     *
-     * @param limit - The limit value to validate
-     * @throws {InvalidLimitError} If the value is not an integer, or is 0, or is a negative number other than -1
+     * The `$` prefix is mandated by the OData URL conventions; these keys
+     * are intentionally not configurable through `QueryBuilderOptions` and
+     * live as private statics so they are visible in one place.
      */
-    validateLimit(limit: number): void;
+    private static readonly _countKey;
+    private static readonly _expandKey;
+    private static readonly _filterKey;
+    private static readonly _orderbyKey;
+    private static readonly _searchKey;
+    private static readonly _selectKey;
+    private static readonly _skipKey;
+    private static readonly _topKey;
     /**
-     * Emit NestJS-format query-string segments in canonical order:
-     * filters → operator filters → sortBy → select → search → limit → page
+     * Emit OData-format query-string segments in canonical order:
+     * $filter → $orderby → $select → $expand → $search → $count → $top → $skip
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
+     * @param _options - The query parameter key name configuration (unused —
+     * every OData system query option name is fixed by the specification)
      * @returns Ordered query-string fragments
      */
-    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+    protected parts(state: IQueryBuilderState, _options: QueryBuilderOptions): string[];
     /**
-     * Append simple filter parameters as `filter.field=value1,value2`
+     * Append the constant `$count=true` parameter
+     *
+     * Always emitted: the OData response strategy reads the total from
+     * `@odata.count`, which servers only include when the request asks
+     * for it.
      *
-     * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendFilters;
+    private _appendCount;
     /**
-     * Append the limit parameter
+     * Append the `$expand=` parameter combining includes and embedded
+     * relations
+     *
+     * Plain relations from `addIncludes` emit bare (`rel`); embedded
+     * relations from `addEmbedded` emit with an inline projection
+     * (`rel($select=col1,col2)`) or bare when no columns were given. A
+     * relation present in both folds into the embedded fragment, which
+     * carries the column information.
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendLimit;
+    private _appendExpand;
     /**
-     * Append operator-filter parameters as `filter.field=$op:value`
+     * Append the single `$filter=` parameter combining simple and operator
+     * filters
      *
-     * Groups by field; multi-value operators ($in, $btw) join values with commas.
+     * Each term is one OData boolean expression; terms join with ` and `.
+     * Simple single-value filters fold to `eq`; simple multi-value filters
+     * fold to the `in` list operator (`field in ('v1','v2')`).
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendOperatorFilters;
+    private _appendFilter;
     /**
-     * Append the page parameter
+     * Append the `$orderby=field asc,other desc` CSV parameter
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendPage;
+    private _appendOrderby;
     /**
-     * Append the search parameter as `search=term`
+     * Append the `$search=` free-text search parameter
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
     private _appendSearch;
     /**
-     * Append the select parameter as `select=col1,col2`
+     * Append the `$select=col1,col2` projection parameter
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
     private _appendSelect;
     /**
-     * Append sort parameter as `sortBy=field1:DESC,field2:ASC`
+     * Append the `$skip=` parameter, derived from state.page
+     *
+     * OData uses offset-based pagination: the skip is computed as
+     * `(page - 1) * limit`. Omitted when the skip would be 0 (i.e. page 1)
+     * since OData defaults to no skip and dropping it keeps the URI shorter.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSkip;
+    /**
+     * Append the `$top=` page-size parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendTop;
+    /**
+     * Format a filter value as an OData primitive literal
+     *
+     * Strings are single-quoted with embedded single quotes doubled
+     * (`'O''Brien'`) per the OData ABNF; numbers and booleans are emitted
+     * bare.
+     *
+     * @param value - The raw filter value
+     * @returns The OData-formatted literal
+     */
+    private _formatLiteral;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into one or more
+     * OData boolean expressions
+     *
+     * The mapping is library-canonical → OData-native:
+     * - `EQ` → `eq`; `GT`/`GTE`/`LT`/`LTE` → `gt` / `ge` / `lt` / `le`
+     * - `CONTAINS` → `contains(field,'val')`
+     * - `ILIKE` → `contains(tolower(field),tolower('val'))` (case-insensitive
+     *   contains)
+     * - `SW` → `startswith(field,'val')`
+     * - `IN` → `field in ('v1','v2')` (OData v4.01 list operator)
+     * - `BTW` → **two** AND-ed terms (`field ge min` and `field le max`,
+     *   arity-checked)
+     * - `NOT` → `ne` — one term per value, AND-ed (`field ne v1 and field ne v2`)
+     * - `NULL` → `field eq null` (when value is `true`) / `field ne null`
+     *   (when value is `false`); arity- and type-checked
+     *
+     * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
+     * `WFTS`) have no OData equivalent and throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns One or more OData boolean expressions ready to ` and `-join
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator is a
+     * PostgREST-only FTS variant
+     */
+    private _formatOperatorTerms;
+}
+
+/**
+ * Response strategy for the OData v4 driver
+ *
+ * Parses OData collection responses:
+ *
+ * ```json
+ * {
+ *   "@odata.context": "https://api.example.com/$metadata#Products",
+ *   "@odata.count": 100,
+ *   "@odata.nextLink": "https://api.example.com/Products?$count=true&$top=10&$skip=30",
+ *   "value": [...]
+ * }
+ * ```
+ *
+ * OData emits no current-page or page-size field in the body, so this
+ * strategy **derives** them by inspecting the `@odata.nextLink` URL:
+ *
+ * - `perPage` comes from the link's `$top` param, falling back to the
+ *   item count of the current (necessarily full) page when the link
+ *   carries no `$top`.
+ * - `currentPage` is `$skip ÷ perPage` — the next page starts where the
+ *   current one ends. Without a usable link (`$skiptoken`-based
+ *   server-driven paging, or the last page) the strategy falls back to
+ *   page **1**, which is only guaranteed correct for single-page results.
+ * - `lastPage` is `ceil(total ÷ perPage)`; on a link-less response it
+ *   resolves to 1 when the page provably holds the whole result set.
+ *
+ * The total requires `$count=true` on the request — the request strategy
+ * always emits it. Envelope keys contain **literal dots** (`@odata.count`),
+ * so key paths from `OdataResponseOptions` are read with flat bracket
+ * access, never dot-path traversal.
+ *
+ * @see https://docs.oasis-open.org/odata/odata-json-format/v4.01/odata-json-format-v4.01.html
+ */
+declare class OdataResponseStrategy implements IResponseStrategy {
+    /**
+     * Parse an OData collection response into a PaginatedCollection
+     *
+     * @param response - The raw API response body
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, any>, options: ResponseOptions): PaginatedCollection<T>;
+    /**
+     * Derive the current page number from the `@odata.nextLink` URL
+     *
+     * The next page starts where the current one ends, so
+     * `currentPage = $skip ÷ perPage` (e.g. `$skip=30` with `$top=10` →
+     * page 3). Falls back to **1** when the link is absent (last or only
+     * page), carries no `$skip` (`$skiptoken`-based paging), or the page
+     * size is unknown.
+     *
+     * @param nextPageUrl - The `@odata.nextLink` from the response, or null
+     * @param perPage - The derived page size (may be undefined)
+     * @returns The current page number
+     */
+    private _deriveCurrentPage;
+    /**
+     * Derive `from` as the 1-indexed offset of the first item on this page
+     *
+     * Computed from `currentPage` × `perPage` when the page size is known;
+     * on a link-less single page it is 1 whenever items are present.
+     *
+     * @param nextPageUrl - The `@odata.nextLink` from the response, or null
+     * @param data - The items on the current page
+     * @param currentPage - The current page number
+     * @param perPage - The page size (may be undefined)
+     * @returns The 1-indexed `from` index, or undefined when inputs insufficient
+     */
+    private _deriveFrom;
+    /**
+     * Derive the last page number
+     *
+     * `ceil(total ÷ perPage)` when both are known; a link-less response
+     * that provably holds the entire non-empty result set resolves to 1.
+     *
+     * @param nextPageUrl - The `@odata.nextLink` from the response, or null
+     * @param data - The items on the current page
+     * @param total - The total item count
+     * @param perPage - The page size
+     * @returns The last page number, or undefined when inputs insufficient
+     */
+    private _deriveLastPage;
+    /**
+     * Derive `perPage` from the `@odata.nextLink` URL
+     *
+     * Reads the link's `$top` param. When the link exists but carries no
+     * `$top` (server-driven page size), the current page is necessarily
+     * full, so its item count equals the page size. Without a link the
+     * page may be partial and the size is not introspectable.
+     *
+     * @param nextPageUrl - The `@odata.nextLink` from the response, or null
+     * @param data - The items on the current page
+     * @returns The page size, or undefined
+     */
+    private _derivePerPage;
+    /**
+     * Derive `to` as the 1-indexed offset of the last item on this page
+     *
+     * Clamped to `total` so the last page does not report past the end;
+     * on a link-less single page it is the item count.
+     *
+     * @param nextPageUrl - The `@odata.nextLink` from the response, or null
+     * @param data - The items on the current page
+     * @param currentPage - The current page number
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `to` index, or undefined when inputs insufficient
+     */
+    private _deriveTo;
+    /**
+     * Extract an integer query parameter from an OData pagination URL
+     *
+     * @param url - The URL to parse
+     * @param name - The query-parameter name to look up (e.g. `$skip`)
+     * @returns The integer value, or undefined
+     */
+    private _extractNumberParam;
+    /**
+     * Extract a single query parameter from a URL via the WHATWG URL parser
+     *
+     * OData permits **relative** `@odata.nextLink` values, so parsing
+     * retries against a placeholder base before giving up. Returns
+     * undefined when the URL is unparseable or the parameter is absent.
+     *
+     * @param url - The URL to parse
+     * @param name - The query-parameter name to look up
+     * @returns The raw string value of the parameter, or undefined
+     */
+    private _extractQueryParam;
+}
+
+/**
+ * Request strategy for the Payload CMS driver
+ *
+ * Generates URIs in [Payload's REST query format](https://payloadcms.com/docs/queries/overview):
+ * - Filters: `where[field][equals]=value` (multi-value collapses to
+ *   `where[field][in]=v1,v2` CSV)
+ * - Operator filters: `where[field][op]=value` (translated from
+ *   `FilterOperatorEnum` — `BTW`→`greater_than_equal`+`less_than_equal`
+ *   pair, `NOT`→`not_equals`/`not_in`, `NULL`→`exists` with inverted
+ *   boolean)
+ * - Sorts: `sort=-createdAt,title` (CSV, `-` prefix = DESC)
+ * - Field selection (flat): `select[col1]=true&select[col2]=true`
+ * - Pagination (page-based): `page=N&limit=M`
+ *
+ * The `where` / `sort` / `select` / `page` / `limit` keys are fixed by
+ * Payload's REST endpoints and intentionally not configurable through
+ * `QueryBuilderOptions`; they live as private statics so they are
+ * visible in one place.
+ *
+ * Relationship population is controlled by Payload's numeric `depth`
+ * param, not a named-relation list — `addIncludes` therefore throws
+ * `UnsupportedIncludesError` (pass `depth` through your HTTP layer if
+ * needed). There is no per-model field selection and no global search
+ * param. `SW` (no starts-with operator) and the PostgREST-native
+ * full-text operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://payloadcms.com/docs/queries/overview
+ */
+declare class PayloadRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, sorts, flat field selection (`select`)
+     * — no per-model fields, no includes (numeric `depth` instead), no
+     * global search, no embedded resources
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Payload-native names of the five hardcoded query keys
+     *
+     * Fixed by the REST endpoints and intentionally not configurable
+     * through `QueryBuilderOptions`.
+     */
+    private static readonly _limitKey;
+    private static readonly _pageKey;
+    private static readonly _selectKey;
+    private static readonly _sortKey;
+    private static readonly _whereKey;
+    /**
+     * Emit Payload-format query-string segments in canonical order:
+     * where (merged) → sort → select → page → limit
+     *
+     * Simple filters and operator filters share a single `where` wrapper
+     * so qs emits one ordered bracket structure rather than two duplicate
+     * top-level `where[...]` blocks.
+     *
+     * @param state - The current query builder state
+     * @param _options - The query parameter key name configuration (unused;
+     * Payload's wire keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, _options: QueryBuilderOptions): string[];
+    /**
+     * Append the `page=` / `limit=` pagination pair
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPagination;
+    /**
+     * Append `select[col]=true` flags from the flat select array
+     *
+     * Payload's select API is an object of `true` flags rather than a
+     * CSV; nested selection (`select[group.field]=true`) passes through
+     * when given as a dotted column name.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSelect;
+    /**
+     * Append the `sort=-createdAt,title` CSV parameter
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendSort;
+    private _appendSort;
+    /**
+     * Append the unified `where[...]` wrapper combining simple filters
+     * and operator filters
+     *
+     * Both kinds emit into the same nested object under `where` so qs
+     * produces a single bracketed block per request. Simple single-value
+     * filters fold to `equals`; simple multi-value filters fold to the
+     * `in` CSV. Operator filters then merge into the same per-field map,
+     * potentially co-existing with a simple filter on the same field.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendWhere;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into Payload's
+     * `operator → value` payload shape
+     *
+     * The mapping is library-canonical → Payload-native:
+     * - `EQ` → `equals`
+     * - `GT`/`GTE`/`LT`/`LTE` → `greater_than` / `greater_than_equal` /
+     *   `less_than` / `less_than_equal`
+     * - `CONTAINS` → `contains` (case-insensitive substring)
+     * - `ILIKE` → `like` (case-insensitive, word-based)
+     * - `IN` → `in` (CSV)
+     * - `BTW` → `greater_than_equal` + `less_than_equal` pair in one
+     *   payload (arity-checked)
+     * - `NOT` → `not_equals` (single value) / `not_in` (multi-value, CSV)
+     * - `NULL` → `exists` with **inverted** boolean (`true` →
+     *   `exists=false` ⇔ IS NULL); arity- and type-checked
+     *
+     * `SW` (Payload has no starts-with operator) and PostgREST's
+     * full-text-search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns An `{ operator: value }` payload ready to merge under
+     * `where[field]`
+     * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
+     * exactly two values, or `NULL` does not receive exactly one boolean
+     * @throws {UnsupportedFilterOperatorError} If the operator has no
+     * Payload equivalent
+     */
+    private _formatOperatorPayload;
 }
 
 /**
- * Response strategy for the NestJS (nestjs-paginate) driver
+ * Response strategy for the Payload CMS driver
  *
- * Parses nested NestJS pagination responses:
+ * Parses Payload's paginated collection responses — the
+ * `mongoose-paginate-v2` envelope, shared by many Express/Mongoose
+ * backends:
  * ```json
  * {
- *   "data": [...],
- *   "meta": {
- *     "currentPage": 1,
- *     "totalItems": 100,
- *     "itemsPerPage": 10,
- *     "totalPages": 10
- *   },
- *   "links": {
- *     "first": "url",
- *     "previous": "url",
- *     "next": "url",
- *     "last": "url",
- *     "current": "url"
- *   }
+ *   "docs": [{ "id": "abc123", "title": "Hello" }],
+ *   "totalDocs": 48,
+ *   "limit": 10,
+ *   "totalPages": 5,
+ *   "page": 2,
+ *   "pagingCounter": 11,
+ *   "hasPrevPage": true,
+ *   "hasNextPage": true,
+ *   "prevPage": 1,
+ *   "nextPage": 3
  * }
  * ```
  *
- * Default key paths are configured in `NestjsResponseOptions`. The
- * traversal algorithm (dot-notation resolution + computed `from`/`to`) is
- * inherited from `AbstractDotPathResponseStrategy`; this class exists so
- * `DriverEnum.NESTJS` resolves to a distinct identity at the DI layer
- * even though the parsing logic is shared with JSON:API.
+ * Default key paths are configured in `PayloadResponseOptions`. The
+ * envelope's `pagingCounter` is the 1-indexed offset of the first doc
+ * on the page, so it maps straight onto `from`; `to` is computed from
+ * `page` × `limit` (clamped to the total). `prevPage` / `nextPage` are
+ * **page numbers**, not URLs, so the navigation-URL slots on
+ * `PaginatedCollection` stay `undefined` unless the consumer overrides
+ * their paths via `IPaginationConfig`. The traversal algorithm is
+ * inherited from `AbstractDotPathResponseStrategy`; this class exists
+ * so `DriverEnum.PAYLOAD` resolves to a distinct identity at the DI
+ * layer even though the parsing logic is shared with JSON:API, NestJS,
+ * Strapi, and PocketBase.
  *
- * @see https://github.com/ppetzold/nestjs-paginate
+ * @see https://payloadcms.com/docs/rest-api/overview
  */
-declare class NestjsResponseStrategy extends AbstractDotPathResponseStrategy {
+declare class PayloadResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
 /**
- * Request strategy for the @nestjsx/crud driver
- *
- * Generates URIs in [@nestjsx/crud's pipe-delimited query format](https://github.com/nestjsx/crud/wiki/Requests):
- * - Filters: `filter=field||$eq||value` (repeatable; multi-value
- *   collapses to `filter=field||$in||v1,v2`)
- * - Operator filters: `filter=field||$op||value` (translated from
- *   `FilterOperatorEnum` — `CONTAINS`→`$cont`, `ILIKE`→`$contL`,
- *   `SW`→`$starts`, `BTW`→`$between`, `NOT`→`$ne`/`$notin`,
- *   `NULL`→`$isnull`/`$notnull` with no value segment)
- * - Joins: `join=relation` (repeatable, from `addIncludes`)
- * - Field selection (flat): `fields=col1,col2` (from `addSelect`)
- * - Sorts: `sort=field,ASC` (repeatable, uppercase direction)
- * - Pagination (page-based): `page=N&limit=N`
- *
- * The JSON-shaped `s={...}` search parameter is intentionally out of
- * scope: it is not a plain search term, so `setSearch` throws
- * `UnsupportedSearchError` on this driver. PostgREST-native full-text
- * search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * Request strategy for the PocketBase driver
+ *
+ * Generates URIs in [PocketBase's records-list format](https://pocketbase.io/docs/api-records/):
+ * - Filters: a single `filter=(...)` expression-language parameter —
+ *   simple single-value filters fold to `field='value'`, multi-value
+ *   filters fold to an OR group (`(field='v1' || field='v2')`), and all
+ *   clauses join with ` && `
+ * - Operator filters: expression terms (`field>=10`, `field~'val'`) —
+ *   see the mapping on `_formatOperatorClause`
+ * - Sorts: `sort=-created,title` (CSV, `-` prefix = DESC)
+ * - Field selection (flat): `fields=id,title` (CSV)
+ * - Relation expansion: `expand=author,comments` (CSV)
+ * - Pagination (page-based): `page=N&perPage=M`
+ *
+ * The `page` / `perPage` / `sort` / `filter` / `expand` / `fields` keys
+ * are fixed by the PocketBase records API and intentionally not
+ * configurable through `QueryBuilderOptions`; they live as private
+ * statics so they are visible in one place.
+ *
+ * String literals are single-quoted with embedded quotes
+ * backslash-escaped (`name='O\'Brien'`); numbers and booleans emit
+ * bare. PocketBase has no global search param (use `~` terms instead)
+ * and no per-model field selection — the corresponding fluent methods
+ * throw the matching `Unsupported*Error`. The PostgREST-native
+ * full-text operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
  * `UnsupportedFilterOperatorError`.
  *
- * @see https://github.com/nestjsx/crud/wiki/Requests
+ * @see https://pocketbase.io/docs/api-records/
  */
-declare class NestjsxCrudRequestStrategy extends AbstractRequestStrategy {
+declare class PocketbaseRequestStrategy extends AbstractRequestStrategy {
     /**
-     * Filters, operator filters, joins (`includes`), flat field selection
-     * (`select`), sorts — no per-model fields, no global search (the `s`
-     * parameter is JSON-shaped, not a plain term)
+     * Filters, operator filters, sorts, expand (`includes`), flat field
+     * selection (`select`) — no per-model fields, no global search, no
+     * embedded resources
      */
     readonly capabilities: IStrategyCapabilities;
     /**
-     * @nestjsx/crud-native names of the four hardcoded query keys
+     * PocketBase-native names of the six hardcoded query keys
      *
-     * The wire format is fixed (the server's `CrudRequestInterceptor`
-     * reads `fields`, `filter`, `join`, and `sort`); these keys are
-     * intentionally not configurable through `QueryBuilderOptions` and
-     * live as private statics so they are visible in one place.
+     * The records API reads exactly these names; they are intentionally
+     * not configurable through `QueryBuilderOptions` and live as private
+     * statics so they are visible in one place.
      */
+    private static readonly _expandKey;
     private static readonly _fieldsKey;
     private static readonly _filterKey;
-    private static readonly _joinKey;
+    private static readonly _pageKey;
+    private static readonly _perPageKey;
     private static readonly _sortKey;
     /**
-     * Pipe delimiter separating field, operator, and value segments
-     */
-    private static readonly _separator;
-    /**
-     * Emit @nestjsx/crud-format query-string segments in canonical order:
-     * fields → filters → operator filters → join → sort → limit → page
+     * Emit PocketBase-format query-string segments in canonical order:
+     * expand → fields → filter (merged) → sort → page → perPage
      *
-     * @param state - The current query builder state
-     * @param options - The query parameter key name configuration (used
-     * for `page` / `limit`, whose defaults match the wire format; the
-     * `fields` / `filter` / `join` / `sort` keys are fixed by the server)
-     * @returns Ordered query-string fragments
-     */
-    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
-    /**
-     * Append `fields=col1,col2` from the flat select array
+     * Simple filters and operator filters share the single `filter=(...)`
+     * parameter so the server receives one combined expression rather
+     * than two conflicting `filter` params.
      *
      * @param state - The current query builder state
-     * @param out - The accumulator the caller joins into the URI
+     * @param _options - The query parameter key name configuration (unused;
+     * PocketBase's wire keys are fixed by the server)
+     * @returns Ordered query-string fragments
      */
-    private _appendFields;
+    protected parts(state: IQueryBuilderState, _options: QueryBuilderOptions): string[];
     /**
-     * Append simple filters as repeatable `filter=field||$eq||value` params
+     * Append the `expand=` CSV from the includes array
      *
-     * Single-value filters fold to `$eq`; multi-value filters fold to
-     * `$in` with comma-joined values.
+     * Nested expansion (`author.address`) passes through verbatim when
+     * given as a dotted include name.
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendFilters;
+    private _appendExpand;
     /**
-     * Append `join=relation` params from the includes array
-     *
-     * Per-relation field projection (`join=relation||f1,f2`) is not
-     * expressible through the current state shape and is out of scope.
+     * Append the `fields=` CSV from the flat select array
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendJoin;
+    private _appendFields;
     /**
-     * Append the limit parameter
+     * Append the single `filter=(...)` expression combining simple
+     * filters and operator filters
      *
-     * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
-     * @param out - The accumulator the caller joins into the URI
-     */
-    private _appendLimit;
-    /**
-     * Append operator filters as repeatable `filter=field||$op||value` params
+     * Clauses join with ` && `; multi-value clauses keep their own
+     * parentheses so OR groups stay correctly scoped inside the AND
+     * chain.
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendOperatorFilters;
+    private _appendFilter;
     /**
-     * Append the page parameter
+     * Append the `page=` / `perPage=` pagination pair
      *
      * @param state - The current query builder state
-     * @param options - The query parameter key name configuration
      * @param out - The accumulator the caller joins into the URI
      */
-    private _appendPage;
+    private _appendPagination;
     /**
-     * Append `sort=field,ASC` params, one per sort rule
+     * Append the `sort=-created,title` CSV parameter
      *
      * @param state - The current query builder state
      * @param out - The accumulator the caller joins into the URI
      */
     private _appendSort;
     /**
-     * Translate a `FilterOperatorEnum` operator filter into @nestjsx/crud's
-     * `$operator||value` condition segment
-     *
-     * The mapping is library-canonical → @nestjsx/crud-native:
-     * - `EQ`/`GT`/`GTE`/`LT`/`LTE`/`IN` → identity (same operator name)
-     * - `CONTAINS` → `$cont`; `ILIKE` → `$contL` (case-insensitive contains)
-     * - `SW` → `$starts`
-     * - `BTW` → `$between` with `min,max` (arity-checked)
-     * - `NOT` → `$ne` (single value) / `$notin` (multi-value)
-     * - `NULL` → `$isnull` (when value is `true`) / `$notnull` (when value
-     *   is `false`); both emit **no value segment**; arity- and type-checked
+     * Translate a `FilterOperatorEnum` operator filter into one
+     * PocketBase expression clause
+     *
+     * The mapping is library-canonical → PocketBase-native:
+     * - `EQ` → `field='v'`; `GT`/`GTE`/`LT`/`LTE` → `>` / `>=` / `<` / `<=`
+     * - `CONTAINS`/`ILIKE` → `field~'v'` (PocketBase's `~` is a
+     *   case-insensitive LIKE that auto-wraps the operand in `%...%`)
+     * - `SW` → `field~'v%'` (explicit trailing wildcard disables the
+     *   auto-wrap)
+     * - `IN` → OR group `(field='v1' || field='v2')`
+     * - `BTW` → AND group `(field>=min && field<=max)` (arity-checked)
+     * - `NOT` → `field!='v'` (single) / AND group of `!=` terms (multi)
+     * - `NULL` → `field=null` (when value is `true`) / `field!=null`
+     *   (when value is `false`); arity- and type-checked
      *
      * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
-     * `WFTS`) have no @nestjsx/crud equivalent and throw
+     * `WFTS`) have no PocketBase equivalent and throw
      * `UnsupportedFilterOperatorError`.
      *
      * @param filter - The operator filter to translate
-     * @returns The `$operator||value` (or bare `$operator`) condition segment
+     * @returns One expression clause ready to join into `filter=(...)`
      * @throws {InvalidFilterOperatorValueError} If `BTW` does not receive
      * exactly two values, or `NULL` does not receive exactly one boolean
      * @throws {UnsupportedFilterOperatorError} If the operator is a
      * PostgREST-only FTS variant
      */
-    private _formatOperatorCondition;
+    private _formatOperatorClause;
+    /**
+     * Backslash-escape single quotes inside a string literal
+     *
+     * @param value - The raw string value
+     * @returns The escaped string, ready to wrap in single quotes
+     */
+    private _escape;
+    /**
+     * Format a filter value as a PocketBase expression literal
+     *
+     * Strings are single-quoted (embedded quotes backslash-escaped);
+     * numbers and booleans emit bare, matching the expression language's
+     * literal rules.
+     *
+     * @param value - The raw filter value
+     * @returns The formatted literal
+     */
+    private _formatValue;
 }
 
 /**
- * Response strategy for the @nestjsx/crud driver
+ * Response strategy for the PocketBase driver
  *
- * Parses @nestjsx/crud's `getMany` envelope:
+ * Parses PocketBase records-list responses:
  * ```json
  * {
- *   "data": [{ "id": 1, "name": "John" }],
- *   "count": 10,
- *   "total": 48,
- *   "page": 2,
- *   "pageCount": 5
+ *   "page": 1,
+ *   "perPage": 30,
+ *   "totalItems": 48,
+ *   "totalPages": 2,
+ *   "items": [{ "id": "abc123", "title": "Hello" }]
  * }
  * ```
  *
- * Default key paths are configured in `NestjsxCrudResponseOptions`. The
- * envelope carries no `from`/`to` indices and no navigation links, so
- * `from`/`to` are computed from `page` × `count` by the inherited
- * traversal algorithm and the URL slots resolve to `undefined` unless
- * the consumer overrides their paths via `IPaginationConfig`.
- *
- * Note that `count` is the number of entities **on the current page**,
- * not the requested page size — on the last page of a result set the
- * derived `from`/`to` can underestimate. Consumers needing exact
- * indices should compute them from the requested limit instead.
- *
- * The dot-notation traversal is inherited from
- * `AbstractDotPathResponseStrategy`; this class exists so
- * `DriverEnum.NESTJSX_CRUD` resolves to a distinct identity at the DI
+ * Default key paths are configured in `PocketbaseResponseOptions` —
+ * all flat keys, resolved by the inherited dot-path traversal (a flat
+ * key is just a one-segment path). PocketBase does not include
+ * navigation links in the envelope, so `firstPageUrl`, `prevPageUrl`,
+ * `nextPageUrl`, and `lastPageUrl` resolve to `undefined` unless the
+ * consumer overrides their paths via `IPaginationConfig`; `from`/`to`
+ * are computed from `page` × `perPage`. This class exists so
+ * `DriverEnum.POCKETBASE` resolves to a distinct identity at the DI
  * layer even though the parsing logic is shared with JSON:API, NestJS,
  * and Strapi.
  *
- * @see https://github.com/nestjsx/crud/wiki/Requests
+ * When the request was sent with `skipTotal=1` (not emitted by this
+ * driver), PocketBase reports `totalItems`/`totalPages` as `-1`;
+ * override the paths or treat the values accordingly if you opt into
+ * that server-side optimisation.
+ *
+ * @see https://pocketbase.io/docs/api-records/
  */
-declare class NestjsxCrudResponseStrategy extends AbstractDotPathResponseStrategy {
+declare class PocketbaseResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
 /**
@@ -2423,10 +4276,17 @@ declare class PostgrestRequestStrategy extends AbstractRequestStrategy {
      */
     private _appendOrder;
     /**
-     * Append the select parameter as `select=col1,col2`
+     * Append the select parameter as `select=col1,col2,rel(col1,col2)`
      *
-     * PostgREST uses a `select` query param for column pruning, matching
-     * NestJS semantics.
+     * PostgREST uses a single `select` query param for both column pruning
+     * (matching NestJS semantics) and embedded-resource fetching — the
+     * embedded fragments from `addEmbedded` are spliced into the same
+     * param value, never emitted as a second `select`.
+     *
+     * Fragment shape per relation: `rel(col1,col2)` with explicit columns,
+     * `rel(*)` without. When embedded relations are present but no flat
+     * columns were selected, the flat part defaults to `*` so the base
+     * row's columns are not silently dropped from the projection.
      *
      * @param state - The current query builder state
      * @param options - The query parameter key name configuration
@@ -3054,5 +4914,241 @@ declare class StrapiRequestStrategy extends AbstractRequestStrategy {
 declare class StrapiResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
-export { DrfRequestStrategy, DrfResponseStrategy, DriverEnum, FilterOperatorEnum, InvalidFilterOperatorValueError, InvalidLimitError, InvalidPageNumberError, InvalidResourceNameError, JsonApiRequestStrategy, JsonApiResponseStrategy, KeyNotFoundError, LaravelRequestStrategy, LaravelResponseStrategy, NG_QUBEE_DRIVER, NG_QUBEE_REQUEST_OPTIONS, NG_QUBEE_REQUEST_STRATEGY, NG_QUBEE_RESPONSE_OPTIONS, NG_QUBEE_RESPONSE_STRATEGY, NestjsRequestStrategy, NestjsResponseStrategy, NestjsxCrudRequestStrategy, NestjsxCrudResponseStrategy, NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationModeEnum, PaginationNotSyncedError, PaginationService, PostgrestRequestStrategy, PostgrestResponseStrategy, SieveRequestStrategy, SieveResponseStrategy, SortEnum, SpatieRequestStrategy, SpatieResponseStrategy, SpringRequestStrategy, SpringResponseStrategy, StrapiRequestStrategy, StrapiResponseStrategy, UnselectableModelError, UnsupportedFieldSelectionError, UnsupportedFilterError, UnsupportedFilterOperatorError, UnsupportedIncludesError, UnsupportedSearchError, UnsupportedSelectError, UnsupportedSortError, buildNgQubeeProviders, provideNgQubee, provideNgQubeeInstance, readHeader };
-export type { HeaderBag, IConfig, IFields, IFilters, INestState, IOperatorFilter, IPage, IPaginatedObject, IPaginationConfig, IQueryBuilderConfig, IQueryBuilderState, IRequestStrategy, IResponseStrategy, ISort };
+/**
+ * Request strategy for the WordPress REST API driver
+ *
+ * Generates URIs in the [WordPress REST API collection format](https://developer.wordpress.org/rest-api/using-the-rest-api/pagination/):
+ * - Filters: `field=value` (collection parameters like `status`,
+ *   `author`, `categories`); multi-value folds to a CSV (`field=v1,v2`,
+ *   the list convention WordPress uses for ID params)
+ * - Sorts: `orderby=field&order=asc|desc` — WordPress core supports a
+ *   **single** orderby, so only the first sort rule is emitted
+ * - Field selection (flat): `_fields=id,title` (CSV)
+ * - Relation embedding: `_embed=author,wp:term` (CSV)
+ * - Search: `search=term`
+ * - Pagination (page-based): `page=N&per_page=M`
+ *
+ * The `page` / `per_page` / `orderby` / `order` / `search` and the
+ * underscore-prefixed global params (`_fields`, `_embed`) are fixed by
+ * the server and intentionally not configurable through
+ * `QueryBuilderOptions`; they live as private statics so they are
+ * visible in one place.
+ *
+ * WordPress caps `per_page` at **100** server-side (a 400
+ * `rest_invalid_param` response beyond that); the cap is endpoint
+ * policy rather than a syntax rule, so `validateLimit` keeps the
+ * default positive-integer check and the server stays authoritative.
+ * There is no generic comparison-operator syntax (only
+ * parameter-specific helpers like `before`/`after` for dates, which
+ * pass through `addFilter`), so `addFilterOperator` throws
+ * `UnsupportedFilterOperatorError` via the capability gate.
+ *
+ * @see https://developer.wordpress.org/rest-api/reference/posts/#list-posts
+ */
+declare class WordpressRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, sorts, global search, flat field selection (`select`),
+     * embedding (`includes`) — no operator filters, no per-model fields,
+     * no embedded-column projection
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * WordPress-native names of the seven hardcoded query keys
+     *
+     * The underscore prefix marks the REST API's global params apart
+     * from collection filters; all keys are fixed by the server and
+     * intentionally not configurable through `QueryBuilderOptions`.
+     */
+    private static readonly _embedKey;
+    private static readonly _fieldsKey;
+    private static readonly _orderbyKey;
+    private static readonly _orderKey;
+    private static readonly _pageKey;
+    private static readonly _perPageKey;
+    private static readonly _searchKey;
+    /**
+     * Emit WordPress-format query-string segments in canonical order:
+     * filters → orderby/order → _fields → _embed → search → page → per_page
+     *
+     * @param state - The current query builder state
+     * @param _options - The query parameter key name configuration (unused;
+     * WordPress' wire keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, _options: QueryBuilderOptions): string[];
+    /**
+     * Append the `_embed=` CSV from the includes array
+     *
+     * A bare `_embed` (no value) embeds everything; this driver always
+     * emits the named form so the response stays lean.
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendEmbed;
+    /**
+     * Append the `_fields=` CSV from the flat select array
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFields;
+    /**
+     * Append simple filter parameters
+     *
+     * A single value emits the bare form (`status=publish`); multiple
+     * values fold to the CSV list convention (`categories=2,3`).
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * Append the `page=` / `per_page=` pagination pair
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPagination;
+    /**
+     * Append the `search=` parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSearch;
+    /**
+     * Append the `orderby=` / `order=` pair from the first sort rule
+     *
+     * WordPress core accepts a single `orderby` value — additional sort
+     * rules in state are ignored by design (the server would reject a
+     * CSV here).
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSort;
+}
+
+/**
+ * Response strategy for the WordPress REST API driver
+ *
+ * WordPress returns a bare array body for collection endpoints.
+ * Pagination metadata travels in HTTP response headers:
+ *
+ * - `X-WP-Total` — total number of records in the collection
+ * - `X-WP-TotalPages` — total number of pages at the requested
+ *   `per_page`
+ * - `Link` — RFC 5988 navigation links (`rel="next"` / `rel="prev"`)
+ *
+ * The strategy surfaces the `Link` URLs as `nextPageUrl` /
+ * `prevPageUrl` and derives position from them:
+ *
+ * - `currentPage` is the `prev` link's `page` param + 1 (no `prev` →
+ *   page **1**), falling back to the `next` link's `page` param − 1.
+ * - `perPage` is the item count of the current page whenever a `next`
+ *   link exists (a page with a successor is necessarily full); on the
+ *   last page of a multi-page set it is not introspectable and stays
+ *   `undefined`.
+ * - `from`/`to` derive from `currentPage` × `perPage` on full pages,
+ *   or count back from the total on the last page
+ *   (`from = total - data.length + 1`, `to = total`).
+ *
+ * This strategy expects the consumer to pass the array body as
+ * `response` (or a plain object with `response[options.data]` pointing
+ * at the array) and the response headers via the optional `headers`
+ * bag — the same call-site shape as the PostgREST driver. Omitted
+ * headers are tolerated and yield a collection with `undefined`
+ * bounds.
+ *
+ * @see https://developer.wordpress.org/rest-api/using-the-rest-api/pagination/
+ */
+declare class WordpressResponseStrategy implements IResponseStrategy {
+    private static readonly _linkHeader;
+    private static readonly _linkRegex;
+    private static readonly _pageParamRegex;
+    private static readonly _totalHeader;
+    private static readonly _totalPagesHeader;
+    /**
+     * Parse a WordPress REST response into a typed PaginatedCollection
+     *
+     * @param response - The raw response. Either the array body directly, or
+     * an object with the array at `response[options.data]`.
+     * @param options - The response key configuration (only `options.data` is
+     * consulted; all pagination metadata comes from headers).
+     * @param headers - Optional HTTP response headers. `X-WP-Total` /
+     * `X-WP-TotalPages` drive the totals and the `Link` header drives
+     * navigation and page derivation; omission is tolerated.
+     * @returns A typed PaginatedCollection instance
+     */
+    paginate<T extends IPaginatedObject>(response: Record<string, unknown>, options: ResponseOptions, headers?: HeaderBag): PaginatedCollection<T>;
+    /**
+     * Derive the current page from the Link relations
+     *
+     * The `prev` URL's `page` param + 1 is authoritative; without a
+     * `prev` the page is 1 unless a `next` URL contradicts it (its page
+     * param − 1). A missing/unparseable Link header yields page 1.
+     *
+     * @param next - The `rel="next"` URL, if present
+     * @param prev - The `rel="prev"` URL, if present
+     * @returns The 1-indexed current page
+     */
+    private _deriveCurrentPage;
+    /**
+     * Derive `from` as the 1-indexed offset of the first item on this page
+     *
+     * Computed from `currentPage` × `perPage` on full pages; on the last
+     * page (no `next` link) it counts back from the total
+     * (`total - items + 1`), which also covers single-page responses.
+     *
+     * @param data - The items on the current page
+     * @param currentPage - The current page number
+     * @param next - The `rel="next"` URL, if present
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `from` index, or undefined when inputs insufficient
+     */
+    private _deriveFrom;
+    /**
+     * Derive `to` as the 1-indexed offset of the last item on this page
+     *
+     * Clamped to `total` so the last page does not report past the end;
+     * on the last page (no `next` link) it is simply the total.
+     *
+     * @param data - The items on the current page
+     * @param currentPage - The current page number
+     * @param next - The `rel="next"` URL, if present
+     * @param perPage - The page size (may be undefined)
+     * @param total - The total item count (may be undefined)
+     * @returns The 1-indexed `to` index, or undefined when inputs insufficient
+     */
+    private _deriveTo;
+    /**
+     * Extract the `page` query param from a navigation URL
+     *
+     * @param url - The URL to inspect (possibly undefined)
+     * @returns The parsed page number, or undefined
+     */
+    private _pageParam;
+    /**
+     * Parse a non-negative integer count header value
+     *
+     * @param value - Raw header value (possibly null/undefined)
+     * @returns The parsed count, or undefined when absent or unparseable
+     */
+    private _parseCount;
+    /**
+     * Extract the `rel="next"` / `rel="prev"` URLs from an RFC 5988
+     * `Link` header value
+     *
+     * Tolerates any ordering, extra relations (`rel="collection"` etc.
+     * are ignored), and a missing header.
+     *
+     * @param value - Raw header value (possibly null/undefined)
+     * @returns The navigation URLs found, keyed by relation
+     */
+    private _parseLinkHeader;
+}
+
+export { ApiPlatformRequestStrategy, ApiPlatformResponseOptions, ApiPlatformResponseStrategy, DirectusRequestStrategy, DirectusResponseOptions, DirectusResponseStrategy, DrfRequestStrategy, DrfResponseOptions, DrfResponseStrategy, DriverEnum, FeathersRequestStrategy, FeathersResponseOptions, FeathersResponseStrategy, FilterOperatorEnum, InvalidFilterOperatorValueError, InvalidLimitError, InvalidPageNumberError, InvalidResourceNameError, JsonApiRequestStrategy, JsonApiResponseOptions, JsonApiResponseStrategy, JsonServerRequestStrategy, JsonServerResponseOptions, JsonServerResponseStrategy, KeyNotFoundError, LaravelRequestStrategy, LaravelResponseStrategy, NG_QUBEE_DRIVER, NG_QUBEE_REQUEST_OPTIONS, NG_QUBEE_REQUEST_STRATEGY, NG_QUBEE_RESPONSE_OPTIONS, NG_QUBEE_RESPONSE_STRATEGY, NestjsRequestStrategy, NestjsResponseOptions, NestjsResponseStrategy, NestjsxCrudRequestStrategy, NestjsxCrudResponseOptions, NestjsxCrudResponseStrategy, NgQubeeModule, NgQubeeService, OdataRequestStrategy, OdataResponseOptions, OdataResponseStrategy, PaginatedCollection, PaginationModeEnum, PaginationNotSyncedError, PaginationService, PayloadRequestStrategy, PayloadResponseOptions, PayloadResponseStrategy, PocketbaseRequestStrategy, PocketbaseResponseOptions, PocketbaseResponseStrategy, PostgrestRequestStrategy, PostgrestResponseStrategy, QueryBuilderOptions, ResponseOptions, SieveRequestStrategy, SieveResponseOptions, SieveResponseStrategy, SortEnum, SpatieRequestStrategy, SpatieResponseStrategy, SpringRequestStrategy, SpringResponseOptions, SpringResponseStrategy, StrapiRequestStrategy, StrapiResponseOptions, StrapiResponseStrategy, UnselectableModelError, UnsupportedEmbeddedError, UnsupportedFieldSelectionError, UnsupportedFilterError, UnsupportedFilterOperatorError, UnsupportedIncludesError, UnsupportedSearchError, UnsupportedSelectError, UnsupportedSortError, WordpressRequestStrategy, WordpressResponseStrategy, buildNgQubeeProviders, provideNgQubee, provideNgQubeeInstance, readHeader };
+export type { Embedded, HeaderBag, IConfig, IFields, IFilters, INestState, IOperatorFilter, IPage, IPaginatedObject, IPaginationConfig, IQueryBuilderConfig, IQueryBuilderState, IRequestStrategy, IResponseStrategy, ISort };