ng-qubee 2.1.0 → 3.1.0

package/fesm2022/ng-qubee.mjs

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
-import { signal, computed, Injectable, Inject, Optional, NgModule, makeEnvironmentProviders } from '@angular/core';
-import * as qs from 'qs';
+import { signal, computed, Injectable, NgModule, makeEnvironmentProviders } from '@angular/core';
 import { BehaviorSubject, filter, throwError } from 'rxjs';
+import * as qs from 'qs';
 
 class KeyNotFoundError extends Error {
     constructor(key) {
@@ -66,18 +66,204 @@ class PaginatedCollection {
     }
 }
 
-var SortEnum;
-(function (SortEnum) {
-    SortEnum["ASC"] = "asc";
-    SortEnum["DESC"] = "desc";
-})(SortEnum || (SortEnum = {}));
+/**
+ * Enum representing the available pagination driver types
+ *
+ * Each driver encapsulates the full format knowledge for both
+ * request building (URI generation) and response parsing.
+ */
+var DriverEnum;
+(function (DriverEnum) {
+    DriverEnum["JSON_API"] = "json-api";
+    DriverEnum["LARAVEL"] = "laravel";
+    DriverEnum["NESTJS"] = "nestjs";
+    DriverEnum["SPATIE"] = "spatie";
+})(DriverEnum || (DriverEnum = {}));
 
-class UnselectableModelError extends Error {
-    constructor(model) {
-        super(`Unselectable Model: the selected model (${model}) is not present neither in the "model" property, nor in the includes object.`);
+/**
+ * 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'
+ * });
+ * ```
+ */
+class ResponseOptions {
+    currentPage;
+    data;
+    firstPageUrl;
+    from;
+    lastPage;
+    lastPageUrl;
+    nextPageUrl;
+    path;
+    perPage;
+    prevPageUrl;
+    to;
+    total;
+    constructor(options) {
+        this.currentPage = options.currentPage || 'current_page';
+        this.data = options.data || 'data';
+        this.firstPageUrl = options.firstPageUrl || 'first_page_url';
+        this.from = options.from || 'from';
+        this.lastPage = options.lastPage || 'last_page';
+        this.lastPageUrl = options.lastPageUrl || 'last_page_url';
+        this.nextPageUrl = options.nextPageUrl || 'next_page_url';
+        this.path = options.path || 'path';
+        this.perPage = options.perPage || 'per_page';
+        this.prevPageUrl = options.prevPageUrl || 'prev_page_url';
+        this.to = options.to || 'to';
+        this.total = options.total || 'total';
+    }
+}
+/**
+ * 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`.
+ */
+class JsonApiResponseOptions extends ResponseOptions {
+    constructor(options) {
+        super({
+            currentPage: options.currentPage || 'meta.current-page',
+            data: options.data || 'data',
+            firstPageUrl: options.firstPageUrl || 'links.first',
+            from: options.from || 'meta.from',
+            lastPage: options.lastPage || 'meta.page-count',
+            lastPageUrl: options.lastPageUrl || 'links.last',
+            nextPageUrl: options.nextPageUrl || 'links.next',
+            path: options.path || 'path',
+            perPage: options.perPage || 'meta.per-page',
+            prevPageUrl: options.prevPageUrl || 'links.prev',
+            to: options.to || 'meta.to',
+            total: options.total || 'meta.total'
+        });
+    }
+}
+/**
+ * Pre-configured ResponseOptions for the NestJS driver
+ *
+ * Uses dot-notation paths to access nested values in the NestJS response format.
+ */
+class NestjsResponseOptions extends ResponseOptions {
+    constructor(options) {
+        super({
+            currentPage: options.currentPage || 'meta.currentPage',
+            data: options.data || 'data',
+            firstPageUrl: options.firstPageUrl || 'links.first',
+            from: options.from || 'meta.from',
+            lastPage: options.lastPage || 'meta.totalPages',
+            lastPageUrl: options.lastPageUrl || 'links.last',
+            nextPageUrl: options.nextPageUrl || 'links.next',
+            path: options.path || 'path',
+            perPage: options.perPage || 'meta.itemsPerPage',
+            prevPageUrl: options.prevPageUrl || 'links.previous',
+            to: options.to || 'meta.to',
+            total: options.total || 'meta.totalItems'
+        });
+    }
+}
+
+/**
+ * Error thrown when per-model field selection is attempted with a driver that does not support it
+ *
+ * Per-model field selection is only supported by the Spatie driver.
+ * Use `addSelect()` for NestJS flat field selection.
+ */
+class UnsupportedFieldSelectionError extends Error {
+    constructor() {
+        super('Per-model field selection is only supported by the Spatie driver. Use addSelect() for NestJS.');
+        this.name = 'UnsupportedFieldSelectionError';
+    }
+}
+
+/**
+ * Error thrown when filters are attempted with a driver that does not support them
+ *
+ * Filters are only supported by the Spatie and NestJS drivers.
+ */
+class UnsupportedFilterError extends Error {
+    constructor() {
+        super('Filters are only supported by the Spatie and NestJS drivers.');
+        this.name = 'UnsupportedFilterError';
+    }
+}
+
+/**
+ * Error thrown when filter operators are attempted with a driver that does not support them
+ *
+ * Filter operators are only supported by the NestJS driver.
+ * Use `addFilter()` for Spatie implicit equality filters.
+ */
+class UnsupportedFilterOperatorError extends Error {
+    constructor() {
+        super('Filter operators are only supported by the NestJS driver. Use addFilter() for Spatie.');
+        this.name = 'UnsupportedFilterOperatorError';
+    }
+}
+
+/**
+ * Error thrown when includes are attempted with a driver that does not support them
+ *
+ * Includes are only supported by the Spatie driver.
+ */
+class UnsupportedIncludesError extends Error {
+    constructor() {
+        super('Includes are only supported by the Spatie driver.');
+        this.name = 'UnsupportedIncludesError';
+    }
+}
+
+/**
+ * Error thrown when search is attempted with a driver that does not support it
+ *
+ * Search is only supported by the NestJS driver.
+ */
+class UnsupportedSearchError extends Error {
+    constructor() {
+        super('Search is only supported by the NestJS driver.');
+        this.name = 'UnsupportedSearchError';
+    }
+}
+
+/**
+ * Error thrown when flat field selection is attempted with a driver that does not support it
+ *
+ * Flat field selection is only supported by the NestJS driver.
+ * Use `addFields()` for Spatie per-model field selection.
+ */
+class UnsupportedSelectError extends Error {
+    constructor() {
+        super('Flat field selection is only supported by the NestJS driver. Use addFields() for Spatie.');
+        this.name = 'UnsupportedSelectError';
+    }
+}
+
+/**
+ * Error thrown when sorts are attempted with a driver that does not support them
+ *
+ * Sorts are only supported by the Spatie and NestJS drivers.
+ */
+class UnsupportedSortError extends Error {
+    constructor() {
+        super('Sorts are only supported by the Spatie and NestJS drivers.');
+        this.name = 'UnsupportedSortError';
     }
 }
 
+/**
+ * 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.
+ */
 class QueryBuilderOptions {
     appends;
     fields;
@@ -85,7 +271,10 @@ class QueryBuilderOptions {
     includes;
     limit;
     page;
+    search;
+    select;
     sort;
+    sortBy;
     constructor(options) {
         this.appends = options.appends || 'append';
         this.fields = options.fields || 'fields';
@@ -93,176 +282,523 @@ class QueryBuilderOptions {
         this.includes = options.includes || 'include';
         this.limit = options.limit || 'limit';
         this.page = options.page || 'page';
+        this.search = options.search || 'search';
+        this.select = options.select || 'select';
         this.sort = options.sort || 'sort';
+        this.sortBy = options.sortBy || 'sortBy';
     }
 }
 
-class InvalidModelNameError extends Error {
-    constructor(model) {
-        super(`Invalid model name: Model name must be a non-empty string. Received: ${JSON.stringify(model)}`);
-        this.name = 'InvalidModelNameError';
-    }
-}
-
-class InvalidPageNumberError extends Error {
-    constructor(page) {
-        super(`Invalid page number: Page must be a positive integer greater than 0. Received: ${page}`);
-        this.name = 'InvalidPageNumberError';
-    }
-}
-
-class InvalidLimitError extends Error {
-    constructor(limit) {
-        super(`Invalid limit value: Limit must be a positive integer greater than 0. Received: ${limit}`);
-        this.name = 'InvalidLimitError';
-    }
-}
-
-const INITIAL_STATE = {
-    baseUrl: '',
-    fields: {},
-    filters: {},
-    includes: [],
-    limit: 15,
-    model: '',
-    page: 1,
-    sorts: []
-};
-class NestService {
+class NgQubeeService {
+    _nestService;
     /**
-     * Private writable signal that holds the Query Builder state
-     *
-     * @type {IQueryBuilderState}
+     * The active pagination driver
      */
-    _nest = signal(this._clone(INITIAL_STATE));
+    _driver;
     /**
-     * A computed signal that makes readonly the writable signal _nest
-     *
-     * @type {Signal<IQueryBuilderState>}
+     * Resolved query parameter key name options
      */
-    nest = computed(() => this._clone(this._nest()));
-    constructor() {
-        // Nothing to see here 👮🏻‍♀️
-    }
+    _options;
     /**
-     * Set the base URL for the API
-     *
-     * @param {string} baseUrl - The base URL to prepend to generated URIs
-     * @example
-     * service.baseUrl = 'https://api.example.com';
+     * The request strategy that builds URIs for the active driver
      */
-    set baseUrl(baseUrl) {
-        this._nest.update(nest => ({
-            ...nest,
-            baseUrl
-        }));
+    _requestStrategy;
+    /**
+     * Internal BehaviorSubject that holds the latest generated URI
+     */
+    _uri$ = new BehaviorSubject('');
+    /**
+     * Observable that emits non-empty generated URIs
+     */
+    uri$ = this._uri$.asObservable().pipe(filter(uri => !!uri));
+    constructor(_nestService, requestStrategy, driver, options = {}) {
+        this._nestService = _nestService;
+        this._driver = driver;
+        this._options = new QueryBuilderOptions(options);
+        this._requestStrategy = requestStrategy;
     }
     /**
-     * Set the limit for paginated results
-     * Must be a positive integer greater than 0
+     * Assert that the active driver is one of the allowed drivers
      *
-     * @param {number} limit - The number of items per page
-     * @throws {InvalidLimitError} If limit is not a positive integer
-     * @example
-     * service.limit = 25;
+     * @param allowed - The allowed drivers
+     * @param error - The error to throw if the driver is not allowed
+     * @throws The provided error if the active driver is not in the allowed list
      */
-    set limit(limit) {
-        this._validateLimit(limit);
-        this._nest.update(nest => ({
-            ...nest,
-            limit
-        }));
+    _assertDriver(allowed, error) {
+        if (!allowed.includes(this._driver)) {
+            throw error;
+        }
     }
     /**
-     * Set the model name for the query
-     * Must be a non-empty string
+     * Add fields to the select statement for the given model (JSON:API and Spatie only)
      *
-     * @param {string} model - The model/resource name (e.g., 'users', 'posts')
-     * @throws {InvalidModelNameError} If model is not a non-empty string
-     * @example
-     * service.model = 'users';
+     * @param model - Model that holds the fields
+     * @param fields - Fields to select
+     * @returns {this}
+     * @throws {UnsupportedFieldSelectionError} If the active driver does not support per-model field selection
      */
-    set model(model) {
-        this._validateModelName(model);
-        this._nest.update(nest => ({
-            ...nest,
-            model
-        }));
+    addFields(model, fields) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.SPATIE], new UnsupportedFieldSelectionError());
+        if (!fields.length) {
+            return this;
+        }
+        this._nestService.addFields({ [model]: fields });
+        return this;
     }
     /**
-     * Set the page number for pagination
-     * Must be a positive integer greater than 0
+     * Add a filter with the given value(s) (JSON:API, NestJS, and Spatie)
      *
-     * @param {number} page - The page number to fetch
-     * @throws {InvalidPageNumberError} If page is not a positive integer
-     * @example
-     * service.page = 2;
+     * Produces: `filter[field]=value` (JSON:API / Spatie) or `filter.field=value` (NestJS)
+     *
+     * @param {string} field - Name of the field to filter
+     * @param {(string | number | boolean)[]} values - The needle(s)
+     * @returns {this}
+     * @throws {UnsupportedFilterError} If the active driver does not support filters
      */
-    set page(page) {
-        this._validatePageNumber(page);
-        this._nest.update(nest => ({
-            ...nest,
-            page
-        }));
-    }
-    _clone(obj) {
-        return JSON.parse(JSON.stringify(obj));
+    addFilter(field, ...values) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.NESTJS, DriverEnum.SPATIE], new UnsupportedFilterError());
+        if (!values.length) {
+            return this;
+        }
+        this._nestService.addFilters({
+            [field]: values
+        });
+        return this;
     }
     /**
-     * Validates that the model name is a non-empty string
+     * Add a filter with an explicit operator (NestJS only)
      *
-     * @param {string} model - The model name to validate
-     * @throws {InvalidModelNameError} If model is not a non-empty string
-     * @private
+     * Produces: `filter.field=$operator:value`
+     *
+     * @param {string} field - Name of the field to filter
+     * @param {FilterOperatorEnum} operator - The filter operator to apply
+     * @param {(string | number | boolean)[]} values - The value(s) for the filter
+     * @returns {this}
+     * @throws {UnsupportedFilterOperatorError} If the active driver does not support filter operators
      */
-    _validateModelName(model) {
-        if (!model || typeof model !== 'string' || model.trim().length === 0) {
-            throw new InvalidModelNameError(model);
+    addFilterOperator(field, operator, ...values) {
+        this._assertDriver([DriverEnum.NESTJS], new UnsupportedFilterOperatorError());
+        if (!values.length) {
+            return this;
         }
+        this._nestService.addOperatorFilters([{ field, operator, values }]);
+        return this;
     }
     /**
-     * Validates that the page number is a positive integer
+     * Add related entities to include in the request (JSON:API and Spatie only)
      *
-     * @param {number} page - The page number to validate
-     * @throws {InvalidPageNumberError} If page is not a positive integer
-     * @private
+     * @param {string[]} models - Models to include
+     * @returns {this}
+     * @throws {UnsupportedIncludesError} If the active driver does not support includes
      */
-    _validatePageNumber(page) {
-        if (!Number.isInteger(page) || page < 1) {
-            throw new InvalidPageNumberError(page);
+    addIncludes(...models) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.SPATIE], new UnsupportedIncludesError());
+        if (!models.length) {
+            return this;
         }
+        this._nestService.addIncludes(models);
+        return this;
     }
     /**
-     * Validates that the limit is a positive integer
+     * Add flat field selection (NestJS only)
      *
-     * @param {number} limit - The limit value to validate
-     * @throws {InvalidLimitError} If limit is not a positive integer
-     * @private
+     * Produces: `select=col1,col2`
+     *
+     * @param {string[]} fields - Fields to select
+     * @returns {this}
+     * @throws {UnsupportedSelectError} If the active driver does not support flat field selection
      */
-    _validateLimit(limit) {
-        if (!Number.isInteger(limit) || limit < 1) {
-            throw new InvalidLimitError(limit);
+    addSelect(...fields) {
+        this._assertDriver([DriverEnum.NESTJS], new UnsupportedSelectError());
+        if (!fields.length) {
+            return this;
         }
+        this._nestService.addSelect(fields);
+        return this;
     }
     /**
-     * Add selectable fields for the given model to the request
-     * Automatically prevents duplicate fields for each model
+     * Add a field with a sort criteria (JSON:API, NestJS, and Spatie)
      *
-     * @param {IFields} fields - Object mapping model names to arrays of field names
-     * @return {void}
-     * @example
-     * service.addFields({ users: ['id', 'email', 'username'] });
-     * service.addFields({ posts: ['title', 'content'] });
+     * @param field - Field to use for sorting
+     * @param {SortEnum} order - A value from the SortEnum enumeration
+     * @returns {this}
+     * @throws {UnsupportedSortError} If the active driver does not support sorts
      */
-    addFields(fields) {
-        this._nest.update(nest => {
-            const mergedFields = { ...nest.fields };
-            Object.keys(fields).forEach(model => {
-                const existingFields = mergedFields[model] || [];
-                const newFields = fields[model];
-                // Use Set to prevent duplicates
-                const uniqueFields = Array.from(new Set([...existingFields, ...newFields]));
-                mergedFields[model] = uniqueFields;
+    addSort(field, order) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.NESTJS, DriverEnum.SPATIE], new UnsupportedSortError());
+        this._nestService.addSort({
+            field,
+            order
+        });
+        return 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']
+     * });
+     * ```
+     *
+     * @param {IFields} fields - Object mapping model names to field arrays to remove
+     * @returns {this}
+     * @throws {UnsupportedFieldSelectionError} If the active driver does not support per-model field selection
+     */
+    deleteFields(fields) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.SPATIE], new UnsupportedFieldSelectionError());
+        this._nestService.deleteFields(fields);
+        return this;
+    }
+    /**
+     * Delete selected fields for the given model in the current query builder state (JSON:API and Spatie only)
+     *
+     * ```
+     * ngQubeeService.deleteFieldsByModel('users', 'email', 'password');
+     * ```
+     *
+     * @param model - Model that holds the fields
+     * @param {string[]} fields - Fields to delete from the state
+     * @returns {this}
+     * @throws {UnsupportedFieldSelectionError} If the active driver does not support per-model field selection
+     */
+    deleteFieldsByModel(model, ...fields) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.SPATIE], new UnsupportedFieldSelectionError());
+        if (!fields.length) {
+            return this;
+        }
+        this._nestService.deleteFields({
+            [model]: fields
+        });
+        return this;
+    }
+    /**
+     * Remove given filters from the query builder state (JSON:API, NestJS, and Spatie)
+     *
+     * @param {string[]} filters - Filters to remove
+     * @returns {this}
+     * @throws {UnsupportedFilterError} If the active driver does not support filters
+     */
+    deleteFilters(...filters) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.NESTJS, DriverEnum.SPATIE], new UnsupportedFilterError());
+        if (!filters.length) {
+            return this;
+        }
+        this._nestService.deleteFilters(...filters);
+        return this;
+    }
+    /**
+     * Remove selected related models from the query builder state (JSON:API and Spatie only)
+     *
+     * @param {string[]} includes - Models to remove
+     * @returns {this}
+     * @throws {UnsupportedIncludesError} If the active driver does not support includes
+     */
+    deleteIncludes(...includes) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.SPATIE], new UnsupportedIncludesError());
+        if (!includes.length) {
+            return this;
+        }
+        this._nestService.deleteIncludes(...includes);
+        return this;
+    }
+    /**
+     * Remove operator filters by field name (NestJS only)
+     *
+     * @param {string[]} fields - Field names of operator filters to remove
+     * @returns {this}
+     * @throws {UnsupportedFilterOperatorError} If the active driver does not support filter operators
+     */
+    deleteOperatorFilters(...fields) {
+        this._assertDriver([DriverEnum.NESTJS], new UnsupportedFilterOperatorError());
+        if (!fields.length) {
+            return this;
+        }
+        this._nestService.deleteOperatorFilters(...fields);
+        return this;
+    }
+    /**
+     * Remove search term from the query builder state (NestJS only)
+     *
+     * @returns {this}
+     * @throws {UnsupportedSearchError} If the active driver does not support search
+     */
+    deleteSearch() {
+        this._assertDriver([DriverEnum.NESTJS], new UnsupportedSearchError());
+        this._nestService.deleteSearch();
+        return this;
+    }
+    /**
+     * Remove flat field selections from the query builder state (NestJS only)
+     *
+     * @param {string[]} fields - Fields to remove from selection
+     * @returns {this}
+     * @throws {UnsupportedSelectError} If the active driver does not support flat field selection
+     */
+    deleteSelect(...fields) {
+        this._assertDriver([DriverEnum.NESTJS], new UnsupportedSelectError());
+        if (!fields.length) {
+            return this;
+        }
+        this._nestService.deleteSelect(...fields);
+        return this;
+    }
+    /**
+     * Remove sort rules from the query builder state (JSON:API, NestJS, and Spatie)
+     *
+     * @param sorts - Fields used for sorting to remove
+     * @returns {this}
+     * @throws {UnsupportedSortError} If the active driver does not support sorts
+     */
+    deleteSorts(...sorts) {
+        this._assertDriver([DriverEnum.JSON_API, DriverEnum.NESTJS, DriverEnum.SPATIE], new UnsupportedSortError());
+        this._nestService.deleteSorts(...sorts);
+        return this;
+    }
+    /**
+     * Generate a URI accordingly to the given data and active driver
+     *
+     * @returns {Observable<string>} An observable that emits the generated URI
+     */
+    generateUri() {
+        try {
+            this._uri$.next(this._requestStrategy.buildUri(this._nestService.nest(), this._options));
+            return this.uri$;
+        }
+        catch (error) {
+            return throwError(() => error);
+        }
+    }
+    /**
+     * Clear the current state and reset the Query Builder to a fresh, clean condition
+     *
+     * @returns {this}
+     */
+    reset() {
+        this._nestService.reset();
+        return this;
+    }
+    /**
+     * Set the base URL to use for composing the address
+     *
+     * @param {string} baseUrl - The base URL
+     * @returns {this}
+     */
+    setBaseUrl(baseUrl) {
+        this._nestService.baseUrl = baseUrl;
+        return this;
+    }
+    /**
+     * Set the items per page number
+     *
+     * Validation is delegated to the active request strategy because the
+     * accepted range is driver-specific: nestjs-paginate additionally accepts
+     * `-1` as a "fetch all" sentinel, while Laravel, Spatie, and JSON:API
+     * require a positive integer.
+     *
+     * @param limit - Number of items per page (or `-1` to fetch all, NestJS only)
+     * @returns {this}
+     * @throws {import('../errors/invalid-limit.error').InvalidLimitError} If the value is not accepted by the active driver
+     */
+    setLimit(limit) {
+        this._requestStrategy.validateLimit(limit);
+        this._nestService.limit = limit;
+        return this;
+    }
+    /**
+     * Set the page that the backend will use to paginate the result set
+     *
+     * @param page - Page number
+     * @returns {this}
+     */
+    setPage(page) {
+        this._nestService.page = page;
+        return this;
+    }
+    /**
+     * Set the API resource to run the query against
+     *
+     * @param {string} resource - Resource name (e.g. 'users' produces /users)
+     * @returns {this}
+     */
+    setResource(resource) {
+        this._nestService.resource = resource;
+        return this;
+    }
+    /**
+     * Set the search term for full-text search (NestJS only)
+     *
+     * Produces: `search=term`
+     *
+     * @param {string} search - The search term
+     * @returns {this}
+     * @throws {UnsupportedSearchError} If the active driver does not support search
+     */
+    setSearch(search) {
+        this._assertDriver([DriverEnum.NESTJS], new UnsupportedSearchError());
+        this._nestService.setSearch(search);
+        return this;
+    }
+}
+
+/**
+ * Error thrown when an invalid resource name is provided
+ *
+ * Resource name must be a non-empty string.
+ */
+class InvalidResourceNameError extends Error {
+    constructor(resource) {
+        super(`Invalid resource name: Resource name must be a non-empty string. Received: ${JSON.stringify(resource)}`);
+        this.name = 'InvalidResourceNameError';
+    }
+}
+
+class InvalidPageNumberError extends Error {
+    constructor(page) {
+        super(`Invalid page number: Page must be a positive integer greater than 0. Received: ${page}`);
+        this.name = 'InvalidPageNumberError';
+    }
+}
+
+const INITIAL_STATE = {
+    baseUrl: '',
+    fields: {},
+    filters: {},
+    includes: [],
+    limit: 15,
+    operatorFilters: [],
+    page: 1,
+    resource: '',
+    search: '',
+    select: [],
+    sorts: []
+};
+class NestService {
+    /**
+     * Private writable signal that holds the Query Builder state
+     *
+     * @type {IQueryBuilderState}
+     */
+    _nest = signal(this._clone(INITIAL_STATE), ...(ngDevMode ? [{ debugName: "_nest" }] : []));
+    /**
+     * A computed signal that makes readonly the writable signal _nest
+     *
+     * @type {Signal<IQueryBuilderState>}
+     */
+    nest = computed(() => this._clone(this._nest()), ...(ngDevMode ? [{ debugName: "nest" }] : []));
+    constructor() {
+        // Nothing to see here
+    }
+    /**
+     * Set the base URL for the API
+     *
+     * @param {string} baseUrl - The base URL to prepend to generated URIs
+     * @example
+     * service.baseUrl = 'https://api.example.com';
+     */
+    set baseUrl(baseUrl) {
+        this._nest.update(nest => ({
+            ...nest,
+            baseUrl
+        }));
+    }
+    /**
+     * Set the limit for paginated results
+     *
+     * This setter performs a raw state write. Validation of the value is the
+     * responsibility of the active request strategy and is enforced upstream
+     * by `NgQubeeService.setLimit()`, because the accepted range depends on
+     * the driver (e.g. nestjs-paginate accepts `-1` for "fetch all").
+     *
+     * @param {number} limit - The number of items per page
+     * @example
+     * service.limit = 25;
+     */
+    set limit(limit) {
+        this._nest.update(nest => ({
+            ...nest,
+            limit
+        }));
+    }
+    /**
+     * Set the page number for pagination
+     * Must be a positive integer greater than 0
+     *
+     * @param {number} page - The page number to fetch
+     * @throws {InvalidPageNumberError} If page is not a positive integer
+     * @example
+     * service.page = 2;
+     */
+    set page(page) {
+        this._validatePageNumber(page);
+        this._nest.update(nest => ({
+            ...nest,
+            page
+        }));
+    }
+    /**
+     * Set the resource name for the query
+     * Must be a non-empty string
+     *
+     * @param {string} resource - The API resource name (e.g., 'users', 'posts')
+     * @throws {InvalidResourceNameError} If resource is not a non-empty string
+     * @example
+     * service.resource = 'users';
+     */
+    set resource(resource) {
+        this._validateResourceName(resource);
+        this._nest.update(nest => ({
+            ...nest,
+            resource
+        }));
+    }
+    _clone(obj) {
+        return JSON.parse(JSON.stringify(obj));
+    }
+    /**
+     * Validates that the page number is a positive integer
+     *
+     * @param {number} page - The page number to validate
+     * @throws {InvalidPageNumberError} If page is not a positive integer
+     * @private
+     */
+    _validatePageNumber(page) {
+        if (!Number.isInteger(page) || page < 1) {
+            throw new InvalidPageNumberError(page);
+        }
+    }
+    /**
+     * Validates that the resource name is a non-empty string
+     *
+     * @param {string} resource - The resource name to validate
+     * @throws {InvalidResourceNameError} If resource is not a non-empty string
+     * @private
+     */
+    _validateResourceName(resource) {
+        if (!resource || typeof resource !== 'string' || resource.trim().length === 0) {
+            throw new InvalidResourceNameError(resource);
+        }
+    }
+    /**
+     * Add selectable fields for the given model to the request
+     * Automatically prevents duplicate fields for each model
+     *
+     * @param {IFields} fields - Object mapping model names to arrays of field names
+     * @return {void}
+     * @example
+     * service.addFields({ users: ['id', 'email', 'username'] });
+     * service.addFields({ posts: ['title', 'content'] });
+     */
+    addFields(fields) {
+        this._nest.update(nest => {
+            const mergedFields = { ...nest.fields };
+            Object.keys(fields).forEach(model => {
+                const existingFields = mergedFields[model] || [];
+                const newFields = fields[model];
+                // Use Set to prevent duplicates
+                const uniqueFields = Array.from(new Set([...existingFields, ...newFields]));
+                mergedFields[model] = uniqueFields;
             });
             return {
                 ...nest,
@@ -292,27 +828,77 @@ class NestService {
             });
             return {
                 ...nest,
-                filters: mergedFilters
+                filters: mergedFilters
+            };
+        });
+    }
+    /**
+     * Add resources to include with the request
+     * Automatically prevents duplicate includes
+     *
+     * @param {string[]} includes - Array of resource names to include in the response
+     * @return {void}
+     * @example
+     * service.addIncludes(['profile', 'posts']);
+     * service.addIncludes(['comments']);
+     */
+    addIncludes(includes) {
+        this._nest.update(nest => {
+            // Use Set to prevent duplicates
+            const uniqueIncludes = Array.from(new Set([...nest.includes, ...includes]));
+            return {
+                ...nest,
+                includes: uniqueIncludes
+            };
+        });
+    }
+    /**
+     * Add filters with explicit operators (NestJS only)
+     * Automatically prevents duplicate operator filters for the same field + operator combination
+     *
+     * @param {IOperatorFilter[]} filters - Array of operator filter configurations
+     * @return {void}
+     * @example
+     * import { FilterOperatorEnum } from 'ng-qubee';
+     * service.addOperatorFilters([{ field: 'age', operator: FilterOperatorEnum.GTE, values: [18] }]);
+     */
+    addOperatorFilters(filters) {
+        this._nest.update(nest => {
+            const merged = [...nest.operatorFilters];
+            filters.forEach(newFilter => {
+                const existingIdx = merged.findIndex(f => f.field === newFilter.field && f.operator === newFilter.operator);
+                if (existingIdx > -1) {
+                    const existingValues = merged[existingIdx].values;
+                    merged[existingIdx] = {
+                        ...merged[existingIdx],
+                        values: Array.from(new Set([...existingValues, ...newFilter.values]))
+                    };
+                }
+                else {
+                    merged.push({ ...newFilter });
+                }
+            });
+            return {
+                ...nest,
+                operatorFilters: merged
             };
         });
     }
     /**
-     * Add resources to include with the request
-     * Automatically prevents duplicate includes
+     * Add flat field selection columns (NestJS only)
+     * Automatically prevents duplicate select fields
      *
-     * @param {string[]} includes - Array of model names to include in the response
+     * @param {string[]} fields - Array of column names to select
      * @return {void}
      * @example
-     * service.addIncludes(['profile', 'posts']);
-     * service.addIncludes(['comments']);
+     * service.addSelect(['id', 'name', 'email']);
      */
-    addIncludes(includes) {
+    addSelect(fields) {
         this._nest.update(nest => {
-            // Use Set to prevent duplicates
-            const uniqueIncludes = Array.from(new Set([...nest.includes, ...includes]));
+            const uniqueSelect = Array.from(new Set([...nest.select, ...fields]));
             return {
                 ...nest,
-                includes: uniqueIncludes
+                select: uniqueSelect
             };
         });
     }
@@ -390,6 +976,49 @@ class NestService {
             includes: nest.includes.filter(v => !includes.includes(v))
         }));
     }
+    /**
+     * Remove operator filters by field name (NestJS only)
+     *
+     * @param {...string[]} fields - Field names of operator filters to remove
+     * @return {void}
+     * @example
+     * service.deleteOperatorFilters('age');
+     * service.deleteOperatorFilters('price', 'quantity');
+     */
+    deleteOperatorFilters(...fields) {
+        this._nest.update(nest => ({
+            ...nest,
+            operatorFilters: nest.operatorFilters.filter(f => !fields.includes(f.field))
+        }));
+    }
+    /**
+     * Remove the search term from the state (NestJS only)
+     *
+     * @return {void}
+     * @example
+     * service.deleteSearch();
+     */
+    deleteSearch() {
+        this._nest.update(nest => ({
+            ...nest,
+            search: ''
+        }));
+    }
+    /**
+     * Remove flat field selections from the state (NestJS only)
+     *
+     * @param {...string[]} fields - Field names to remove from selection
+     * @return {void}
+     * @example
+     * service.deleteSelect('email');
+     * service.deleteSelect('name', 'email');
+     */
+    deleteSelect(...fields) {
+        this._nest.update(nest => ({
+            ...nest,
+            select: nest.select.filter(f => !fields.includes(f))
+        }));
+    }
     /**
      * Remove sorts from the request by field name
      *
@@ -412,6 +1041,20 @@ class NestService {
             sorts: s
         }));
     }
+    /**
+     * Set the full-text search term (NestJS only)
+     *
+     * @param {string} search - The search term
+     * @return {void}
+     * @example
+     * service.setSearch('john doe');
+     */
+    setSearch(search) {
+        this._nest.update(nest => ({
+            ...nest,
+            search
+        }));
+    }
     /**
      * Reset the query builder state to initial values
      * Clears all fields, filters, includes, sorts, and resets pagination
@@ -419,385 +1062,1018 @@ class NestService {
      * @return {void}
      * @example
      * service.reset();
-     * // State is now: { baseUrl: '', fields: {}, filters: {}, includes: [], limit: 15, model: '', page: 1, sorts: [] }
      */
     reset() {
         this._nest.update(_ => this._clone(INITIAL_STATE));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NestService });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: NestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: NestService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NestService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: NestService, decorators: [{
             type: Injectable
         }], ctorParameters: () => [] });
 
-class NgQubeeService {
-    _nestService;
+class PaginationService {
+    /**
+     * Resolved response key name options
+     */
     _options;
     /**
-     * This property serves as an accumulator for holding the composed string with each query param
+     * The response strategy that parses responses for the active driver
+     */
+    _responseStrategy;
+    constructor(responseStrategy, options = {}) {
+        this._options = new ResponseOptions(options);
+        this._responseStrategy = responseStrategy;
+    }
+    /**
+     * Transform a raw API response into a typed PaginatedCollection
+     *
+     * Delegates to the active driver's response strategy for parsing.
+     *
+     * @param response - The raw API response object
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response) {
+        return this._responseStrategy.paginate(response, this._options);
+    }
+}
+
+var SortEnum;
+(function (SortEnum) {
+    SortEnum["ASC"] = "asc";
+    SortEnum["DESC"] = "desc";
+})(SortEnum || (SortEnum = {}));
+
+/**
+ * Thrown when a limit value does not satisfy the active driver's constraints
+ *
+ * Validation is driver-scoped: most drivers require an integer `>= 1`, while
+ * the NestJS driver additionally accepts `-1` as a "fetch all items" sentinel
+ * (as documented by nestjs-paginate). The message is tailored accordingly so
+ * the caller understands which values are permitted.
+ */
+class InvalidLimitError extends Error {
+    /**
+     * @param limit - The rejected limit value
+     * @param allowFetchAll - Whether the active driver accepts `-1` (fetch all)
+     */
+    constructor(limit, allowFetchAll = false) {
+        const allowed = allowFetchAll
+            ? 'a positive integer greater than 0, or -1 to fetch all items'
+            : 'a positive integer greater than 0';
+        super(`Invalid limit value: Limit must be ${allowed}. Received: ${limit}`);
+        this.name = 'InvalidLimitError';
+    }
+}
+
+class UnselectableModelError extends Error {
+    constructor(model) {
+        super(`Unselectable Model: the selected model (${model}) is not present neither in the "model" property, nor in the includes object.`);
+    }
+}
+
+/**
+ * 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/
+ */
+class JsonApiRequestStrategy {
+    /**
+     * Accumulator for composing the URI string
      */
     _uri = '';
-    _uri$ = new BehaviorSubject('');
-    uri$ = this._uri$.asObservable().pipe(filter(uri => !!uri));
-    constructor(_nestService, options = {}) {
-        this._nestService = _nestService;
-        this._options = new QueryBuilderOptions(options);
+    /**
+     * Build a URI string from the given state using the JSON:API format
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The composed URI string
+     * @throws Error if resource is not set
+     */
+    buildUri(state, options) {
+        if (!state.resource) {
+            throw new Error('Set the resource property BEFORE adding filters or calling the url() / get() methods');
+        }
+        this._uri = '';
+        this._parseIncludes(state, options);
+        this._parseFields(state, options);
+        this._parseFilters(state, options);
+        this._parsePagination(state, options);
+        this._parseSort(state, options);
+        return this._uri;
+    }
+    /**
+     * Validate that the given limit is accepted by the JSON:API driver
+     *
+     * The JSON:API specification leaves pagination semantics to the server and
+     * does not define a "fetch all" sentinel, so only positive integers are
+     * accepted.
+     *
+     * @param limit - The limit value to validate
+     * @throws {InvalidLimitError} If the value is not a positive integer
+     */
+    validateLimit(limit) {
+        if (Number.isInteger(limit) && limit >= 1) {
+            return;
+        }
+        throw new InvalidLimitError(limit);
     }
-    _parseFields(s) {
-        if (!Object.keys(s.fields).length) {
+    /**
+     * Parse and append field selection parameters
+     *
+     * Validates that each field model exists either as the main resource
+     * or in the includes list. Fields are grouped by type in bracket notation.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated field selection parameter string
+     * @throws Error if resource is required but not set
+     * @throws UnselectableModelError if a field model is not in resource or includes
+     */
+    _parseFields(state, options) {
+        if (!Object.keys(state.fields).length) {
             return this._uri;
         }
-        if (!s.model) {
-            throw new Error('While selecting fields, the -> model <- is required');
+        if (!state.resource) {
+            throw new Error('While selecting fields, the -> resource <- is required');
         }
-        if (!(s.model in s.fields)) {
-            throw new Error(`Key ${s.model} is missing in the fields object`);
+        if (!(state.resource in state.fields)) {
+            throw new Error(`Key ${state.resource} is missing in the fields object`);
         }
         const f = {};
-        for (const k in s.fields) {
-            if (s.fields.hasOwnProperty(k)) {
-                // Check if the key is the model or is declared in "includes".
-                // If not, it means that has not been selected anywhere and that will cause an error on the API
-                if (k !== s.model && !s.includes.includes(k)) {
+        for (const k in state.fields) {
+            if (state.fields.hasOwnProperty(k)) {
+                if (k !== state.resource && !state.includes.includes(k)) {
                     throw new UnselectableModelError(k);
                 }
-                Object.assign(f, { [`${this._options.fields}[${k}]`]: s.fields[k].join(',') });
+                Object.assign(f, { [`${options.fields}[${k}]`]: state.fields[k].join(',') });
             }
         }
-        const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;
+        const param = `${this._prepend(state)}${qs.stringify(f, { encode: false })}`;
         this._uri += param;
         return param;
     }
-    _parseFilters(s) {
-        const keys = Object.keys(s.filters);
+    /**
+     * Parse and append filter parameters
+     *
+     * Generates filter parameters in bracket notation: `filter[key]=value1,value2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated filter parameter string
+     */
+    _parseFilters(state, options) {
+        const keys = Object.keys(state.filters);
         if (!keys.length) {
             return this._uri;
         }
         const f = {
-            [`${this._options.filters}`]: keys.reduce((acc, key) => {
-                return Object.assign(acc, { [key]: s.filters[key].join(',') });
+            [`${options.filters}`]: keys.reduce((acc, key) => {
+                return Object.assign(acc, { [key]: state.filters[key].join(',') });
             }, {})
         };
-        const param = `${this._prepend(s.model)}${qs.stringify(f, { encode: false })}`;
+        const param = `${this._prepend(state)}${qs.stringify(f, { encode: false })}`;
         this._uri += param;
         return param;
     }
-    _parseIncludes(s) {
-        if (!s.includes.length) {
+    /**
+     * Parse and append include parameters
+     *
+     * Generates: `include=author,comments.author`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated include parameter string
+     */
+    _parseIncludes(state, options) {
+        if (!state.includes.length) {
             return this._uri;
         }
-        const param = `${this._prepend(s.model)}${this._options.includes}=${s.includes}`;
-        this._uri += param;
-        return param;
-    }
-    _parseLimit(s) {
-        const param = `${this._prepend(s.model)}${this._options.limit}=${s.limit}`;
+        const param = `${this._prepend(state)}${options.includes}=${state.includes}`;
         this._uri += param;
         return param;
     }
-    _parsePage(s) {
-        const param = `${this._prepend(s.model)}${this._options.page}=${s.page}`;
+    /**
+     * Parse and append pagination parameters in JSON:API bracket notation
+     *
+     * Generates: `page[number]=1&page[size]=15`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated pagination parameter string
+     */
+    _parsePagination(state, options) {
+        const pagination = qs.stringify({ [options.page]: { number: state.page, size: state.limit } }, { encode: false });
+        const param = `${this._prepend(state)}${pagination}`;
         this._uri += param;
         return param;
     }
-    _parseSort(s) {
+    /**
+     * Parse and append sort parameters
+     *
+     * Generates: `sort=-field1,field2` where `-` prefix indicates DESC order
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated sort parameter string
+     */
+    _parseSort(state, options) {
         let param = '';
-        if (!s.sorts.length) {
+        if (!state.sorts.length) {
             return param;
         }
-        param = `${this._prepend(s.model)}${this._options.sort}=`;
-        s.sorts.forEach((sort, idx) => {
+        param = `${this._prepend(state)}${options.sort}=`;
+        state.sorts.forEach((sort, idx) => {
             param += `${sort.order === SortEnum.DESC ? '-' : ''}${sort.field}`;
-            if (idx < s.sorts.length - 1) {
+            if (idx < state.sorts.length - 1) {
                 param += ',';
             }
         });
         this._uri += param;
         return param;
     }
-    _parse(s) {
-        if (!s.model) {
-            throw new Error('Set the model property BEFORE adding filters or calling the url() / get() methods');
+    /**
+     * Determine the appropriate URI prefix based on the current accumulator state
+     *
+     * Returns the full base path with `?` for the first parameter,
+     * or `&` for subsequent parameters.
+     *
+     * @param state - The current query builder state
+     * @returns The prefix string to prepend to the next parameter
+     */
+    _prepend(state) {
+        if (this._uri) {
+            return '&';
+        }
+        return state.baseUrl ? `${state.baseUrl}/${state.resource}?` : `/${state.resource}?`;
+    }
+}
+
+/**
+ * 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"
+ *   }
+ * }
+ * ```
+ *
+ * @see https://jsonapi.org/format/
+ */
+class JsonApiResponseStrategy {
+    /**
+     * Parse a JSON:API pagination response into a PaginatedCollection
+     *
+     * Supports dot-notation key paths for accessing nested values.
+     * Computes `from` and `to` from `currentPage` and `perPage` when
+     * they are not directly available in the response.
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        const data = this._resolve(response, options.data);
+        const currentPage = this._resolve(response, options.currentPage);
+        const total = this._resolve(response, options.total);
+        const perPage = this._resolve(response, options.perPage);
+        const lastPage = this._resolve(response, options.lastPage);
+        // Compute from/to if not directly available
+        const from = this._resolveFrom(response, options, currentPage, perPage);
+        const to = this._resolveTo(response, options, currentPage, perPage, total);
+        const prevPageUrl = this._resolve(response, options.prevPageUrl);
+        const nextPageUrl = this._resolve(response, options.nextPageUrl);
+        const firstPageUrl = this._resolve(response, options.firstPageUrl);
+        const lastPageUrl = this._resolve(response, options.lastPageUrl);
+        return new PaginatedCollection(data, currentPage, from, to, total, perPage, prevPageUrl, nextPageUrl, lastPage, firstPageUrl, lastPageUrl);
+    }
+    /**
+     * Resolve a value from a response object using a dot-notation path
+     *
+     * Supports both flat keys ('data') and nested paths ('meta.current-page').
+     *
+     * @param response - The raw response object
+     * @param path - The dot-notation path to resolve
+     * @returns The resolved value, or undefined if not found
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolve(response, path) {
+        return path.split('.').reduce((obj, key) => obj?.[key], response);
+    }
+    /**
+     * Resolve the "from" index value
+     *
+     * If the path resolves to a value in the response, use it.
+     * Otherwise, compute it from currentPage and perPage:
+     * `(currentPage - 1) * perPage + 1`
+     *
+     * @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 computed "from" index
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolveFrom(response, options, currentPage, perPage) {
+        const direct = this._resolve(response, options.from);
+        if (direct !== undefined) {
+            return direct;
+        }
+        if (currentPage && perPage) {
+            return (currentPage - 1) * perPage + 1;
+        }
+        return undefined;
+    }
+    /**
+     * Resolve the "to" index value
+     *
+     * If the path resolves to a value in the response, use it.
+     * Otherwise, compute it from currentPage, perPage, and total:
+     * `Math.min(currentPage * perPage, total)`
+     *
+     * @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 computed "to" index
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolveTo(response, options, currentPage, perPage, total) {
+        const direct = this._resolve(response, options.to);
+        if (direct !== undefined) {
+            return direct;
+        }
+        if (currentPage && perPage && total) {
+            return Math.min(currentPage * perPage, total);
+        }
+        return undefined;
+    }
+}
+
+/**
+ * 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.
+ */
+class LaravelRequestStrategy {
+    /**
+     * Build a pagination-only URI from the given state
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The composed URI string
+     * @throws Error if resource is not set
+     */
+    buildUri(state, options) {
+        if (!state.resource) {
+            throw new Error('Set the resource property BEFORE calling the url() / get() methods');
+        }
+        const base = state.baseUrl ? `${state.baseUrl}/${state.resource}` : `/${state.resource}`;
+        return `${base}?${options.limit}=${state.limit}&${options.page}=${state.page}`;
+    }
+    /**
+     * Validate that the given limit is accepted by the Laravel driver
+     *
+     * Laravel pagination does not recognize `-1` as a "fetch all" sentinel,
+     * so only positive integers are accepted.
+     *
+     * @param limit - The limit value to validate
+     * @throws {InvalidLimitError} If the value is not a positive integer
+     */
+    validateLimit(limit) {
+        if (Number.isInteger(limit) && limit >= 1) {
+            return;
+        }
+        throw new InvalidLimitError(limit);
+    }
+}
+
+/**
+ * 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,
+ *   ...
+ * }
+ * ```
+ */
+class LaravelResponseStrategy {
+    /**
+     * Parse a flat Laravel pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        return new PaginatedCollection(response[options.data], response[options.currentPage], response[options.from], response[options.to], response[options.total], response[options.perPage], response[options.prevPageUrl], response[options.nextPageUrl], response[options.lastPage], response[options.firstPageUrl], response[options.lastPageUrl]);
+    }
+}
+
+/**
+ * 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
+ */
+class NestjsRequestStrategy {
+    /**
+     * Accumulator for composing the URI string
+     */
+    _uri = '';
+    /**
+     * Build a URI string from the given state using the NestJS paginate format
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The composed URI string
+     * @throws Error if model is not set
+     */
+    buildUri(state, options) {
+        if (!state.resource) {
+            throw new Error('Set the resource property BEFORE adding filters or calling the url() / get() methods');
         }
-        // Cleanup the previously generated URI
         this._uri = '';
-        this._parseIncludes(s);
-        this._parseFields(s);
-        this._parseFilters(s);
-        this._parseLimit(s);
-        this._parsePage(s);
-        this._parseSort(s);
+        this._parseFilters(state, options);
+        this._parseOperatorFilters(state, options);
+        this._parseSort(state, options);
+        this._parseSelect(state, options);
+        this._parseSearch(state, options);
+        this._parseLimit(state, options);
+        this._parsePage(state, options);
         return this._uri;
     }
-    _prepend(model) {
-        const state = this._nestService.nest();
-        const baseUrl = state.baseUrl;
-        if (this._uri) {
-            return '&';
+    /**
+     * 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) {
+        if (Number.isInteger(limit) && (limit === -1 || limit >= 1)) {
+            return;
+        }
+        throw new InvalidLimitError(limit, true);
+    }
+    /**
+     * Parse and append simple filter parameters
+     *
+     * Generates: `filter.field=value1,value2` for each filter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     */
+    _parseFilters(state, options) {
+        const keys = Object.keys(state.filters);
+        if (!keys.length) {
+            return;
+        }
+        keys.forEach(key => {
+            const values = state.filters[key].join(',');
+            const param = `${this._prepend(state)}${options.filters}.${key}=${values}`;
+            this._uri += param;
+        });
+    }
+    /**
+     * Parse and append the limit parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     */
+    _parseLimit(state, options) {
+        const param = `${this._prepend(state)}${options.limit}=${state.limit}`;
+        this._uri += param;
+    }
+    /**
+     * Parse and append operator filter parameters
+     *
+     * Groups operator filters by field and generates:
+     * - Single value: `filter.field=$operator:value`
+     * - Multiple values ($in, $btw): `filter.field=$operator:val1,val2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     */
+    _parseOperatorFilters(state, options) {
+        if (!state.operatorFilters.length) {
+            return;
+        }
+        state.operatorFilters.forEach((opFilter) => {
+            const values = opFilter.values.join(',');
+            const param = `${this._prepend(state)}${options.filters}.${opFilter.field}=${opFilter.operator}:${values}`;
+            this._uri += param;
+        });
+    }
+    /**
+     * Parse and append the page parameter
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     */
+    _parsePage(state, options) {
+        const param = `${this._prepend(state)}${options.page}=${state.page}`;
+        this._uri += param;
+    }
+    /**
+     * Parse and append the search parameter
+     *
+     * Generates: `search=term`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     */
+    _parseSearch(state, options) {
+        if (!state.search) {
+            return;
+        }
+        const param = `${this._prepend(state)}${options.search}=${state.search}`;
+        this._uri += param;
+    }
+    /**
+     * Parse and append the select parameter
+     *
+     * Generates: `select=col1,col2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     */
+    _parseSelect(state, options) {
+        if (!state.select.length) {
+            return;
         }
-        return baseUrl ? `${baseUrl}/${model}?` : `/${model}?`;
+        const param = `${this._prepend(state)}${options.select}=${state.select.join(',')}`;
+        this._uri += param;
     }
     /**
-     * Add fields to the select statement for the given model
+     * Parse and append sort parameters
      *
-     * @param model Model that holds the fields
-     * @param fields Fields to select
-     * @returns {this}
+     * Generates: `sortBy=field1:DESC,field2:ASC`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
      */
-    addFields(model, fields) {
-        if (!fields.length) {
-            return this;
+    _parseSort(state, options) {
+        if (!state.sorts.length) {
+            return;
         }
-        this._nestService.addFields({ [model]: fields });
-        return this;
+        const sortPairs = state.sorts.map(sort => `${sort.field}:${sort.order === SortEnum.DESC ? 'DESC' : 'ASC'}`);
+        const param = `${this._prepend(state)}${options.sortBy}=${sortPairs.join(',')}`;
+        this._uri += param;
     }
     /**
-     * Add a filter with the given value(s)
-     *  I.e. filter[field]=1 or filter[field]=1,2,3
+     * Determine the appropriate URI prefix based on the current accumulator state
      *
-     * @param {string} field Name of the field to filter
-     * @param {string[]} value The needle(s)
-     * @returns {this}
+     * Returns the full base path with `?` for the first parameter,
+     * or `&` for subsequent parameters.
+     *
+     * @param state - The current query builder state
+     * @returns The prefix string to prepend to the next parameter
      */
-    addFilter(field, ...values) {
-        if (!values.length) {
-            return this;
+    _prepend(state) {
+        if (this._uri) {
+            return '&';
         }
-        this._nestService.addFilters({
-            [field]: values
-        });
-        return this;
+        return state.baseUrl ? `${state.baseUrl}/${state.resource}?` : `/${state.resource}?`;
     }
+}
+
+/**
+ * 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"
+ *   }
+ * }
+ * ```
+ *
+ * @see https://github.com/ppetzold/nestjs-paginate
+ */
+class NestjsResponseStrategy {
     /**
-     * Add related entities to include in the request
+     * Parse a nested NestJS pagination response into a PaginatedCollection
      *
-     * @param {string[]} models
-     * @returns
+     * Supports dot-notation key paths for accessing nested values.
+     * Computes `from` and `to` from `currentPage` and `itemsPerPage` when
+     * they are not directly available in the response.
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
      */
-    addIncludes(...models) {
-        if (!models.length) {
-            return this;
-        }
-        this._nestService.addIncludes(models);
-        return this;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        const data = this._resolve(response, options.data);
+        const currentPage = this._resolve(response, options.currentPage);
+        const total = this._resolve(response, options.total);
+        const perPage = this._resolve(response, options.perPage);
+        const lastPage = this._resolve(response, options.lastPage);
+        // Compute from/to if not directly available
+        const from = this._resolveFrom(response, options, currentPage, perPage);
+        const to = this._resolveTo(response, options, currentPage, perPage, total);
+        const prevPageUrl = this._resolve(response, options.prevPageUrl);
+        const nextPageUrl = this._resolve(response, options.nextPageUrl);
+        const firstPageUrl = this._resolve(response, options.firstPageUrl);
+        const lastPageUrl = this._resolve(response, options.lastPageUrl);
+        return new PaginatedCollection(data, currentPage, from, to, total, perPage, prevPageUrl, nextPageUrl, lastPage, firstPageUrl, lastPageUrl);
     }
     /**
-     * Add a field with a sort criteria
+     * Resolve a value from a response object using a dot-notation path
      *
-     * @param field Field to use for sorting
-     * @param {SortEnum} order A value from the SortEnum enumeration
-     * @returns {this}
+     * Supports both flat keys ('data') and nested paths ('meta.currentPage').
+     *
+     * @param response - The raw response object
+     * @param path - The dot-notation path to resolve
+     * @returns The resolved value, or undefined if not found
      */
-    addSort(field, order) {
-        this._nestService.addSort({
-            field,
-            order
-        });
-        return this;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolve(response, path) {
+        return path.split('.').reduce((obj, key) => obj?.[key], response);
     }
     /**
-     * Delete selected fields for the given models in the current query builder state
+     * Resolve the "from" index value
      *
-     * ```
-     * ngQubeeService.deleteFields({
-     *   users: ['email', 'password'],
-     *   address: ['zipcode']
-     * });
-     * ```
+     * If the path resolves to a value in the response, use it.
+     * Otherwise, compute it from currentPage and perPage:
+     * `(currentPage - 1) * perPage + 1`
      *
-     * @param {IFields} fields
-     * @returns
+     * @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 computed "from" index
      */
-    deleteFields(fields) {
-        this._nestService.deleteFields(fields);
-        return this;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolveFrom(response, options, currentPage, perPage) {
+        const direct = this._resolve(response, options.from);
+        if (direct !== undefined) {
+            return direct;
+        }
+        if (currentPage && perPage) {
+            return (currentPage - 1) * perPage + 1;
+        }
+        return undefined;
     }
     /**
-     * Delete selected fields for the given model in the current query builder state
+     * Resolve the "to" index value
      *
-     * ```
-     * ngQubeeService.deleteFieldsByModel('users', 'email', 'password']);
-     * ```
+     * If the path resolves to a value in the response, use it.
+     * Otherwise, compute it from currentPage, perPage, and total:
+     * `Math.min(currentPage * perPage, total)`
      *
-     * @param model Model that holds the fields
-     * @param {string[]} fields Fields to delete from the state
-     * @returns {this}
+     * @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 computed "to" index
      */
-    deleteFieldsByModel(model, ...fields) {
-        if (!fields.length) {
-            return this;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _resolveTo(response, options, currentPage, perPage, total) {
+        const direct = this._resolve(response, options.to);
+        if (direct !== undefined) {
+            return direct;
         }
-        this._nestService.deleteFields({
-            [model]: fields
-        });
-        return this;
+        if (currentPage && perPage && total) {
+            return Math.min(currentPage * perPage, total);
+        }
+        return undefined;
     }
+}
+
+/**
+ * Request strategy for the Spatie Query Builder driver
+ *
+ * Generates URIs in the Spatie format:
+ * - Fields: `fields[model]=col1,col2`
+ * - Filters: `filter[field]=value`
+ * - Includes: `include=model1,model2`
+ * - Sorts: `sort=-field1,field2` (- prefix = DESC)
+ * - Pagination: `limit=N&page=N`
+ *
+ * @see https://spatie.be/docs/laravel-query-builder
+ */
+class SpatieRequestStrategy {
+    /**
+     * Accumulator for composing the URI string
+     */
+    _uri = '';
     /**
-     * Remove given filters from the query builder state
+     * Build a URI string from the given state using the Spatie format
      *
-     * @param {string[]} filters Filters to remove
-     * @returns {this}
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The composed URI string
+     * @throws Error if resource is not set
      */
-    deleteFilters(...filters) {
-        if (!filters.length) {
-            return this;
+    buildUri(state, options) {
+        if (!state.resource) {
+            throw new Error('Set the resource property BEFORE adding filters or calling the url() / get() methods');
         }
-        this._nestService.deleteFilters(...filters);
-        return this;
+        this._uri = '';
+        this._parseIncludes(state, options);
+        this._parseFields(state, options);
+        this._parseFilters(state, options);
+        this._parseLimit(state, options);
+        this._parsePage(state, options);
+        this._parseSort(state, options);
+        return this._uri;
     }
     /**
-     * Remove selected related models from the query builder state
+     * Validate that the given limit is accepted by the Spatie driver
      *
-     * @param {string[]} includes Models to remove
-     * @returns
+     * Spatie query-builder does not recognize `-1` as a "fetch all" sentinel,
+     * so only positive integers are accepted.
+     *
+     * @param limit - The limit value to validate
+     * @throws {InvalidLimitError} If the value is not a positive integer
      */
-    deleteIncludes(...includes) {
-        if (!includes.length) {
-            return this;
+    validateLimit(limit) {
+        if (Number.isInteger(limit) && limit >= 1) {
+            return;
         }
-        this._nestService.deleteIncludes(...includes);
-        return this;
+        throw new InvalidLimitError(limit);
     }
     /**
-     * Remove sorts rules from the query builder state
+     * Parse and append field selection parameters
      *
-     * @param sorts Fields used for sorting to remove
-     * @returns {this}
+     * Validates that each field model exists either as the main resource
+     * or in the includes list. Fields are grouped by model in bracket notation.
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated field selection parameter string
+     * @throws Error if resource is required but not set
+     * @throws UnselectableModelError if a field model is not in resource or includes
      */
-    deleteSorts(...sorts) {
-        this._nestService.deleteSorts(...sorts);
-        return this;
+    _parseFields(state, options) {
+        if (!Object.keys(state.fields).length) {
+            return this._uri;
+        }
+        if (!state.resource) {
+            throw new Error('While selecting fields, the -> resource <- is required');
+        }
+        if (!(state.resource in state.fields)) {
+            throw new Error(`Key ${state.resource} is missing in the fields object`);
+        }
+        const f = {};
+        for (const k in state.fields) {
+            if (state.fields.hasOwnProperty(k)) {
+                if (k !== state.resource && !state.includes.includes(k)) {
+                    throw new UnselectableModelError(k);
+                }
+                Object.assign(f, { [`${options.fields}[${k}]`]: state.fields[k].join(',') });
+            }
+        }
+        const param = `${this._prepend(state)}${qs.stringify(f, { encode: false })}`;
+        this._uri += param;
+        return param;
     }
     /**
-     * Generate an URI accordingly to the given data
+     * Parse and append filter parameters
      *
-     * @returns {Observable<string>} An observable that emits the generated uri
+     * Generates filter parameters in bracket notation: `filter[key]=value1,value2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated filter parameter string
      */
-    generateUri() {
-        try {
-            this._uri$.next(this._parse(this._nestService.nest()));
-            return this.uri$;
-        }
-        catch (error) {
-            return throwError(() => error);
+    _parseFilters(state, options) {
+        const keys = Object.keys(state.filters);
+        if (!keys.length) {
+            return this._uri;
         }
+        const f = {
+            [`${options.filters}`]: keys.reduce((acc, key) => {
+                return Object.assign(acc, { [key]: state.filters[key].join(',') });
+            }, {})
+        };
+        const param = `${this._prepend(state)}${qs.stringify(f, { encode: false })}`;
+        this._uri += param;
+        return param;
     }
     /**
-     * Clear the current state and reset the Query Builder to a fresh, clean condition
+     * Parse and append include parameters
      *
-     * @returns {this}
+     * Generates: `include=model1,model2`
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated include parameter string
      */
-    reset() {
-        this._nestService.reset();
-        return this;
+    _parseIncludes(state, options) {
+        if (!state.includes.length) {
+            return this._uri;
+        }
+        const param = `${this._prepend(state)}${options.includes}=${state.includes}`;
+        this._uri += param;
+        return param;
     }
     /**
-     * Set the base url to use for composing the address
+     * Parse and append the limit parameter
      *
-     * @param {string} baseUrl
-     * @returns {this}
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated limit parameter string
      */
-    setBaseUrl(baseUrl) {
-        this._nestService.baseUrl = baseUrl;
-        return this;
+    _parseLimit(state, options) {
+        const param = `${this._prepend(state)}${options.limit}=${state.limit}`;
+        this._uri += param;
+        return param;
     }
     /**
-     * Set the items per page number
+     * Parse and append the page parameter
      *
-     * @param limit
-     * @returns {this}
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated page parameter string
      */
-    setLimit(limit) {
-        this._nestService.limit = limit;
-        return this;
+    _parsePage(state, options) {
+        const param = `${this._prepend(state)}${options.page}=${state.page}`;
+        this._uri += param;
+        return param;
     }
     /**
-     * Set the model to use for running the query against
-     *   - I.e. the model "users" will return /users
+     * Parse and append sort parameters
      *
-     * @param {string} model Model name
-     * @returns {this}
+     * Generates: `sort=-field1,field2` where `-` prefix indicates DESC order
+     *
+     * @param state - The current query builder state
+     * @param options - The query parameter key name configuration
+     * @returns The generated sort parameter string
      */
-    setModel(model) {
-        this._nestService.model = model;
-        return this;
+    _parseSort(state, options) {
+        let param = '';
+        if (!state.sorts.length) {
+            return param;
+        }
+        param = `${this._prepend(state)}${options.sort}=`;
+        state.sorts.forEach((sort, idx) => {
+            param += `${sort.order === SortEnum.DESC ? '-' : ''}${sort.field}`;
+            if (idx < state.sorts.length - 1) {
+                param += ',';
+            }
+        });
+        this._uri += param;
+        return param;
     }
     /**
-     * Set the page that the backend will use to paginate the result set
+     * Determine the appropriate URI prefix based on the current accumulator state
      *
-     * @param page Page param
-     * @returns {this}
+     * Returns the full base path with `?` for the first parameter,
+     * or `&` for subsequent parameters.
+     *
+     * @param state - The current query builder state
+     * @returns The prefix string to prepend to the next parameter
      */
-    setPage(page) {
-        this._nestService.page = page;
-        return this;
+    _prepend(state) {
+        if (this._uri) {
+            return '&';
+        }
+        return state.baseUrl ? `${state.baseUrl}/${state.resource}?` : `/${state.resource}?`;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeService, deps: [{ token: NestService }, { token: 'QUERY_PARAMS_CONFIG', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: NestService }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['QUERY_PARAMS_CONFIG']
-                }, {
-                    type: Optional
-                }] }] });
 
-class ResponseOptions {
-    currentPage;
-    data;
-    firstPageUrl;
-    from;
-    lastPage;
-    lastPageUrl;
-    nextPageUrl;
-    path;
-    perPage;
-    prevPageUrl;
-    to;
-    total;
-    constructor(options) {
-        this.currentPage = options.currentPage || 'current_page';
-        this.data = options.data || 'data';
-        this.firstPageUrl = options.firstPageUrl || 'first_page_url';
-        this.from = options.from || 'from';
-        this.lastPage = options.lastPage || 'last_page';
-        this.lastPageUrl = options.lastPageUrl || 'last_page_url';
-        this.nextPageUrl = options.nextPageUrl || 'next_page_url';
-        this.path = options.path || 'path';
-        this.perPage = options.perPage || 'per_page';
-        this.prevPageUrl = options.prevPageUrl || 'prev_page_url';
-        this.to = options.to || 'to';
-        this.total = options.total || 'total';
+/**
+ * Response strategy for the Spatie Query Builder driver
+ *
+ * Parses flat Laravel pagination responses:
+ * ```json
+ * {
+ *   "data": [...],
+ *   "current_page": 1,
+ *   "total": 100,
+ *   "per_page": 15,
+ *   "from": 1,
+ *   "to": 15,
+ *   ...
+ * }
+ * ```
+ *
+ * @see https://spatie.be/docs/laravel-query-builder
+ */
+class SpatieResponseStrategy {
+    /**
+     * Parse a flat Laravel pagination response into a PaginatedCollection
+     *
+     * @param response - The raw API response object
+     * @param options - The response key name configuration
+     * @returns A typed PaginatedCollection instance
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    paginate(response, options) {
+        return new PaginatedCollection(response[options.data], response[options.currentPage], response[options.from], response[options.to], response[options.total], response[options.perPage], response[options.prevPageUrl], response[options.nextPageUrl], response[options.lastPage], response[options.firstPageUrl], response[options.lastPageUrl]);
     }
 }
 
-class PaginationService {
-    _options;
-    constructor(options = {}) {
-        this._options = new ResponseOptions(options);
+/**
+ * Resolve the request strategy instance for the given driver
+ *
+ * @param driver - The pagination driver
+ * @returns The corresponding request strategy
+ */
+function resolveRequestStrategy$1(driver) {
+    switch (driver) {
+        case DriverEnum.JSON_API:
+            return new JsonApiRequestStrategy();
+        case DriverEnum.NESTJS:
+            return new NestjsRequestStrategy();
+        case DriverEnum.SPATIE:
+            return new SpatieRequestStrategy();
+        case DriverEnum.LARAVEL:
+            return new LaravelRequestStrategy();
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    paginate(response) {
-        return new PaginatedCollection(response[this._options.data], response[this._options.currentPage], response[this._options.from], response[this._options.to], response[this._options.total], response[this._options.perPage], response[this._options.prevPageUrl], response[this._options.nextPageUrl], response[this._options.lastPage], response[this._options.firstPageUrl], response[this._options.lastPageUrl]);
+}
+/**
+ * Resolve the response strategy instance for the given driver
+ *
+ * @param driver - The pagination driver
+ * @returns The corresponding response strategy
+ */
+function resolveResponseStrategy$1(driver) {
+    switch (driver) {
+        case DriverEnum.JSON_API:
+            return new JsonApiResponseStrategy();
+        case DriverEnum.NESTJS:
+            return new NestjsResponseStrategy();
+        case DriverEnum.SPATIE:
+            return new SpatieResponseStrategy();
+        case DriverEnum.LARAVEL:
+            return new LaravelResponseStrategy();
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: PaginationService, deps: [{ token: 'RESPONSE_OPTIONS', optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: PaginationService });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: PaginationService, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: ['RESPONSE_OPTIONS']
-                }, {
-                    type: Optional
-                }] }] });
-
 // @dynamic
 class NgQubeeModule {
-    static forRoot(config = {}) {
+    /**
+     * Configure NgQubee for the root module
+     *
+     * @param config - Configuration object with driver, and optional request and response settings
+     * @returns Module with providers configured for the specified driver
+     */
+    static forRoot(config) {
+        const driver = config.driver;
+        const requestStrategy = resolveRequestStrategy$1(driver);
+        const responseStrategy = resolveResponseStrategy$1(driver);
         return {
             ngModule: NgQubeeModule,
             providers: [
@@ -805,52 +2081,115 @@ class NgQubeeModule {
                 {
                     deps: [NestService],
                     provide: NgQubeeService,
-                    useFactory: (nestService) => new NgQubeeService(nestService, Object.assign({}, config.request))
-                }, {
+                    useFactory: (nestService) => new NgQubeeService(nestService, requestStrategy, driver, Object.assign({}, config.request))
+                },
+                {
                     provide: PaginationService,
-                    useFactory: () => new PaginationService(Object.assign({}, config.response))
+                    useFactory: () => {
+                        const responseConfig = Object.assign({}, config.response);
+                        if (driver === DriverEnum.JSON_API) {
+                            return new PaginationService(responseStrategy, new JsonApiResponseOptions(responseConfig));
+                        }
+                        return driver === DriverEnum.NESTJS
+                            ? new PaginationService(responseStrategy, new NestjsResponseOptions(responseConfig))
+                            : new PaginationService(responseStrategy, responseConfig);
+                    }
                 }
             ]
         };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeModule });
-    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeModule, providers: [{
-                deps: [NestService],
-                provide: NgQubeeService,
-                useFactory: (nestService) => new NgQubeeService(nestService, {})
-            }] });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: NgQubeeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "21.0.3", ngImport: i0, type: NgQubeeModule });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: NgQubeeModule });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.17", ngImport: i0, type: NgQubeeModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.0.3", ngImport: i0, type: NgQubeeModule, decorators: [{
             type: NgModule,
-            args: [{
-                    providers: [{
-                            deps: [NestService],
-                            provide: NgQubeeService,
-                            useFactory: (nestService) => new NgQubeeService(nestService, {})
-                        }]
-                }]
+            args: [{}]
         }] });
 
+/**
+ * Resolve the request strategy instance for the given driver
+ *
+ * @param driver - The pagination driver
+ * @returns The corresponding request strategy
+ */
+function resolveRequestStrategy(driver) {
+    switch (driver) {
+        case DriverEnum.JSON_API:
+            return new JsonApiRequestStrategy();
+        case DriverEnum.NESTJS:
+            return new NestjsRequestStrategy();
+        case DriverEnum.SPATIE:
+            return new SpatieRequestStrategy();
+        case DriverEnum.LARAVEL:
+            return new LaravelRequestStrategy();
+    }
+}
+/**
+ * Resolve the response strategy instance for the given driver
+ *
+ * @param driver - The pagination driver
+ * @returns The corresponding response strategy
+ */
+function resolveResponseStrategy(driver) {
+    switch (driver) {
+        case DriverEnum.JSON_API:
+            return new JsonApiResponseStrategy();
+        case DriverEnum.NESTJS:
+            return new NestjsResponseStrategy();
+        case DriverEnum.SPATIE:
+            return new SpatieResponseStrategy();
+        case DriverEnum.LARAVEL:
+            return new LaravelResponseStrategy();
+    }
+}
 /**
  * Sets up providers necessary to enable `NgQubee` functionality for the application.
  *
  * @usageNotes
  *
- * Basic example of how you can add NgQubee to your application:
+ * Basic example with the Laravel driver:
+ * ```
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideNgQubee({ driver: DriverEnum.LARAVEL })]
+ * });
+ * ```
+ *
+ * Spatie driver example:
+ * ```
+ * import { DriverEnum } from 'ng-qubee';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideNgQubee({ driver: DriverEnum.SPATIE })]
+ * });
+ * ```
+ *
+ * JSON:API driver example:
+ * ```
+ * import { DriverEnum } from 'ng-qubee';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideNgQubee({ driver: DriverEnum.JSON_API })]
+ * });
+ * ```
+ *
+ * NestJS driver example:
  * ```
- * const config = {};
+ * import { DriverEnum } from 'ng-qubee';
  *
  * bootstrapApplication(AppComponent, {
- *   providers: [provideNgQubee(config)]
+ *   providers: [provideNgQubee({ driver: DriverEnum.NESTJS })]
  * });
  * ```
  *
  * @publicApi
- * @param config Configuration object compliant to the IConfig interface
+ * @param config - Configuration object compliant to the IConfig interface
  * @returns A set of providers to setup NgQubee
  */
-function provideNgQubee(config = {}) {
+function provideNgQubee(config) {
+    const driver = config.driver;
+    const requestStrategy = resolveRequestStrategy(driver);
+    const responseStrategy = resolveResponseStrategy(driver);
     return makeEnvironmentProviders([
         {
             provide: NestService,
@@ -859,14 +2198,47 @@ function provideNgQubee(config = {}) {
         {
             deps: [NestService],
             provide: NgQubeeService,
-            useFactory: (nestService) => new NgQubeeService(nestService, Object.assign({}, config.request))
-        }, {
+            useFactory: (nestService) => new NgQubeeService(nestService, requestStrategy, driver, Object.assign({}, config.request))
+        },
+        {
             provide: PaginationService,
-            useFactory: () => new PaginationService(Object.assign({}, config.response))
+            useFactory: () => {
+                const responseConfig = Object.assign({}, config.response);
+                if (driver === DriverEnum.JSON_API) {
+                    return new PaginationService(responseStrategy, new JsonApiResponseOptions(responseConfig));
+                }
+                return driver === DriverEnum.NESTJS
+                    ? new PaginationService(responseStrategy, new NestjsResponseOptions(responseConfig))
+                    : new PaginationService(responseStrategy, responseConfig);
+            }
         }
     ]);
 }
 
+/**
+ * Enum representing the available filter operators for the NestJS driver
+ *
+ * These operators map to the nestjs-paginate filter syntax:
+ * `filter.field=$operator:value`
+ *
+ * @see https://github.com/ppetzold/nestjs-paginate
+ */
+var FilterOperatorEnum;
+(function (FilterOperatorEnum) {
+    FilterOperatorEnum["BTW"] = "$btw";
+    FilterOperatorEnum["CONTAINS"] = "$contains";
+    FilterOperatorEnum["EQ"] = "$eq";
+    FilterOperatorEnum["GT"] = "$gt";
+    FilterOperatorEnum["GTE"] = "$gte";
+    FilterOperatorEnum["ILIKE"] = "$ilike";
+    FilterOperatorEnum["IN"] = "$in";
+    FilterOperatorEnum["LT"] = "$lt";
+    FilterOperatorEnum["LTE"] = "$lte";
+    FilterOperatorEnum["NOT"] = "$not";
+    FilterOperatorEnum["NULL"] = "$null";
+    FilterOperatorEnum["SW"] = "$sw";
+})(FilterOperatorEnum || (FilterOperatorEnum = {}));
+
 /*
  * Public API Surface of angular-query-builder
  */
@@ -875,5 +2247,5 @@ function provideNgQubee(config = {}) {
  * Generated bundle index. Do not edit.
  */
 
-export { InvalidLimitError, InvalidModelNameError, InvalidPageNumberError, KeyNotFoundError, NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationService, SortEnum, UnselectableModelError, provideNgQubee };
+export { DriverEnum, FilterOperatorEnum, InvalidLimitError, InvalidPageNumberError, InvalidResourceNameError, JsonApiRequestStrategy, JsonApiResponseStrategy, KeyNotFoundError, LaravelRequestStrategy, LaravelResponseStrategy, NestjsRequestStrategy, NestjsResponseStrategy, NgQubeeModule, NgQubeeService, PaginatedCollection, PaginationService, SortEnum, SpatieRequestStrategy, SpatieResponseStrategy, UnselectableModelError, UnsupportedFieldSelectionError, UnsupportedFilterError, UnsupportedFilterOperatorError, UnsupportedIncludesError, UnsupportedSearchError, UnsupportedSelectError, UnsupportedSortError, provideNgQubee };
 //# sourceMappingURL=ng-qubee.mjs.map