@gala-chain/launchpad-sdk 5.0.2-beta.1 → 5.0.4-beta.0

package/dist/src/utils/numeric-wrappers.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Numeric Utility Wrappers
+ *
+ * Semantic wrappers and helpers for common numeric operations.
+ * Consolidates 7 patterns found across 127+ occurrences in service files.
+ *
+ * @category Utilities
+ * @since 5.16.0
+ */
+import BigNumber from 'bignumber.js';
+/**
+ * Convert decimal to percentage representation
+ *
+ * Multiplies by 100 to convert decimal to percentage.
+ * Consolidates 13+ occurrences across pool validators and metrics.
+ *
+ * @example
+ * ```typescript
+ * const percentageChange = toPercentageDecimal(0.025); // 2.5
+ * ```
+ */
+export declare function toPercentageDecimal(value: string | number | BigNumber): BigNumber;
+/**
+ * Convert percentage back to decimal representation
+ *
+ * Divides by 100 to convert percentage to decimal.
+ * Reverse of toPercentageDecimal.
+ *
+ * @example
+ * ```typescript
+ * const decimal = fromPercentageDecimal(2.5); // 0.025
+ * ```
+ */
+export declare function fromPercentageDecimal(value: string | number | BigNumber): BigNumber;
+/**
+ * Format value as display price (6 decimal places)
+ *
+ * Semantic wrapper for `.toFixed(6)` - standard price display format.
+ * Consolidates 20+ occurrences across GSwap services.
+ *
+ * @example
+ * ```typescript
+ * const displayPrice = toDisplayPrice(1.23456789); // "1.234568"
+ * ```
+ */
+export declare function toDisplayPrice(value: string | number | BigNumber, decimals?: number): string;
+/**
+ * Format value as pool price (8 decimal places)
+ *
+ * Semantic wrapper for `.toFixed(8)` - pool calculation format.
+ * Consolidates 10+ occurrences across pool calculation services.
+ *
+ * @example
+ * ```typescript
+ * const poolPrice = toPoolPrice(1.234567890); // "1.23456789"
+ * ```
+ */
+export declare function toPoolPrice(value: string | number | BigNumber): string;
+/**
+ * Format value as percentage display (2 decimal places)
+ *
+ * Semantic wrapper for `.toFixed(2)` - percentage display format.
+ * Consolidates 5+ occurrences for percentage formatting.
+ *
+ * @example
+ * ```typescript
+ * const percentage = toPercentage(0.025, 2); // "2.50"
+ * ```
+ */
+export declare function toPercentage(value: string | number | BigNumber, decimals?: number): string;
+/**
+ * Convert fee tier to basis points value
+ *
+ * Maps fee tier enum values (1, 0.3, 0.05) to basis points (10000, 3000, 500).
+ * Consolidates 8 occurrences and prevents hardcoded arrays.
+ *
+ * @example
+ * ```typescript
+ * const basisPoints = feeTierToBasisPoints(0.3); // 3000
+ * const basisPoints2 = feeTierToBasisPoints(3000); // 3000
+ * ```
+ */
+export declare function feeTierToBasisPoints(feeTier: number): number;
+/**
+ * Create a decimal scaler for token amount normalization
+ *
+ * Returns 10^decimals as BigNumber for token amount conversions.
+ * Consolidates 7 occurrences of Math.pow(10, decimals) pattern.
+ *
+ * @example
+ * ```typescript
+ * const scaler = createDecimalScaler(6);
+ * const normalized = amount.dividedBy(scaler); // Normalize 1M units to 1 token
+ * ```
+ */
+export declare function createDecimalScaler(decimals: number): BigNumber;
+/**
+ * Check if value is a valid number (not NaN, not infinite)
+ *
+ * Consolidates 40+ occurrences of `!isNaN() && isFinite()` checks.
+ * Used in safe-parsers and validation throughout.
+ *
+ * @example
+ * ```typescript
+ * if (!isValidNumber(parsed)) {
+ *   return fallback;
+ * }
+ * ```
+ */
+export declare function isValidNumber(value: unknown): value is number;
+/**
+ * Convert Uniswap V3 tick to price ratio
+ *
+ * Calculates: (1.0001)^tick for Uniswap V3 price calculations.
+ * Consolidates 6 occurrences of Math.pow(1.0001, tick) pattern.
+ *
+ * @example
+ * ```typescript
+ * const price = tickToPrice(-1000);
+ * const inversePrice = tickToPrice(1000);
+ * ```
+ */
+export declare function tickToPrice(tick: number): BigNumber;
+/**
+ * Convert milliseconds to seconds
+ *
+ * Simple conversion helper for time unit handling.
+ *
+ * @example
+ * ```typescript
+ * const seconds = msToSeconds(5000); // 5
+ * ```
+ */
+export declare function msToSeconds(ms: number): number;
+/**
+ * Convert seconds to milliseconds
+ *
+ * Simple conversion helper for time unit handling.
+ *
+ * @example
+ * ```typescript
+ * const ms = secondsToMs(5); // 5000
+ * ```
+ */
+export declare function secondsToMs(seconds: number): number;
+//# sourceMappingURL=numeric-wrappers.d.ts.map

package/dist/src/utils/numeric-wrappers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-wrappers.d.ts","sourceRoot":"","sources":["../../../src/utils/numeric-wrappers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AAGrC;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAEjF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,CAEnF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,QAAQ,GAAE,MAAU,GACnB,MAAM,CAER;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAEtE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,EAClC,QAAQ,GAAE,MAAU,GACnB,MAAM,CAER;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAK5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,CAE/D;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAG7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAEnD;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/src/utils/object-extractors.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Object and Array Extraction Patterns
+ *
+ * Utility functions for object manipulation, field extraction, and recursive traversal.
+ * Consolidates 7-8 duplicated patterns found across event extractors and transformers.
+ *
+ * @category Utilities
+ * @since 5.16.0
+ */
+/**
+ * Extract field value from object using candidate field names
+ *
+ * Loops through candidate field names in order and returns the first non-empty string value.
+ * Consolidates 11 occurrences across LiquidityEventExtractor and SwapEventExtractor.
+ *
+ * @example
+ * ```typescript
+ * const txId = extractFieldWithCandidates(obj, ['transactionId', 'txId', 'tx_id', 'hash']);
+ * ```
+ */
+export declare function extractFieldWithCandidates(obj: Record<string, unknown>, candidates: string[]): string | null;
+/**
+ * Build object with conditionally included optional fields
+ *
+ * Starts with base object and conditionally adds optional fields only if defined.
+ * Consolidates 8 occurrences of the pattern: `if (value !== undefined) obj.field = value;`
+ *
+ * @example
+ * ```typescript
+ * const event = buildWithOptionalFields(
+ *   { id: '123', amount: '100' },
+ *   { timestamp: timestampValue, token0: token0Value }
+ * );
+ * // Returns: { id: '123', amount: '100', timestamp: ..., token0: ... }
+ * ```
+ */
+export declare function buildWithOptionalFields<T extends Record<string, unknown>>(base: T, optionalFields: Record<string, unknown>): T;
+/**
+ * Extract nested "Data" object or fallback to current object
+ *
+ * Checks for nested "Data" property and uses it if it's a non-array object.
+ * Otherwise returns the original object.
+ * Consolidates 5 occurrences in event extractors.
+ *
+ * @example
+ * ```typescript
+ * const fieldsObj = extractNestedData(payload);
+ * const txId = fieldsObj['transactionId'];
+ * ```
+ */
+export declare function extractNestedData(obj: Record<string, unknown>, nestedKey?: string): Record<string, unknown>;
+/**
+ * Recursively walk object structure with visitor callback
+ *
+ * Traverses object tree depth-first, deduplicates with WeakSet,
+ * applies visitor callback to each value, and respects max depth.
+ * Consolidates 3 occurrences in event extractors for recursive payload walking.
+ *
+ * @example
+ * ```typescript
+ * const events: LiquidityEventData[] = [];
+ * walkObjectRecursive(payload, (value) => {
+ *   const event = extractLiquidityFromObject(value);
+ *   if (event) events.push(event);
+ * }, 50);
+ * ```
+ */
+export declare function walkObjectRecursive(payload: unknown, visitor: (value: unknown) => void, maxDepth?: number): void;
+/**
+ * Normalize numeric value using recognized value mapping
+ *
+ * Maps recognized values to canonical form, applies fallback for unrecognized.
+ * Consolidates 4 occurrences of fee tier normalization pattern.
+ *
+ * @example
+ * ```typescript
+ * // Fee tier normalization: 1 or 10000 -> 10000, 0.3 or 3000 -> 3000, etc.
+ * const normalized = normalizeNumericValue(fee, {
+ *   '1': 10000,
+ *   '10000': 10000,
+ *   '0.3': 3000,
+ *   '3000': 3000,
+ *   '0.05': 500,
+ *   '500': 500,
+ * });
+ * ```
+ */
+export declare function normalizeNumericValue(value: unknown, recognizedValues: Record<string | number, number>, fallback?: number): number | null;
+/**
+ * Validate that required fields are present and non-empty
+ *
+ * Checks that all specified fields exist and are non-empty strings.
+ * Consolidates 5 occurrences of strict validation pattern.
+ *
+ * @example
+ * ```typescript
+ * if (!validateRequiredFields(obj, ['id', 'name', 'address'])) {
+ *   return null; // Missing required fields
+ * }
+ * ```
+ */
+export declare function validateRequiredFields(obj: Record<string, unknown>, fields: string[]): boolean;
+/**
+ * Merge object with defaults using spread operator pattern
+ *
+ * Safely merges existing object with new properties, handling nullish values.
+ * Consolidates 50+ occurrences of the pattern: `{...(existing || {}), ...updates}`
+ *
+ * @example
+ * ```typescript
+ * const merged = mergeWithDefaults(cachedEntry, { lastUpdated: Date.now() });
+ * ```
+ */
+export declare function mergeWithDefaults<T extends Record<string, unknown>>(existing: T | null | undefined, updates: Partial<T>): T;
+//# sourceMappingURL=object-extractors.d.ts.map

package/dist/src/utils/object-extractors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-extractors.d.ts","sourceRoot":"","sources":["../../../src/utils/object-extractors.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,UAAU,EAAE,MAAM,EAAE,GACnB,MAAM,GAAG,IAAI,CAQf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvE,IAAI,EAAE,CAAC,EACP,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACtC,CAAC,CAQH;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,SAAS,GAAE,MAAe,GACzB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAMzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,EACjC,QAAQ,GAAE,MAAW,GACpB,IAAI,CAqBN;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,OAAO,EACd,gBAAgB,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,MAAM,CAAC,EACjD,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,GAAG,IAAI,CAiBf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,MAAM,EAAE,MAAM,EAAE,GACf,OAAO,CAOT;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjE,QAAQ,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9B,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAClB,CAAC,CAKH"}

package/dist/src/utils/object-patterns.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Conditional Spread Object Building
+ *
+ * Utility functions for building objects with conditionally included fields
+ * using spread operator patterns. Consolidates duplicated patterns across services.
+ *
+ * @category Utilities
+ * @since 5.17.0
+ */
+/**
+ * Build object with conditionally spread fields
+ *
+ * Takes a base object and conditionally spreads fields only if they are defined.
+ * Uses the pattern: `{ ...baseObj, ...(field ? { field } : {}) }` to clean up code
+ * and make intent explicit.
+ *
+ * Consolidates 2 occurrences across PoolStateManager and agent-config utilities.
+ *
+ * @template T - The base object type
+ * @param baseObj - The base object to start with
+ * @param conditionalFields - Object where each value determines if that field is included
+ * @returns New object with base fields plus defined conditional fields
+ *
+ * @example
+ * ```typescript
+ * // Simple conditional field
+ * const config = conditionalSpreadBuilder(
+ *   { id: '123', name: 'test' },
+ *   { description: descriptionValue }
+ * );
+ * // If descriptionValue is defined: { id: '123', name: 'test', description: '...' }
+ * // If descriptionValue is undefined: { id: '123', name: 'test' }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Multiple conditional fields
+ * const event = conditionalSpreadBuilder(
+ *   { id: 'evt-1', timestamp: Date.now() },
+ *   {
+ *     source: sourceValue,      // included if sourceValue is defined
+ *     metadata: metadataObj,     // included if metadataObj is defined
+ *     tags: tagsArray            // included if tagsArray is defined
+ *   }
+ * );
+ * // Returns object with only non-undefined fields from conditionalFields
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Replaces pattern:
+ * // Old: { ...baseConfig, ...(config?.option ? { option: config.option } : {}) }
+ * // New: conditionalSpreadBuilder(baseConfig, { option: config?.option })
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Works with falsy values (only undefined is excluded)
+ * const obj = conditionalSpreadBuilder(
+ *   { value: 10 },
+ *   {
+ *     count: 0,              // included (0 is defined)
+ *     empty: '',             // included ('' is defined)
+ *     nullValue: null,       // included (null is defined)
+ *     undefinedValue: undefined // excluded (undefined)
+ *   }
+ * );
+ * // Returns: { value: 10, count: 0, empty: '', nullValue: null }
+ * ```
+ *
+ * @remarks
+ * - Only fields with `undefined` values are excluded
+ * - All other falsy values (0, '', null, false) ARE included
+ * - This matches the common spread pattern behavior exactly
+ * - Order preserved: base fields first, then conditional fields
+ * - Does not mutate input objects
+ *
+ * @see buildWithOptionalFields for a similar pattern that filters on non-empty strings
+ */
+export declare function conditionalSpreadBuilder<T>(baseObj: T, conditionalFields: Record<string, unknown | undefined>): T & Record<string, unknown>;
+//# sourceMappingURL=object-patterns.d.ts.map

package/dist/src/utils/object-patterns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-patterns.d.ts","sourceRoot":"","sources":["../../../src/utils/object-patterns.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,OAAO,EAAE,CAAC,EACV,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,GACrD,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAU7B"}

package/dist/src/utils/pagination-helpers.d.ts

@@ -0,0 +1,230 @@
+/**
+ * Pagination Helpers
+ *
+ * Centralized utilities for pagination calculations and query building.
+ * Eliminates duplicate offset/page calculation patterns found across 25+ locations.
+ *
+ * @category Utilities
+ * @since 6.5.0
+ */
+/**
+ * Pagination query parameters
+ *
+ * Standardized object for pagination parameters used in API requests.
+ *
+ * @example
+ * ```typescript
+ * const query = createPaginationQuery(2, 20);
+ * // Result: { offset: 20, limit: 20 }
+ * ```
+ */
+export interface PaginationQuery {
+    /** Zero-based offset for API requests */
+    offset: number;
+    /** Maximum number of results per page */
+    limit: number;
+}
+/**
+ * Calculate offset from page number and limit
+ *
+ * Converts page-based pagination (page 1, 2, 3...) to offset-based
+ * pagination (offset 0, 20, 40...).
+ *
+ * Formula: `offset = (page - 1) * limit`
+ *
+ * Common pattern eliminated (25+ locations):
+ * ```typescript
+ * // Before: Scattered throughout codebase
+ * const offset = (page - 1) * limit;
+ * const skip = page > 1 ? (page - 1) * limit : 0;
+ * const startIndex = (pageNum - 1) * itemsPerPage;
+ * ```
+ *
+ * @param page Page number (1-based, e.g., 1, 2, 3...)
+ * @param limit Maximum results per page
+ * @returns Zero-based offset for API requests
+ * @throws Error if page <= 0 or limit <= 0
+ *
+ * @example Page 1 with limit 20
+ * ```typescript
+ * calculatePaginationOffset(1, 20) // Returns: 0
+ * ```
+ *
+ * @example Page 2 with limit 20
+ * ```typescript
+ * calculatePaginationOffset(2, 20) // Returns: 20
+ * ```
+ *
+ * @example Page 5 with limit 50
+ * ```typescript
+ * calculatePaginationOffset(5, 50) // Returns: 200
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function calculatePaginationOffset(page: number, limit: number): number;
+/**
+ * Create pagination query object for API requests
+ *
+ * Constructs a standardized pagination query with offset and limit.
+ * Replaces manual offset calculation patterns across multiple services.
+ *
+ * Common pattern eliminated:
+ * ```typescript
+ * // Before: Manual construction in every service
+ * const offset = (page - 1) * limit;
+ * const params = { offset, limit };
+ * ```
+ *
+ * @param page Page number (1-based, e.g., 1, 2, 3...)
+ * @param limit Maximum results per page (default: PAGINATION_DEFAULTS.DEFAULT_LIMIT)
+ * @returns Object with offset and limit ready for API requests
+ * @throws Error if page or limit is invalid
+ *
+ * @example Basic usage
+ * ```typescript
+ * const query = createPaginationQuery(1, 20);
+ * // Result: { offset: 0, limit: 20 }
+ *
+ * const params = { ...query, search: 'anime' };
+ * const result = await api.fetchTokens(params);
+ * ```
+ *
+ * @example With default limit
+ * ```typescript
+ * const query = createPaginationQuery(3);
+ * // Result: { offset: 20, limit: PAGINATION_DEFAULTS.DEFAULT_LIMIT }
+ * ```
+ *
+ * @example In API request
+ * ```typescript
+ * const pools = await api.fetchPools({
+ *   ...createPaginationQuery(2, 50),
+ *   search: 'GALA'
+ * });
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function createPaginationQuery(page: number, limit?: number): PaginationQuery;
+/**
+ * Validate pagination parameters
+ *
+ * Ensures page and limit values are valid before using them in API requests.
+ * Throws descriptive errors for invalid values.
+ *
+ * @param page Page number to validate
+ * @param limit Limit/page size to validate
+ * @param contextMessage Optional message for error context (e.g., "fetchPools")
+ * @throws Error if page or limit is invalid with descriptive message
+ *
+ * @example Basic validation
+ * ```typescript
+ * validatePaginationParams(1, 20);
+ * // No error - both valid
+ *
+ * validatePaginationParams(0, 20);
+ * // Throws: "Invalid page number: 0. Page must be a positive integer."
+ * ```
+ *
+ * @example With context
+ * ```typescript
+ * validatePaginationParams(page, limit, 'fetchTokens');
+ * // Throws: "fetchTokens: Invalid limit: 0. Limit must be a positive integer."
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function validatePaginationParams(page: number, limit: number, _contextMessage?: string): void;
+/**
+ * Normalize page number to ensure it's within valid bounds
+ *
+ * Ensures page is at least 1 (minimum page number).
+ * Useful for handling user input or default values.
+ * Accepts undefined and returns minPage.
+ *
+ * @param page Page number to normalize (undefined returns minPage)
+ * @param minPage Minimum allowed page (default: 1)
+ * @returns Normalized page number (at least minPage)
+ *
+ * @example
+ * ```typescript
+ * normalizePage(undefined) // Returns: 1
+ * normalizePage(0) // Returns: 1
+ * normalizePage(-5) // Returns: 1
+ * normalizePage(10) // Returns: 10
+ * normalizePage(0, 5) // Returns: 5 (custom minimum)
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function normalizePage(page: number | undefined, minPage?: number): number;
+/**
+ * Normalize limit to ensure it's within valid bounds
+ *
+ * Ensures limit is between min and max bounds.
+ * Useful for enforcing server-side pagination constraints.
+ * Accepts undefined and returns minLimit.
+ *
+ * @param limit Limit to normalize (undefined returns minLimit)
+ * @param minLimit Minimum allowed limit (default: 1)
+ * @param maxLimit Maximum allowed limit (default: PAGINATION_DEFAULTS.BACKEND_MAX_PAGE_SIZE)
+ * @returns Normalized limit within bounds
+ *
+ * @example
+ * ```typescript
+ * normalizeLimit(undefined) // Returns: 1
+ * normalizeLimit(0) // Returns: 1
+ * normalizeLimit(100) // Returns: 20 (if maxLimit is 20)
+ * normalizeLimit(10) // Returns: 10 (within bounds)
+ * normalizeLimit(100, 1, 50) // Returns: 50 (custom max)
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function normalizeLimit(limit: number | undefined, minLimit?: number, maxLimit?: number): number;
+/**
+ * Calculate total pages from total count and limit
+ *
+ * Determines how many pages are needed to display all items.
+ * Useful for pagination UI and progress tracking.
+ *
+ * @param total Total number of items
+ * @param limit Items per page
+ * @returns Number of pages needed
+ * @throws Error if total or limit is invalid
+ *
+ * @example
+ * ```typescript
+ * calculateTotalPages(100, 20) // Returns: 5
+ * calculateTotalPages(105, 20) // Returns: 6 (partial page)
+ * calculateTotalPages(0, 20) // Returns: 0 (no items)
+ * calculateTotalPages(20, 20) // Returns: 1
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function calculateTotalPages(total: number, limit: number): number;
+/**
+ * Check if there are more pages available
+ *
+ * Determines if pagination should continue based on current offset/limit and total.
+ * Useful for implementing auto-pagination with safety checks.
+ *
+ * @param currentOffset Current pagination offset
+ * @param limit Items per page
+ * @param total Total number of items
+ * @returns True if more pages available, false if at or past the end
+ *
+ * @example
+ * ```typescript
+ * hasMorePages(0, 20, 100) // Returns: true (offset 0, total 100)
+ * hasMorePages(80, 20, 100) // Returns: true (offset 80, only 20 left)
+ * hasMorePages(100, 20, 100) // Returns: false (offset equals total)
+ * hasMorePages(120, 20, 100) // Returns: false (offset past total)
+ * ```
+ *
+ * @since 6.5.0
+ */
+export declare function hasMorePages(currentOffset: number, limit: number, total: number): boolean;
+//# sourceMappingURL=pagination-helpers.d.ts.map

package/dist/src/utils/pagination-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination-helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/pagination-helpers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,yCAAyC;IACzC,MAAM,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAS7E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAA0C,GAChD,eAAe,CAGjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,MAAM,GACvB,IAAI,CAMN;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,GAAE,MAAU,GAAG,MAAM,CAEnF;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,GAAE,MAAU,EACpB,QAAQ,GAAE,MAAkD,GAC3D,MAAM,CAER;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAuBxE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,OAAO,CAST"}

package/dist/src/utils/pool-pair-parser.d.ts

@@ -38,9 +38,11 @@ export declare function parsePoolPair(poolPair: string): {
  * Format: "collection|category|type|additionalKey"
  * Example: "GALA|Unit|none|none" or "Token|Unit|BENE|client:5c806869e7fd0e2384461ce9"
  *
+ * Delegates to parsePipeDelimitedToken() from token-parser.ts.
+ *
  * @param pipeDelimitedToken Token string in pipe-delimited format
  * @returns TokenClassKey object with all components
- * @throws Error if token format is invalid
+ * @throws ValidationError if token format is invalid
  *
  * @example
  * ```typescript

package/dist/src/utils/pool-pair-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool-pair-parser.d.ts","sourceRoot":"","sources":["../../../src/utils/pool-pair-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CA2CA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,4BAA4B,CAAC,kBAAkB,EAAE,MAAM,GAAG,aAAa,CAyCtF"}
+{"version":3,"file":"pool-pair-parser.d.ts","sourceRoot":"","sources":["../../../src/utils/pool-pair-parser.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAOrD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CA4CA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,4BAA4B,CAAC,kBAAkB,EAAE,MAAM,GAAG,aAAa,CAatF"}

package/dist/src/utils/pool-state-validator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pool-state-validator.d.ts","sourceRoot":"","sources":["../../../src/utils/pool-state-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,SAAS,MAAM,cAAc,CAAC;AAErC,OAAO,KAAK,EACV,aAAa,EACb,yBAAyB,EAC1B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAG3E;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAOvD;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,cAAc,CACnB,YAAY,EAAE,IAAI,EAClB,WAAW,EAAE,IAAI,EACjB,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,yBAA6D,GACpE,OAAO;IAmHV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,MAAM,CAAC,kBAAkB,CACvB,WAAW,EAAE,IAAI,EACjB,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,yBAA6D,GACpE,yBAAyB;IA6E5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;WACU,cAAc,CACzB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,uBAAuB,EACvC,OAAO,EAAE,MAAM,OAAO,CAAC,uBAAuB,CAAC,GAC9C,OAAO,CAAC,yBAAyB,CAAC;IA6ErC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM;IAYjF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,qBAAqB,CAC1B,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,EACtB,MAAM,GAAE,MAAM,EAAO,GACpB,yBAAyB;CAsC7B"}
+{"version":3,"file":"pool-state-validator.d.ts","sourceRoot":"","sources":["../../../src/utils/pool-state-validator.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEvC,OAAO,SAAS,MAAM,cAAc,CAAC;AAIrC,OAAO,KAAK,EACV,aAAa,EACb,yBAAyB,EAC1B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAG3E;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;OAGG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAE9B;;;OAGG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;GAOG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAG3B;IAEH;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,cAAc,EAAE,yBAAyB,CAOvD;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,MAAM,CAAC,cAAc,CACnB,YAAY,EAAE,IAAI,EAClB,WAAW,EAAE,IAAI,EACjB,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,yBAA6D,GACpE,OAAO;IAqHV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,MAAM,CAAC,kBAAkB,CACvB,WAAW,EAAE,IAAI,EACjB,SAAS,EAAE,aAAa,EACxB,MAAM,GAAE,yBAA6D,GACpE,yBAAyB;IA4E5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;WACU,cAAc,CACzB,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,uBAAuB,EACvC,OAAO,EAAE,MAAM,OAAO,CAAC,uBAAuB,CAAC,GAC9C,OAAO,CAAC,yBAAyB,CAAC;IA4ErC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,wBAAwB,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM;IAYjF;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,qBAAqB,CAC1B,OAAO,EAAE,OAAO,EAChB,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,OAAO,EACtB,MAAM,GAAE,MAAM,EAAO,GACpB,yBAAyB;CAsC7B"}

package/dist/src/utils/position-filters.d.ts

@@ -18,7 +18,6 @@
  * const grouped = groupByTokenPair(active);     // Organize by GALA/GUSDC, etc.
  * ```
  */
-import BigNumber from 'bignumber.js';
 import type { LiquidityPosition } from '../types/gswap.dto';
 /**
  * Sort order for position arrays
@@ -75,7 +74,7 @@ export declare function filterByLiquidity(positions: LiquidityPosition[]): Liqui
  * // Find whale positions
  * ```
  */
-export declare function filterByMinLiquidity(positions: LiquidityPosition[], minLiquidity: string | number | BigNumber): LiquidityPosition[];
+export declare function filterByMinLiquidity(positions: LiquidityPosition[], minLiquidity: string | number): LiquidityPosition[];
 /**
  * Sort positions by liquidity amount
  *

package/dist/src/utils/position-filters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"position-filters.d.ts","sourceRoot":"","sources":["../../../src/utils/position-filters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,SAAS,MAAM,cAAc,CAAC;AACrC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,QAAQ,EAAE,iBAAiB,KAAK,OAAO,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAErF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,iBAAiB,EAAE,EAC9B,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GACxC,iBAAiB,EAAE,CAGrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,KAAK,GAAE,SAAkB,GACxB,iBAAiB,EAAE,CAOrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,iBAAiB,EAAE,CASrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,iBAAiB,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAGhG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAErB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAYjG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAW/F;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAUrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAY/F"}
+{"version":3,"file":"position-filters.d.ts","sourceRoot":"","sources":["../../../src/utils/position-filters.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAK5D;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,MAAM,CAAC;AAEvC;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,QAAQ,EAAE,iBAAiB,KAAK,OAAO,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,kCAAkC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,kDAAkD;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAErF;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,iBAAiB,EAAE,EAC9B,YAAY,EAAE,MAAM,GAAG,MAAM,GAC5B,iBAAiB,EAAE,CAGrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,KAAK,GAAE,SAAkB,GACxB,iBAAiB,EAAE,CAOrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,iBAAiB,EAAE,CASrB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,iBAAiB,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,iBAAiB,EAAE,CAIhG;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAErB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAKjG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAE/F;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,GACd,iBAAiB,EAAE,CAUrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAAC,CAK/F"}

package/dist/src/utils/query-params.d.ts

@@ -60,22 +60,6 @@ export interface QueryParamConfig<T> {
  * ```
  */
 export declare function buildBackendQueryParams<T extends Record<string, any>>(options: T, config?: QueryParamConfig<T>): Record<string, unknown>;
-/**
- * Builds pagination query parameters (common pattern)
- *
- * Convenience function for the most common use case: pagination with page/limit.
- *
- * @param page Page number
- * @param limit Items per page
- * @returns Query parameters with stringified page and limit
- *
- * @example
- * ```typescript
- * const params = buildPaginationParams(2, 20);
- * // Result: { page: '2', limit: '20' }
- * ```
- */
-export declare function buildPaginationParams(page: number, limit: number): Record<string, string>;
 /**
  * Builds token query parameters with pagination
  *

package/dist/src/utils/query-params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-params.d.ts","sourceRoot":"","sources":["../../../src/utils/query-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,iDAAiD;IACjD,eAAe,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC9B,wDAAwD;IACxD,cAAc,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC7B,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnE,OAAO,EAAE,CAAC,EACV,MAAM,GAAE,gBAAgB,CAAC,CAAC,CAAM,GAC/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyCzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAKxB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB"}
+{"version":3,"file":"query-params.d.ts","sourceRoot":"","sources":["../../../src/utils/query-params.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH;;GAEG;AACH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,iDAAiD;IACjD,eAAe,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC9B,wDAAwD;IACxD,cAAc,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IAC7B,qDAAqD;IACrD,aAAa,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;CAClD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EACnE,OAAO,EAAE,CAAC,EACV,MAAM,GAAE,gBAAgB,CAAC,CAAC,CAAM,GAC/B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsCzB;AAGD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAKzB"}