@gala-chain/launchpad-sdk 6.0.0 → 7.0.0-beta.2

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

@@ -1,149 +0,0 @@
-/**
- * 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 type 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.
- *
- * Uses logarithmic formula for efficiency: (1.0001)^tick = e^(tick * ln(1.0001))
- * This avoids expensive BigNumber.pow operations with large exponents.
- *
- * @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

@@ -1 +0,0 @@
-{"version":3,"file":"numeric-wrappers.d.ts","sourceRoot":"","sources":["../../../src/utils/numeric-wrappers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAI1C;;;;;;;;;;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;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAOnD;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

@@ -1,115 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,81 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,161 +0,0 @@
-/**
- * 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;
-}
-/**
- * Create pagination query object for API requests
- *
- * Constructs a standardized pagination query with offset and limit.
- * Validates that offset and limit are within acceptable bounds.
- *
- * @param offset Zero-based offset for pagination
- * @param limit Maximum results per page (default: PAGINATION_DEFAULTS.DEFAULT_LIMIT)
- * @returns Object with offset and limit ready for API requests
- * @throws Error if offset or limit is invalid
- *
- * @example Basic usage
- * ```typescript
- * const query = createPaginationQuery(0, 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(20);
- * // Result: { offset: 20, limit: PAGINATION_DEFAULTS.DEFAULT_LIMIT }
- * ```
- *
- * @example In API request
- * ```typescript
- * const pools = await api.fetchPools({
- *   ...createPaginationQuery(40, 50),
- *   search: 'GALA'
- * });
- * ```
- *
- * @since 7.0.0
- */
-export declare function createPaginationQuery(offset: number, limit?: number): PaginationQuery;
-/**
- * Validate pagination parameters
- *
- * Ensures offset and limit values are valid before using them in API requests.
- * Throws descriptive errors for invalid values.
- *
- * @param offset Zero-based offset to validate
- * @param limit Limit/page size to validate
- * @param contextMessage Optional message for error context (e.g., "fetchPools")
- * @throws Error if offset or limit is invalid with descriptive message
- *
- * @example Basic validation
- * ```typescript
- * validatePaginationParams(0, 20);
- * // No error - both valid
- *
- * validatePaginationParams(-1, 20);
- * // Throws: "Invalid offset: -1. Offset must be a non-negative integer."
- * ```
- *
- * @example With context
- * ```typescript
- * validatePaginationParams(offset, limit, 'fetchTokens');
- * // Throws: "fetchTokens: Invalid limit: 0. Limit must be a positive integer."
- * ```
- *
- * @since 7.0.0
- */
-export declare function validatePaginationParams(offset: number, limit: number, _contextMessage?: string): void;
-/**
- * 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

@@ -1 +0,0 @@
-{"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;AAGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,KAAK,GAAE,MAA0C,GAChD,eAAe,CAUjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,MAAM,GACvB,IAAI,CAQN;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/pagination-validation.d.ts

@@ -1,88 +0,0 @@
-/**
- * Pagination Options Validation Helpers
- *
- * Utilities to safely build pagination options without violating
- * TypeScript's exactOptionalPropertyTypes constraint.
- *
- * With exactOptionalPropertyTypes: true, you cannot pass undefined for optional properties.
- * These helpers ensure proper handling.
- *
- * @category Utilities
- * @since 8.0.0
- */
-import type { BasePaginationOptions } from '../types/common';
-/**
- * Safely build pagination options without passing undefined
- *
- * This helper ensures that optional pagination fields are only included
- * when they have actual values, complying with exactOptionalPropertyTypes.
- *
- * @param options - Partial pagination options (may have undefined values)
- * @returns Clean pagination options object without undefined properties
- *
- * @example
- * ```typescript
- * const cursor = getCursorFromSomewhere() || undefined;
- * const pageSize = getPageSize();
- *
- * // This would cause TS2379 error:
- * // const options: BasePaginationOptions = { cursor, pageSize };
- *
- * // Use this helper instead:
- * const options = buildSafePaginationOptions({
- *   cursor,      // May be undefined
- *   pageSize
- * });
- * // Result has no undefined values
- * ```
- *
- * @since 8.0.0
- */
-export declare function buildSafePaginationOptions(options: Partial<BasePaginationOptions>): BasePaginationOptions;
-/**
- * Safely build pagination options from a base object and overrides
- *
- * Merges base pagination options with overrides, ensuring no undefined values
- * are passed for optional properties.
- *
- * @param base - Base pagination options (may be partial)
- * @param overrides - Override values (may have undefined values)
- * @returns Merged pagination options without undefined properties
- *
- * @example
- * ```typescript
- * const baseOptions = { pageSize: 50 };
- * const cursor = getCursor();  // May be undefined
- *
- * // Merge safely without risk of TS2379 error
- * const merged = mergeSafePaginationOptions(baseOptions, { cursor });
- * // Result: { pageSize: 50, cursor: 'abc123' } (if cursor defined)
- * // Result: { pageSize: 50 } (if cursor undefined)
- * ```
- *
- * @since 8.0.0
- */
-export declare function mergeSafePaginationOptions(base: Partial<BasePaginationOptions>, overrides: Partial<BasePaginationOptions>): BasePaginationOptions;
-/**
- * Conditionally include a cursor in pagination options
- *
- * Useful for the common pattern of optionally including cursor-based pagination.
- *
- * @param baseOptions - Base pagination options
- * @param cursor - Cursor token (may be undefined)
- * @returns Options with cursor only if cursor is defined
- *
- * @example
- * ```typescript
- * const nextPageOptions = addCursorToPagination(
- *   { pageSize: 50 },
- *   pageInfo.nextCursor
- * );
- * // Result: { pageSize: 50, cursor: 'abc123' } or { pageSize: 50 }
- * // depending on whether nextCursor is defined
- * ```
- *
- * @since 8.0.0
- */
-export declare function addCursorToPagination(baseOptions: BasePaginationOptions, cursor: string | undefined): BasePaginationOptions;
-//# sourceMappingURL=pagination-validation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"pagination-validation.d.ts","sourceRoot":"","sources":["../../../src/utils/pagination-validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACtC,qBAAqB,CAcvB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,OAAO,CAAC,qBAAqB,CAAC,EACpC,SAAS,EAAE,OAAO,CAAC,qBAAqB,CAAC,GACxC,qBAAqB,CAGvB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,qBAAqB,EAClC,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,qBAAqB,CAKvB"}

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

@@ -1,57 +0,0 @@
-/**
- * Pool Pair Parser
- *
- * Utilities for parsing poolPair strings from DEX pool discovery into components
- * and converting pipe-delimited token formats to TypeClass objects.
- *
- * @packageDocumentation
- */
-import type { TokenClassKey } from '../types/common';
-/**
- * Parse poolPair string from fetchDexPools() into token0, token1, and fee components
- *
- * Format: "token0/token1/fee"
- * Example: "GALA|Unit|none|none/Token|Unit|BENE|client:5c806869e7fd0e2384461ce9/3000"
- *
- * Each token is in pipe-delimited format: "collection|category|type|additionalKey"
- *
- * @param poolPair Pool pair string from fetchDexPools() result
- * @returns Object with token0, token1 (both in pipe-delimited format), and fee tier
- * @throws Error if poolPair format is invalid
- *
- * @example
- * ```typescript
- * const { token0, token1, fee } = parsePoolPair(
- *   'GALA|Unit|none|none/Token|Unit|BENE|client:123/3000'
- * );
- * // → { token0: 'GALA|Unit|none|none', token1: 'Token|Unit|BENE|client:123', fee: 3000 }
- * ```
- */
-export declare function parsePoolPair(poolPair: string): {
-    token0: string;
-    token1: string;
-    fee: number;
-};
-/**
- * Convert pipe-delimited token string to TokenClassKey object
- *
- * 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 ValidationError if token format is invalid
- *
- * @example
- * ```typescript
- * const tokenClass = pipeDelimitedToTokenClassKey('GALA|Unit|none|none');
- * // → { collection: 'GALA', category: 'Unit', type: 'none', additionalKey: 'none' }
- *
- * const tokenClass2 = pipeDelimitedToTokenClassKey('Token|Unit|BENE|client:123');
- * // → { collection: 'Token', category: 'Unit', type: 'BENE', additionalKey: 'client:123' }
- * ```
- */
-export declare function pipeDelimitedToTokenClassKey(pipeDelimitedToken: string): TokenClassKey;
-//# sourceMappingURL=pool-pair-parser.d.ts.map

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

@@ -1 +0,0 @@
-{"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"}