ng-qubee 3.5.0 → 3.6.0

package/types/ng-qubee.d.ts

@@ -50,8 +50,11 @@ declare enum DriverEnum {
     JSON_API = "json-api",
     LARAVEL = "laravel",
     NESTJS = "nestjs",
+    NESTJSX_CRUD = "nestjsx-crud",
     POSTGREST = "postgrest",
+    SIEVE = "sieve",
     SPATIE = "spatie",
+    SPRING = "spring",
     STRAPI = "strapi"
 }
 
@@ -1445,6 +1448,274 @@ declare abstract class AbstractRequestStrategy implements IRequestStrategy {
     protected join(base: string, segments: string[]): string;
 }
 
+/**
+ * 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/
+ */
+declare class DrfRequestStrategy 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)
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * 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 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.
+     *
+     * @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 JSON:API driver
  *
@@ -1833,6 +2104,183 @@ declare class NestjsRequestStrategy extends AbstractRequestStrategy {
 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 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
+     */
+    private _formatOperatorCondition;
+}
+
+/**
+ * Response strategy for the @nestjsx/crud driver
+ *
+ * Parses @nestjsx/crud's `getMany` envelope:
+ * ```json
+ * {
+ *   "data": [{ "id": 1, "name": "John" }],
+ *   "count": 10,
+ *   "total": 48,
+ *   "page": 2,
+ *   "pageCount": 5
+ * }
+ * ```
+ *
+ * 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 NestjsxCrudResponseStrategy extends AbstractDotPathResponseStrategy {
+}
+
 /**
  * Request strategy for the PostgREST driver
  *
@@ -2032,6 +2480,154 @@ declare class PostgrestResponseStrategy implements IResponseStrategy {
     private _parseContentRange;
 }
 
+/**
+ * Request strategy for the Sieve (.NET) driver
+ *
+ * Generates URIs in [Sieve's compact expression format](https://github.com/Biarity/Sieve):
+ * - Filters: a single `filters=` parameter holding comma-joined (AND)
+ *   `Field{op}Value` terms; multi-value terms use the pipe (OR) on the
+ *   value side (`status==active|pending`)
+ * - Operator filters: translated from `FilterOperatorEnum` — see the
+ *   mapping on `_formatOperatorTerms`
+ * - Sorts: `sorts=field,-other` (CSV, `-` prefix = DESC)
+ * - Pagination: `page=N&pageSize=N`
+ *
+ * Sieve has no per-model field selection, no relation includes, no flat
+ * column selection, and no global search parameter — the corresponding
+ * fluent methods throw the matching `Unsupported*Error`. PostgREST-native
+ * full-text search operators (`FTS`, `PHFTS`, `PLFTS`, `WFTS`) throw
+ * `UnsupportedFilterOperatorError`.
+ *
+ * @see https://github.com/Biarity/Sieve
+ */
+declare class SieveRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Filters, operator filters, sorts — no per-model fields, no includes,
+     * no flat select, no global search (use `CONTAINS` / `ILIKE` operator
+     * filters for partial matches)
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Sieve-native names of the three hardcoded query keys
+     *
+     * Sieve's model binder reads `filters`, `sorts`, and `pageSize` (the
+     * plural forms differ from the library-wide `filter` / `sort` /
+     * `limit` defaults); these keys are intentionally not configurable
+     * through `QueryBuilderOptions` and live as private statics so they
+     * are visible in one place.
+     */
+    private static readonly _filtersKey;
+    private static readonly _pageSizeKey;
+    private static readonly _sortsKey;
+    /**
+     * Emit Sieve-format query-string segments in canonical order:
+     * filters → sorts → page → pageSize
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration (used
+     * for `page`, whose default matches the wire format; the `filters` /
+     * `sorts` / `pageSize` keys are fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+    /**
+     * Append the single `filters=` parameter combining simple and operator
+     * filters
+     *
+     * Each term is one `Field{op}Value` expression; terms join with the
+     * comma (Sieve's AND). Simple single-value filters fold to `==`;
+     * simple multi-value filters fold to a value-level pipe OR
+     * (`field==v1|v2`).
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendFilters;
+    /**
+     * 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 pageSize parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendPageSize;
+    /**
+     * Append the `sorts=field,-other` CSV parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSorts;
+    /**
+     * Translate a `FilterOperatorEnum` operator filter into one or more
+     * Sieve `Field{op}Value` terms
+     *
+     * The mapping is library-canonical → Sieve-native:
+     * - `EQ` → `==`; `GT`/`GTE`/`LT`/`LTE` → `>` / `>=` / `<` / `<=`
+     * - `CONTAINS` → `@=`; `ILIKE` → `@=*` (case-insensitive contains)
+     * - `SW` → `_=` (starts with)
+     * - `IN` → `==` with a value-level pipe OR (`field==v1|v2`)
+     * - `BTW` → **two** AND-ed terms (`field>=min` and `field<=max`,
+     *   arity-checked)
+     * - `NOT` → `!=` — one term per value, AND-ed (`field!=v1,field!=v2`)
+     * - `NULL` → `==null` (when value is `true`) / `!=null` (when value is
+     *   `false`); arity- and type-checked
+     *
+     * PostgREST's full-text-search operators (`FTS`, `PHFTS`, `PLFTS`,
+     * `WFTS`) have no Sieve equivalent and throw
+     * `UnsupportedFilterOperatorError`.
+     *
+     * @param filter - The operator filter to translate
+     * @returns One or more `Field{op}Value` terms 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 Sieve (.NET) driver
+ *
+ * Sieve itself does not define a response envelope — it returns an
+ * `IQueryable` that the ASP.NET developer wraps in a paging DTO of their
+ * choosing. This strategy therefore ships a **sensible default mapping**
+ * for the common hand-rolled `PagedResult<T>` shape:
+ * ```json
+ * {
+ *   "data": [{ "id": 1, "title": "Hello" }],
+ *   "page": 2,
+ *   "pageSize": 10,
+ *   "total": 48,
+ *   "totalPages": 5
+ * }
+ * ```
+ *
+ * Every key path is configurable through `IConfig.response` (dot
+ * notation supported), so any wrapper shape — `{ items, meta: {...} }`,
+ * `{ results, pagination: {...} }` — can be mapped without subclassing.
+ * Defaults are encoded in `SieveResponseOptions`. `from`/`to` are
+ * computed from `page` × `pageSize` by the inherited traversal
+ * algorithm, and the navigation-URL slots resolve to `undefined` unless
+ * paths are provided.
+ *
+ * The dot-notation traversal is inherited from
+ * `AbstractDotPathResponseStrategy`; this class exists so
+ * `DriverEnum.SIEVE` resolves to a distinct identity at the DI layer.
+ *
+ * @see https://github.com/Biarity/Sieve
+ */
+declare class SieveResponseStrategy extends AbstractDotPathResponseStrategy {
+}
+
 /**
  * Request strategy for the Spatie Query Builder driver
  *
@@ -2141,6 +2737,155 @@ declare class SpatieRequestStrategy extends AbstractRequestStrategy {
 declare class SpatieResponseStrategy extends AbstractFlatResponseStrategy {
 }
 
+/**
+ * Request strategy for the Spring Data REST driver
+ *
+ * Generates URIs in [Spring Data REST's pagination format](https://docs.spring.io/spring-data/rest/reference/paging-and-sorting.html):
+ * - Sorts: `sort=field,asc&sort=other,desc` (repeatable param, one per rule)
+ * - Pagination: `page=N&size=N` — **`page` is 0-indexed on the wire**;
+ *   the library state stays 1-indexed and the strategy subtracts 1 at
+ *   emission time
+ *
+ * Spring Data REST defines no standard query parameter convention for
+ * filtering, field selection, includes, or global search — those are
+ * implemented server-side via custom query methods or Specifications.
+ * The corresponding fluent methods (`addFilter`, `addFilterOperator`,
+ * `addSelect`, `addFields`, `addIncludes`, `setSearch`) throw the
+ * matching `Unsupported*Error` on this driver.
+ *
+ * @see https://docs.spring.io/spring-data/rest/reference/paging-and-sorting.html
+ */
+declare class SpringRequestStrategy extends AbstractRequestStrategy {
+    /**
+     * Sorts only — Spring Data REST has no standard wire convention for
+     * filters, operator filters, per-model fields, flat select, includes,
+     * or global search
+     */
+    readonly capabilities: IStrategyCapabilities;
+    /**
+     * Spring-native name of the hardcoded page-size query key
+     *
+     * The wire format is fixed (Spring's `PageableHandlerMethodArgumentResolver`
+     * reads `size` by default); the key is intentionally not configurable
+     * through `QueryBuilderOptions` and lives as a private static so it is
+     * visible in one place.
+     */
+    private static readonly _sizeKey;
+    /**
+     * Emit Spring-format query-string segments in canonical order:
+     * sort → page → size
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration (used
+     * for `page` and `sort`, whose defaults match the wire format; the
+     * `size` key is fixed by the server)
+     * @returns Ordered query-string fragments
+     */
+    protected parts(state: IQueryBuilderState, options: QueryBuilderOptions): string[];
+    /**
+     * Append the 0-indexed page parameter
+     *
+     * The library state is 1-indexed (page 1 is the first page); Spring's
+     * `page` request parameter is 0-indexed, so the strategy subtracts 1
+     * at emission time.
+     *
+     * @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 size parameter
+     *
+     * @param state - The current query builder state
+     * @param out - The accumulator the caller joins into the URI
+     */
+    private _appendSize;
+    /**
+     * Append `sort=field,asc` params, one per sort rule (repeatable)
+     *
+     * Spring parses each `sort` occurrence independently — multiple rules
+     * are expressed by repeating the parameter, not by comma-joining the
+     * fields.
+     *
+     * @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 Spring Data REST driver
+ *
+ * Parses Spring Data REST's HAL envelope:
+ * ```json
+ * {
+ *   "_embedded": { "users": [{ "id": 1, "name": "John" }] },
+ *   "_links": {
+ *     "first": { "href": "..." },
+ *     "prev": { "href": "..." },
+ *     "next": { "href": "..." },
+ *     "last": { "href": "..." }
+ *   },
+ *   "page": { "size": 20, "totalElements": 100, "totalPages": 5, "number": 1 }
+ * }
+ * ```
+ *
+ * Two HAL quirks are absorbed here on top of the inherited dot-path
+ * traversal:
+ *
+ * - **`page.number` is 0-indexed** — the strategy adds 1 so the library
+ *   state stays 1-indexed (mirroring `SpringRequestStrategy`, which
+ *   subtracts 1 on the way out).
+ * - **The collection key under `_embedded` is the resource rel name**
+ *   (e.g. `_embedded.users`), which cannot be known statically. The
+ *   default `data` path is plain `_embedded`; when it resolves to an
+ *   object rather than an array, the strategy picks the first array
+ *   value inside it. Consumers with multiple embedded rels can pin the
+ *   exact path via `IConfig.response` (e.g. `data: '_embedded.users'`).
+ *
+ * Default key paths are configured in `SpringResponseOptions`.
+ *
+ * @see https://docs.spring.io/spring-data/rest/reference/paging-and-sorting.html
+ */
+declare class SpringResponseStrategy extends AbstractDotPathResponseStrategy {
+    /**
+     * Parse a Spring Data REST HAL 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>;
+    /**
+     * Resolve the 1-indexed current page from the 0-indexed `page.number`
+     *
+     * Falls back to page 1 when the path is missing entirely (defensive —
+     * Spring always emits the `page` block on paged endpoints).
+     *
+     * @param response - The raw response object
+     * @param options - The response key name configuration
+     * @returns The 1-indexed current page number
+     */
+    private _resolveCurrentPage;
+    /**
+     * Resolve the data array from the HAL `_embedded` wrapper
+     *
+     * When the configured path resolves directly to an array (a consumer
+     * pinned `data: '_embedded.users'`), it is used as-is. When it
+     * resolves to an object (the default `_embedded` path), the first
+     * array value inside it is used — Spring emits exactly one collection
+     * rel per listing endpoint. An empty array is returned when nothing
+     * matches (e.g. Spring omits `_embedded` on empty result sets).
+     *
+     * @param response - The raw response object
+     * @param options - The response key name configuration
+     * @returns The resolved data array (possibly empty)
+     */
+    private _resolveData;
+}
+
 /**
  * Request strategy for the Strapi driver
  *
@@ -2309,5 +3054,5 @@ declare class StrapiRequestStrategy extends AbstractRequestStrategy {
 declare class StrapiResponseStrategy extends AbstractDotPathResponseStrategy {
 }
 
-export { 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, NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationModeEnum, PaginationNotSyncedError, PaginationService, PostgrestRequestStrategy, PostgrestResponseStrategy, SortEnum, SpatieRequestStrategy, SpatieResponseStrategy, StrapiRequestStrategy, StrapiResponseStrategy, UnselectableModelError, UnsupportedFieldSelectionError, UnsupportedFilterError, UnsupportedFilterOperatorError, UnsupportedIncludesError, UnsupportedSearchError, UnsupportedSelectError, UnsupportedSortError, buildNgQubeeProviders, provideNgQubee, provideNgQubeeInstance, readHeader };
+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 };