@gala-chain/launchpad-sdk 5.1.1 → 7.0.0-beta.1

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

@@ -1,768 +0,0 @@
-/**
- * Common Validation Patterns for Launchpad SDK
- *
- * Reusable validation utilities that consolidate duplicate patterns
- * found across services and DTOs. Eliminates boilerplate validation code
- * and provides consistent error messages throughout the SDK.
- *
- * @category Utilities
- * @since 6.20.0
- */
-/**
- * Validates numeric values within inclusive bounds (min ≤ value ≤ max)
- *
- * Consolidates 7 instances of numeric range validation found in:
- * - pagination-helpers.ts (page, limit bounds)
- * - dex-service.ts (limit, offset constraints)
- * - liquidity-service.ts (slippage tolerance bounds)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across services):
- * ```typescript
- * if (page < MIN_PAGE || page > MAX_PAGE) {
- *   throw new ValidationError(`Page must be between ${MIN_PAGE} and ${MAX_PAGE}`, 'page');
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * numericRangeValidation(page, MIN_PAGE, MAX_PAGE, 'page');
- * ```
- *
- * @param value The numeric value to validate
- * @param min Minimum allowed value (inclusive)
- * @param max Maximum allowed value (inclusive)
- * @param fieldName Field name for error messages (e.g., 'page', 'slippageTolerance')
- * @throws {ValidationError} If value is not a number or outside bounds
- *
- * @example Basic pagination validation
- * ```typescript
- * import { numericRangeValidation } from '../utils/validation-patterns';
- *
- * function fetchPools(page: number) {
- *   numericRangeValidation(page, 1, 1000, 'page');
- *   // Validation passed - proceed with fetch
- * }
- * ```
- *
- * @example With slippage tolerance
- * ```typescript
- * import { numericRangeValidation } from '../utils/validation-patterns';
- *
- * function executeSwap(slippageTolerance: number) {
- *   numericRangeValidation(slippageTolerance, 0, 1, 'slippageTolerance');
- *   // Validation passed - execute swap
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function numericRangeValidation(value: unknown, min: number, max: number, fieldName: string): void;
-/**
- * Validates string length against maximum constraint
- *
- * Consolidates 8 instances of max length validation found in:
- * - streaming.dto.ts (stream descriptions)
- * - content-flag.dto.ts (flag reasons, descriptions)
- * - comment.dto.ts (comment content)
- * - ban.dto.ts (ban reasons)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across DTOs):
- * ```typescript
- * if (typeof value !== 'string' || value.length > MAX_LENGTH) {
- *   throw new ValidationError(`Description must be at most ${MAX_LENGTH} characters`);
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * stringMaxLengthValidation(description, 500, 'description');
- * ```
- *
- * @param value The string to validate
- * @param maxLength Maximum allowed length
- * @param fieldName Field name for error messages (e.g., 'description', 'reason')
- * @throws {ValidationError} If value is not a string or exceeds max length
- *
- * @example Basic usage with comment content
- * ```typescript
- * import { stringMaxLengthValidation } from '../utils/validation-patterns';
- *
- * function postComment(content: unknown) {
- *   stringMaxLengthValidation(content, 1000, 'content');
- *   // Validation passed - post comment
- * }
- * ```
- *
- * @example With ban reason
- * ```typescript
- * import { stringMaxLengthValidation } from '../utils/validation-patterns';
- *
- * function createBan(reason: unknown) {
- *   stringMaxLengthValidation(reason, 500, 'reason');
- *   // Validation passed - create ban
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function stringMaxLengthValidation(value: unknown, maxLength: number, fieldName: string): void;
-/**
- * Validates array type and non-empty requirement with type assertion
- *
- * Consolidates 6 instances of array validation found in:
- * - token-service.ts (batch token operations)
- * - lock.dto.ts (batch lock entries)
- * - burn.dto.ts (batch burn entries)
- * - transfer.dto.ts (batch transfer entries)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across DTOs):
- * ```typescript
- * if (!Array.isArray(arr) || arr.length === 0) {
- *   throw new ValidationError('Tokens array is required and must not be empty');
- * }
- * ```
- *
- * ### After (Single call with type assertion):
- * ```typescript
- * arrayNonEmptyValidation<Token>(entries, 'tokens');
- * // entries is now typed as Token[] (type narrowed)
- * ```
- *
- * @template T The element type of the array being validated
- * @param arr The value to validate (should be an array)
- * @param fieldName Field name for error messages (e.g., 'tokens', 'entries')
- * @throws {ValidationError} If arr is not an array or is empty
- *
- * @example Basic batch operation validation
- * ```typescript
- * import { arrayNonEmptyValidation } from '../utils/validation-patterns';
- *
- * interface TokenEntry { tokenName: string; amount: string; }
- *
- * function lockTokens(entries: unknown) {
- *   arrayNonEmptyValidation<TokenEntry>(entries, 'tokens');
- *   // entries is now TokenEntry[] - safe to iterate
- *   entries.forEach(e => console.log(e.tokenName));
- * }
- * ```
- *
- * @example With type narrowing for error handling
- * ```typescript
- * import { arrayNonEmptyValidation } from '../utils/validation-patterns';
- *
- * function processEntries(data: unknown) {
- *   try {
- *     arrayNonEmptyValidation<CustomType>(data, 'entries');
- *     // data is now CustomType[]
- *   } catch (error) {
- *     if (error instanceof ValidationError) {
- *       console.log(error.message); // "Entries array is required and must not be empty"
- *     }
- *   }
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function arrayNonEmptyValidation<T>(arr: unknown, fieldName: string): asserts arr is T[];
-/**
- * Validates integer type, integer check, and positive value constraint
- *
- * Consolidates 4 instances of positive integer validation found in:
- * - comment.dto.ts (parent comment ID)
- * - content-flag.dto.ts (entity ID)
- * - moderator.dto.ts (invite ID)
- * - streaming.dto.ts (asset ID validation)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across DTOs):
- * ```typescript
- * if (typeof id !== 'number' || !Number.isInteger(id) || id <= 0) {
- *   throw new ValidationError('ID must be a positive integer');
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * positiveIntegerValidation(id, 'id');
- * ```
- *
- * @param value The value to validate
- * @param fieldName Field name for error messages (e.g., 'id', 'count')
- * @throws {ValidationError} If value is not a positive integer
- *
- * @example ID validation
- * ```typescript
- * import { positiveIntegerValidation } from '../utils/validation-patterns';
- *
- * function getComment(commentId: unknown) {
- *   positiveIntegerValidation(commentId, 'commentId');
- *   // Validation passed - fetch comment
- * }
- * ```
- *
- * @example Count validation
- * ```typescript
- * import { positiveIntegerValidation } from '../utils/validation-patterns';
- *
- * function fetchPaginated(limit: unknown) {
- *   positiveIntegerValidation(limit, 'limit');
- *   // Validation passed - fetch with limit
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function positiveIntegerValidation(value: unknown, fieldName: string): void;
-/**
- * Validates integer type, integer check, and non-negative value constraint (>= 0)
- *
- * Similar to positiveIntegerValidation but allows 0. Used for offset parameters
- * where 0 is a valid first index. Consolidates validation for pagination offset fields.
- *
- * @param value The value to validate
- * @param fieldName Field name for error messages (e.g., 'offset', 'index')
- * @throws {ValidationError} If value is not a non-negative integer
- *
- * @example Offset validation
- * ```typescript
- * import { nonNegativeIntegerValidation } from '../utils/validation-patterns';
- *
- * function fetchPaginated(offset: unknown) {
- *   nonNegativeIntegerValidation(offset, 'offset');
- *   // Validation passed - offset is >= 0
- * }
- * ```
- *
- * @since 7.0.0
- */
-export declare function nonNegativeIntegerValidation(value: unknown, fieldName: string): void;
-/**
- * Validates enum membership checking using Object.values() approach
- *
- * Consolidates 5 instances of enum validation found in:
- * - content-flag.dto.ts (ContentType enum)
- * - ban.dto.ts (BanDuration enum)
- * - moderator.dto.ts (ModeratorRole enum)
- * - api-key.dto.ts (ApiKeyRole enum)
- * - streaming.dto.ts (StreamStatus enum)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across DTOs):
- * ```typescript
- * const validRoles = Object.values(ROLE_ENUM);
- * if (!validRoles.includes(value)) {
- *   throw new ValidationError(`Role must be one of: ${validRoles.join(', ')}`);
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * enumValidationWithObjectValues(value, ROLE_ENUM, 'role');
- * ```
- *
- * @template T The type of the enum object
- * @param value The value to validate
- * @param enumObj The enum object containing valid values
- * @param fieldName Field name for error messages (e.g., 'role', 'status')
- * @throws {ValidationError} If value is not a member of the enum
- *
- * @example Role validation
- * ```typescript
- * import { enumValidationWithObjectValues } from '../utils/validation-patterns';
- *
- * enum ContentType {
- *   CHAT_MESSAGE = 'CHAT_MESSAGE',
- *   COMMENT = 'COMMENT',
- *   STREAM = 'STREAM'
- * }
- *
- * function flagContent(type: unknown) {
- *   enumValidationWithObjectValues(type, ContentType, 'contentType');
- *   // Validation passed - type is valid enum member
- * }
- * ```
- *
- * @example Status validation
- * ```typescript
- * import { enumValidationWithObjectValues } from '../utils/validation-patterns';
- *
- * enum StreamStatus {
- *   LIVE = 'LIVE',
- *   OFFLINE = 'OFFLINE',
- *   SCHEDULED = 'SCHEDULED'
- * }
- *
- * function setStreamStatus(status: unknown) {
- *   enumValidationWithObjectValues(status, StreamStatus, 'status');
- *   // Validation passed - status is valid
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function enumValidationWithObjectValues<T extends Record<string, string | number>>(value: unknown, enumObj: T, fieldName: string): void;
-/**
- * Validates value against constraint min/max properties
- *
- * Consolidates 5 instances of constraint-based range validation found in:
- * - bonding-curve-service.ts (fee portion constraints)
- * - dex-service.ts (slippage constraints)
- * - liquidity-service.ts (price range constraints)
- * - token-service.ts (decimal constraints)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across services):
- * ```typescript
- * if (constraint.min && value < constraint.min) {
- *   throw new ValidationError(`Must be at least ${constraint.min}`);
- * }
- * if (constraint.max && value > constraint.max) {
- *   throw new ValidationError(`Must be at most ${constraint.max}`);
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * constraintLengthRangeValidation(value, BEE_CONSTRAINT, 'feePortion');
- * ```
- *
- * @param value The value to validate (string or number)
- * @param constraint Constraint object with optional min and max properties
- * @param fieldName Field name for error messages (e.g., 'feePortion', 'decimals')
- * @throws {ValidationError} If value violates constraint bounds
- *
- * @example Fee constraint validation
- * ```typescript
- * import { constraintLengthRangeValidation } from '../utils/validation-patterns';
- *
- * interface FeeConstraint {
- *   min?: number;
- *   max?: number;
- * }
- *
- * const FEE_CONSTRAINT: FeeConstraint = { min: 0.1, max: 0.5 };
- *
- * function setBondingCurveFee(feePortion: unknown) {
- *   constraintLengthRangeValidation(feePortion, FEE_CONSTRAINT, 'feePortion');
- *   // Validation passed - fee is within constraints
- * }
- * ```
- *
- * @example Slippage constraint validation
- * ```typescript
- * import { constraintLengthRangeValidation } from '../utils/validation-patterns';
- *
- * const SLIPPAGE_CONSTRAINT = { min: 0, max: 10 };
- *
- * function setSlippageTolerance(tolerance: unknown) {
- *   constraintLengthRangeValidation(tolerance, SLIPPAGE_CONSTRAINT, 'slippageTolerance');
- *   // Validation passed - slippage is within constraints
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function constraintLengthRangeValidation(value: unknown, constraint: {
-    min?: number;
-    max?: number;
-}, fieldName: string): void;
-/**
- * Validates that minimum value is less than or equal to maximum value
- *
- * Consolidates 3 instances of min/max comparison validation found in:
- * - liquidity-service.ts (tick range validation)
- * - dex-service.ts (price range validation)
- * - bonding-curve-service.ts (fee range validation)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across services):
- * ```typescript
- * if (minValue > maxValue) {
- *   throw new ValidationError('Minimum must be less than or equal to maximum');
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * minMaxComparisonValidation(minPrice, maxPrice, 'priceRange');
- * ```
- *
- * @param min The minimum value to compare
- * @param max The maximum value to compare
- * @param fieldName Optional field name for error messages (e.g., 'priceRange', 'tickRange')
- * @throws {ValidationError} If min > max
- *
- * @example Tick range validation
- * ```typescript
- * import { minMaxComparisonValidation } from '../utils/validation-patterns';
- *
- * function addLiquidity(minTick: number, maxTick: number) {
- *   minMaxComparisonValidation(minTick, maxTick, 'tickRange');
- *   // Validation passed - tick range is valid
- * }
- * ```
- *
- * @example Price range validation
- * ```typescript
- * import { minMaxComparisonValidation } from '../utils/validation-patterns';
- *
- * function setPriceRange(minPrice: string, maxPrice: string) {
- *   minMaxComparisonValidation(minPrice, maxPrice, 'priceRange');
- *   // Validation passed - price range is valid
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function minMaxComparisonValidation(min: number | string, max: number | string, fieldName?: string): void;
-/**
- * Validates date type accepting Date, string, or number with NaN validation
- *
- * Consolidates 4 instances of date type validation found in:
- * - price-history-service.ts (date range validation)
- * - monitoring-service.ts (event filter dates)
- * - cache-warming-service.ts (cache expiration dates)
- * - utility-service.ts (timestamp validation)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across services):
- * ```typescript
- * if (typeof date !== 'object' && typeof date !== 'string' && typeof date !== 'number') {
- *   throw new ValidationError('Date must be a Date, string, or number');
- * }
- * if (typeof date === 'number' && isNaN(date)) {
- *   throw new ValidationError('Date timestamp must be a valid number');
- * }
- * ```
- *
- * ### After (Single call with type assertion):
- * ```typescript
- * dateTypeValidation(value, 'startDate');
- * // value is now typed as Date | string | number (not NaN)
- * ```
- *
- * @param value The value to validate
- * @param fieldName Field name for error messages (e.g., 'startDate', 'timestamp')
- * @throws {ValidationError} If value is not a valid date type or is NaN
- *
- * @example Date range validation
- * ```typescript
- * import { dateTypeValidation } from '../utils/validation-patterns';
- *
- * function fetchPriceHistory(from: unknown, to: unknown) {
- *   dateTypeValidation(from, 'fromDate');
- *   dateTypeValidation(to, 'toDate');
- *   // Both are now Date | string | number - safe to use
- * }
- * ```
- *
- * @example Event filter validation
- * ```typescript
- * import { dateTypeValidation } from '../utils/validation-patterns';
- *
- * function filterEvents(startTime: unknown) {
- *   dateTypeValidation(startTime, 'startTime');
- *   // startTime is now Date | string | number
- *   const timestamp = new Date(startTime).getTime();
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function dateTypeValidation(value: unknown, fieldName: string): asserts value is Date | string | number;
-/**
- * Validates string is not empty or whitespace-only with optional allowEmpty flag
- *
- * Consolidates 5 instances of string emptiness validation found in:
- * - transfer.dto.ts (description validation)
- * - content-flag.dto.ts (reason validation)
- * - comment.dto.ts (content validation)
- * - streaming.dto.ts (title validation)
- * - ban.dto.ts (reason validation)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across DTOs):
- * ```typescript
- * if (typeof value !== 'string' || value.trim().length === 0) {
- *   throw new ValidationError('Reason is required and cannot be empty');
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * stringEmptyLengthValidation(reason, 'reason', false);
- * ```
- *
- * @param value The value to validate
- * @param fieldName Field name for error messages (e.g., 'reason', 'content')
- * @param allowEmpty Whether to allow empty strings (default: false)
- * @throws {ValidationError} If value is not a string or is empty/whitespace (when not allowed)
- *
- * @example Required string validation
- * ```typescript
- * import { stringEmptyLengthValidation } from '../utils/validation-patterns';
- *
- * function createBan(reason: unknown) {
- *   stringEmptyLengthValidation(reason, 'reason', false);
- *   // Validation passed - reason is non-empty string
- * }
- * ```
- *
- * @example Optional string validation
- * ```typescript
- * import { stringEmptyLengthValidation } from '../utils/validation-patterns';
- *
- * function updateComment(description: unknown) {
- *   stringEmptyLengthValidation(description, 'description', true);
- *   // Validation passed - description can be empty or non-empty string
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function stringEmptyLengthValidation(value: unknown, fieldName: string, allowEmpty?: boolean): void;
-/**
- * Generic type checking with error factory pattern for flexible error customization
- *
- * Consolidates 4 instances of type checking with custom errors found in:
- * - moderator.dto.ts (complex validation rules)
- * - api-key.dto.ts (role type checking)
- * - streaming.dto.ts (enum type validation)
- * - content-flag.dto.ts (flag type validation)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across DTOs):
- * ```typescript
- * if (typeof value !== 'string') {
- *   throw new ValidationError(`Expected string but got ${typeof value}`);
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * fieldTypeCheckWithError(value, 'string', 'tokenName');
- * ```
- *
- * @param value The value to check
- * @param expectedType The expected type name (e.g., 'string', 'number', 'object')
- * @param fieldName Field name for error messages (e.g., 'role', 'tokenName')
- * @throws {ValidationError} If value type does not match expected type
- *
- * @example Basic type checking
- * ```typescript
- * import { fieldTypeCheckWithError } from '../utils/validation-patterns';
- *
- * function setRole(role: unknown) {
- *   fieldTypeCheckWithError(role, 'string', 'role');
- *   // Validation passed - role is a string
- * }
- * ```
- *
- * @example Object type checking
- * ```typescript
- * import { fieldTypeCheckWithError } from '../utils/validation-patterns';
- *
- * function setConfig(config: unknown) {
- *   fieldTypeCheckWithError(config, 'object', 'config');
- *   // Validation passed - config is an object
- * }
- * ```
- *
- * @since 6.20.0
- */
-export declare function fieldTypeCheckWithError(value: unknown, expectedType: string, fieldName: string): void;
-/**
- * Validates sort direction enum value (ASC or DESC)
- *
- * Consolidates 7 instances of sort direction validation found in:
- * - GSwapPoolQueryService.ts (pool listing sort)
- * - ChatService.ts (message sorting)
- * - CommentsService.ts (comment thread sorting)
- * - OverseersService.ts (list sorting)
- * - BanService.ts (ban list sorting)
- * - ModeratorInviteService.ts (invite list sorting)
- * - common.ts (type definitions)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across services):
- * ```typescript
- * if (sortDir !== 'ASC' && sortDir !== 'DESC') {
- *   throw new ValidationError(`Invalid sort direction: ${sortDir}`);
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * validateSortOrderDirection(sortDir, 'sortDir');
- * ```
- *
- * @param value The sort direction value to validate ('ASC' or 'DESC')
- * @param fieldName Field name for error messages (e.g., 'sortDir', 'sortOrder')
- * @throws {ValidationError} If value is not 'ASC' or 'DESC'
- *
- * @example Basic sort direction validation
- * ```typescript
- * import { validateSortOrderDirection } from '../utils/validation-patterns';
- *
- * function listComments(options: { sortDir?: string }) {
- *   if (options.sortDir) {
- *     validateSortOrderDirection(options.sortDir, 'sortDir');
- *   }
- *   // Validation passed - sortDir is either 'ASC' or 'DESC'
- * }
- * ```
- *
- * @example With service method
- * ```typescript
- * import { validateSortOrderDirection } from '../utils/validation-patterns';
- *
- * async getMessages(tokenName: string, sortDir: string = 'DESC') {
- *   validateSortOrderDirection(sortDir, 'sortDir');
- *   // Fetch and return messages sorted in the specified direction
- * }
- * ```
- *
- * @since 6.25.0
- */
-export declare function validateSortOrderDirection(value: string, fieldName: string): void;
-/**
- * Validates decimal number within range (handles NaN, Infinity, type checking)
- *
- * Consolidates 5 instances of strict decimal range validation found in:
- * - validation-patterns.ts (utility validation)
- * - GSwapLiquidityMutationService.ts (slippage tolerance)
- * - PoolCalculationService.ts (price impact bounds)
- * - constraints.ts (type definitions)
- * - swapHandler.ts (MCP handler validation)
- *
- * ## Replaces Pattern
- *
- * ### Before (Duplicate across services):
- * ```typescript
- * const num = parseFloat(value);
- * if (isNaN(num) || num < min || num > max) {
- *   throw new ValidationError(`${fieldName} must be between ${min} and ${max}`);
- * }
- * ```
- *
- * ### After (Single call):
- * ```typescript
- * validateDecimalRangeStrict(value, min, max, 'slippageTolerance');
- * ```
- *
- * @param value The value to validate (string or number)
- * @param min Minimum allowed value (inclusive)
- * @param max Maximum allowed value (inclusive)
- * @param fieldName Field name for error messages (e.g., 'slippageTolerance', 'priceImpact')
- * @throws {ValidationError} If value is not a valid number within range, or if NaN/Infinity detected
- *
- * @example Slippage tolerance validation
- * ```typescript
- * import { validateDecimalRangeStrict } from '../utils/validation-patterns';
- *
- * function swap(slippage: unknown) {
- *   validateDecimalRangeStrict(slippage, 0, 1, 'slippageTolerance');
- *   // Validation passed - slippage is a valid decimal between 0 and 1
- * }
- * ```
- *
- * @example Price impact validation
- * ```typescript
- * import { validateDecimalRangeStrict } from '../utils/validation-patterns';
- *
- * function calculateImpact(impactPercent: unknown) {
- *   validateDecimalRangeStrict(impactPercent, 0, 100, 'priceImpact');
- *   // Validation passed - impact is valid percentage between 0 and 100
- * }
- * ```
- *
- * @since 6.25.0
- */
-export declare function validateDecimalRangeStrict(value: string | number, min: number, max: number, fieldName: string): void;
-/**
- * Validates reverse bonding curve fee portion bounds.
- *
- * Ensures that:
- * - minFee >= 0.1 (minimum fee portion)
- * - maxFee <= 0.5 (maximum fee portion)
- * - minFee <= maxFee (logical ordering)
- *
- * @param minFee - Minimum fee portion (0.1 to 0.5)
- * @param maxFee - Maximum fee portion (0.1 to 0.5)
- * @param fieldName - Field name for error messages
- * @throws {ValidationError} If constraints are violated
- *
- * @example
- * // Valid: min=0.1, max=0.5
- * validateFeePortionConstraints('0.1', '0.5', 'reverseBondingCurve');
- *
- * @example
- * // Invalid: max > 0.5
- * validateFeePortionConstraints(0.1, 0.6, 'feeConfig'); // throws
- *
- * @example
- * // Invalid: min < 0.1
- * validateFeePortionConstraints(0.05, 0.5, 'feeConfig'); // throws
- *
- * @example
- * // Invalid: min > max
- * validateFeePortionConstraints(0.4, 0.2, 'feeConfig'); // throws
- */
-export declare function validateFeePortionConstraints(minFee: string | number, maxFee: string | number, fieldName: string): void;
-/**
- * Validates that min <= max constraint is satisfied.
- *
- * Ensures that a minimum value does not exceed the maximum value.
- * Supports both string and numeric inputs for flexibility.
- *
- * @param min - Minimum value (can be number or string)
- * @param max - Maximum value (can be number or string)
- * @param minLabel - Label for minimum value (e.g., 'minPrice') for error messages
- * @param maxLabel - Label for maximum value (e.g., 'maxPrice') for error messages
- * @throws {ValidationError} If min > max
- *
- * @example
- * // Valid: min < max
- * validateMinMaxRelationship(0.5, 1.0, 'minPrice', 'maxPrice');
- *
- * @example
- * // Valid: min = max
- * validateMinMaxRelationship(100, 100, 'minLiquidity', 'maxLiquidity');
- *
- * @example
- * // Invalid: min > max
- * validateMinMaxRelationship(10, 5, 'startTick', 'endTick'); // throws
- */
-export declare function validateMinMaxRelationship(min: number | string, max: number | string, minLabel: string, maxLabel: string): void;
-/**
- * Validate that a value is included in an allowed set of enum values.
- *
- * @param value - The value to validate (string)
- * @param allowedValues - Array of allowed enum values
- * @param fieldName - The field name for error messages
- * @throws ValidationError if value is not in allowedValues
- *
- * @example
- * validateConstrainedEnumVariant(
- *   role,
- *   [MODERATOR_ROLE.MODERATOR, MODERATOR_ROLE.TECHNICAL_PRODUCER],
- *   'moderatorRole'
- * );
- */
-export declare function validateConstrainedEnumVariant<T extends Record<string, string> = Record<string, string>>(value: string, allowedValues: T[], fieldName: string): void;
-//# sourceMappingURL=validation-patterns.d.ts.map