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

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

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