@cranberry-money/shared-utils 5.0.1 → 8.0.0

package/dist/validation.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Validation utility functions
+ */
+import type { PasswordValidation, EmailConfirmationValidation, ExtendedPasswordValidation } from '@cranberry-money/shared-types';
+/**
+ * Checks if a string contains only numeric characters
+ * @param str - The string to validate
+ * @returns true if the string contains only digits, false otherwise
+ */
+export declare function isNumericOnly(str: string): boolean;
+/**
+ * Validates password strength based on minimum requirements
+ * @param password - The password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @returns An object containing validation results
+ */
+export declare function validatePassword(password: string, minLength?: number): PasswordValidation;
+/**
+ * Validates if a verification token is in the expected format
+ * @param token - The verification token to validate
+ * @param minLength - Minimum token length (default: 6)
+ * @returns true if token appears to be valid format, false otherwise
+ */
+export declare function isValidTokenFormat(token: string, minLength?: number): boolean;
+/**
+ * Formats a verification token by removing whitespace and converting to uppercase
+ * @param token - The token to format
+ * @returns The formatted token
+ */
+export declare function formatVerificationToken(token: string): string;
+/**
+ * Validates email confirmation form data
+ * @param token - The verification token
+ * @param minLength - Minimum token length (default: 6)
+ * @returns An object containing validation results
+ */
+export declare function validateEmailConfirmation(token: string, minLength?: number): EmailConfirmationValidation;
+/**
+ * Validates if an email address is in a valid format
+ * @param email - The email address to validate
+ * @returns true if email format is valid, false otherwise
+ */
+export declare function isValidEmail(email: string): boolean;
+/**
+ * Validates if a string contains at least one uppercase letter
+ * @param str - The string to validate
+ * @returns true if contains uppercase, false otherwise
+ */
+export declare function hasUppercase(str: string): boolean;
+/**
+ * Validates if a string contains at least one lowercase letter
+ * @param str - The string to validate
+ * @returns true if contains lowercase, false otherwise
+ */
+export declare function hasLowercase(str: string): boolean;
+/**
+ * Validates if a string contains at least one special character
+ * @param str - The string to validate
+ * @returns true if contains special character, false otherwise
+ */
+export declare function hasSpecialCharacter(str: string): boolean;
+/**
+ * Validates if a string contains at least one digit
+ * @param str - The string to validate
+ * @returns true if contains digit, false otherwise
+ */
+export declare function hasDigit(str: string): boolean;
+/**
+ * Performs extended password validation with additional strength checks
+ * @param password - The password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @returns An object containing detailed validation results
+ */
+export declare function validatePasswordExtended(password: string, minLength?: number): ExtendedPasswordValidation;
+/**
+ * Validates if a phone number is in a valid format
+ * @param phoneNumber - The phone number to validate
+ * @returns true if phone number format is valid, false otherwise
+ */
+export declare function isValidPhoneNumber(phoneNumber: string): boolean;
+/**
+ * Validates if a phone number appears to be in a valid format (less strict)
+ * @param phoneNumber - The phone number to validate
+ * @param minLength - Minimum length for the phone number (default: 8)
+ * @returns true if phone number appears valid, false otherwise
+ */
+export declare function isValidPhoneFormat(phoneNumber: string, minLength?: number): boolean;
+/**
+ * Validates if a URL is in a valid format
+ * @param url - The URL to validate
+ * @returns true if URL format is valid, false otherwise
+ */
+export declare function isValidUrl(url: string): boolean;
+/**
+ * Validates if a date string is in a valid format
+ * @param dateString - The date string to validate
+ * @returns true if date format is valid, false otherwise
+ */
+export declare function isValidDate(dateString: string): boolean;
+/**
+ * Validates if a string is empty or contains only whitespace
+ * @param str - The string to validate
+ * @returns true if string is empty or whitespace only, false otherwise
+ */
+export declare function isEmptyOrWhitespace(str: string): boolean;
+/**
+ * Validates if a string meets a minimum length requirement
+ * @param str - The string to validate
+ * @param minLength - The minimum length required
+ * @returns true if string meets minimum length, false otherwise
+ */
+export declare function meetsMinLength(str: string, minLength: number): boolean;
+/**
+ * Validates if a string meets a maximum length requirement
+ * @param str - The string to validate
+ * @param maxLength - The maximum length allowed
+ * @returns true if string meets maximum length, false otherwise
+ */
+export declare function meetsMaxLength(str: string, maxLength: number): boolean;
+/**
+ * Validates if a number is within a specified range
+ * @param value - The number to validate
+ * @param min - The minimum value (inclusive)
+ * @param max - The maximum value (inclusive)
+ * @returns true if number is within range, false otherwise
+ */
+export declare function isInRange(value: number, min: number, max: number): boolean;
+/**
+ * Validates if a value is a positive number
+ * @param value - The value to validate
+ * @returns true if value is a positive number, false otherwise
+ */
+export declare function isPositiveNumber(value: number): boolean;
+/**
+ * Validates if a value is a non-negative number
+ * @param value - The value to validate
+ * @returns true if value is a non-negative number, false otherwise
+ */
+export declare function isNonNegativeNumber(value: number): boolean;
+/**
+ * Validates if a full name contains at least first and last name
+ * @param fullName - The full name to validate
+ * @param minParts - Minimum number of name parts required (default: 2)
+ * @returns true if appears to contain required name parts, false otherwise
+ */
+export declare function isValidFullName(fullName: string, minParts?: number): boolean;
+/**
+ * Validates if a date is a valid date of birth (not in future, reasonable age range)
+ * @param dateOfBirth - The date string in YYYY-MM-DD format
+ * @param minAge - Minimum age requirement (default: 13)
+ * @param maxAge - Maximum reasonable age (default: 120)
+ * @returns true if valid date of birth, false otherwise
+ */
+export declare function isValidDateOfBirth(dateOfBirth: string, minAge?: number, maxAge?: number): boolean;
+/**
+ * Formats a phone number by removing extra spaces and standardizing format
+ * @param phoneNumber - The phone number to format
+ * @returns The formatted phone number
+ */
+export declare function formatPhoneNumber(phoneNumber: string): string;
+/**
+ * Validates if investment amount is within acceptable range
+ * @param amount - The investment amount to validate
+ * @param minAmount - Minimum investment amount (default: 100)
+ * @param maxAmount - Maximum investment amount (default: 10000000)
+ * @returns true if amount is within range, false otherwise
+ */
+export declare function isValidInvestmentAmount(amount: number, minAmount?: number, maxAmount?: number): boolean;
+/**
+ * Validates if at least minimum number of items are selected
+ * @param items - Array of selected items
+ * @param minItems - Minimum number of items required (default: 1)
+ * @returns true if minimum items are selected, false otherwise
+ */
+export declare function hasMinimumSelection<T>(items: T[], minItems?: number): boolean;
+/**
+ * Validates if a value is selected (not null, undefined, or empty string)
+ * @param value - The value to check
+ * @returns true if value is selected, false otherwise
+ */
+export declare function isSelected(value: unknown): boolean;
+/**
+ * Validates that percentage values sum to a target value (default 100)
+ * @param values - Array of percentage values
+ * @param target - Target sum value (default: 100)
+ * @param tolerance - Allowed tolerance for floating point differences (default: 0.01)
+ * @returns true if sum equals target within tolerance, false otherwise
+ * @example
+ * validatePercentageSum([25, 25, 50]) // true (sums to 100)
+ * validatePercentageSum([33.33, 33.33, 33.34]) // true (within tolerance)
+ * validatePercentageSum([50, 30, 15]) // false (sums to 95)
+ */
+export declare function validatePercentageSum(values: number[], target?: number, tolerance?: number): boolean;
+/**
+ * Validates that allocation objects with percentage properties sum to 100%
+ * @param allocations - Array of objects with percentage property
+ * @param percentageField - Name of the percentage field (default: 'percentage')
+ * @param tolerance - Allowed tolerance for floating point differences (default: 0.01)
+ * @returns true if sum equals 100 within tolerance, false otherwise
+ * @example
+ * validateAllocationSum([{percentage: 50}, {percentage: 50}]) // true
+ * validateAllocationSum([{percentage: '33.33'}, {percentage: '66.67'}]) // true
+ */
+export declare function validateAllocationSum<T extends Record<string, unknown>>(allocations: T[], percentageField?: keyof T, tolerance?: number): boolean;
+/**
+ * Validates that a number is within a specified range (inclusive)
+ * @param value - The number to validate
+ * @param min - Minimum allowed value
+ * @param max - Maximum allowed value
+ * @returns true if number is within range, false otherwise
+ * @example
+ * isInNumberRange(50, 0, 100) // true
+ * isInNumberRange(150, 0, 100) // false
+ */
+export declare function isInNumberRange(value: number, min: number, max: number): boolean;
+/**
+ * Validates that a percentage is between 0 and 100
+ * @param percentage - The percentage to validate
+ * @returns true if valid percentage, false otherwise
+ * @example
+ * isValidPercentage(50) // true
+ * isValidPercentage(150) // false
+ * isValidPercentage(-10) // false
+ */
+export declare function isValidPercentage(percentage: number): boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"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"}

package/dist/validation.js

@@ -0,0 +1,337 @@
+/**
+ * Validation utility functions
+ */
+/**
+ * Checks if a string contains only numeric characters
+ * @param str - The string to validate
+ * @returns true if the string contains only digits, false otherwise
+ */
+export function isNumericOnly(str) {
+    return /^\d+$/.test(str);
+}
+/**
+ * Validates password strength based on minimum requirements
+ * @param password - The password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @returns An object containing validation results
+ */
+export function validatePassword(password, minLength = 8) {
+    return {
+        lengthValid: password.length >= minLength,
+        notNumeric: !isNumericOnly(password),
+    };
+}
+/**
+ * Validates if a verification token is in the expected format
+ * @param token - The verification token to validate
+ * @param minLength - Minimum token length (default: 6)
+ * @returns true if token appears to be valid format, false otherwise
+ */
+export function isValidTokenFormat(token, minLength = 6) {
+    const trimmedToken = token.trim();
+    // Assuming tokens are alphanumeric and meet minimum length
+    return trimmedToken.length >= minLength && /^[a-zA-Z0-9]+$/.test(trimmedToken);
+}
+/**
+ * Formats a verification token by removing whitespace and converting to uppercase
+ * @param token - The token to format
+ * @returns The formatted token
+ */
+export function formatVerificationToken(token) {
+    return token.trim().toUpperCase();
+}
+/**
+ * Validates email confirmation form data
+ * @param token - The verification token
+ * @param minLength - Minimum token length (default: 6)
+ * @returns An object containing validation results
+ */
+export function validateEmailConfirmation(token, minLength = 6) {
+    const formattedToken = formatVerificationToken(token);
+    return {
+        isValid: formattedToken.length > 0 && isValidTokenFormat(formattedToken, minLength),
+        isEmpty: formattedToken.length === 0,
+        isValidFormat: isValidTokenFormat(formattedToken, minLength),
+    };
+}
+/**
+ * Validates if an email address is in a valid format
+ * @param email - The email address to validate
+ * @returns true if email format is valid, false otherwise
+ */
+export function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email.trim());
+}
+/**
+ * Validates if a string contains at least one uppercase letter
+ * @param str - The string to validate
+ * @returns true if contains uppercase, false otherwise
+ */
+export function hasUppercase(str) {
+    return /[A-Z]/.test(str);
+}
+/**
+ * Validates if a string contains at least one lowercase letter
+ * @param str - The string to validate
+ * @returns true if contains lowercase, false otherwise
+ */
+export function hasLowercase(str) {
+    return /[a-z]/.test(str);
+}
+/**
+ * Validates if a string contains at least one special character
+ * @param str - The string to validate
+ * @returns true if contains special character, false otherwise
+ */
+export function hasSpecialCharacter(str) {
+    return /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(str);
+}
+/**
+ * Validates if a string contains at least one digit
+ * @param str - The string to validate
+ * @returns true if contains digit, false otherwise
+ */
+export function hasDigit(str) {
+    return /\d/.test(str);
+}
+/**
+ * Performs extended password validation with additional strength checks
+ * @param password - The password to validate
+ * @param minLength - Minimum password length (default: 8)
+ * @returns An object containing detailed validation results
+ */
+export function validatePasswordExtended(password, minLength = 8) {
+    const basicValidation = validatePassword(password, minLength);
+    return {
+        ...basicValidation,
+        hasUppercase: hasUppercase(password),
+        hasLowercase: hasLowercase(password),
+        hasSpecialCharacter: hasSpecialCharacter(password),
+        hasDigit: hasDigit(password),
+    };
+}
+/**
+ * Validates if a phone number is in a valid format
+ * @param phoneNumber - The phone number to validate
+ * @returns true if phone number format is valid, false otherwise
+ */
+export function isValidPhoneNumber(phoneNumber) {
+    // Remove common formatting characters
+    const cleaned = phoneNumber.replace(/[\s\-().]/g, '');
+    // Check if it's a valid phone number (digits only, 10-15 digits)
+    return /^\+?\d{10,15}$/.test(cleaned);
+}
+/**
+ * Validates if a phone number appears to be in a valid format (less strict)
+ * @param phoneNumber - The phone number to validate
+ * @param minLength - Minimum length for the phone number (default: 8)
+ * @returns true if phone number appears valid, false otherwise
+ */
+export function isValidPhoneFormat(phoneNumber, minLength = 8) {
+    const trimmedPhone = phoneNumber.trim();
+    // Basic validation: must contain digits and common phone number characters
+    return trimmedPhone.length >= minLength && /^[+\-\s\d()]+$/.test(trimmedPhone);
+}
+/**
+ * Validates if a URL is in a valid format
+ * @param url - The URL to validate
+ * @returns true if URL format is valid, false otherwise
+ */
+export function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validates if a date string is in a valid format
+ * @param dateString - The date string to validate
+ * @returns true if date format is valid, false otherwise
+ */
+export function isValidDate(dateString) {
+    const date = new Date(dateString);
+    return !isNaN(date.getTime());
+}
+/**
+ * Validates if a string is empty or contains only whitespace
+ * @param str - The string to validate
+ * @returns true if string is empty or whitespace only, false otherwise
+ */
+export function isEmptyOrWhitespace(str) {
+    return str.trim().length === 0;
+}
+/**
+ * Validates if a string meets a minimum length requirement
+ * @param str - The string to validate
+ * @param minLength - The minimum length required
+ * @returns true if string meets minimum length, false otherwise
+ */
+export function meetsMinLength(str, minLength) {
+    return str.length >= minLength;
+}
+/**
+ * Validates if a string meets a maximum length requirement
+ * @param str - The string to validate
+ * @param maxLength - The maximum length allowed
+ * @returns true if string meets maximum length, false otherwise
+ */
+export function meetsMaxLength(str, maxLength) {
+    return str.length <= maxLength;
+}
+/**
+ * Validates if a number is within a specified range
+ * @param value - The number to validate
+ * @param min - The minimum value (inclusive)
+ * @param max - The maximum value (inclusive)
+ * @returns true if number is within range, false otherwise
+ */
+export function isInRange(value, min, max) {
+    return value >= min && value <= max;
+}
+/**
+ * Validates if a value is a positive number
+ * @param value - The value to validate
+ * @returns true if value is a positive number, false otherwise
+ */
+export function isPositiveNumber(value) {
+    return typeof value === 'number' && value > 0 && isFinite(value);
+}
+/**
+ * Validates if a value is a non-negative number
+ * @param value - The value to validate
+ * @returns true if value is a non-negative number, false otherwise
+ */
+export function isNonNegativeNumber(value) {
+    return typeof value === 'number' && value >= 0 && isFinite(value);
+}
+/**
+ * Validates if a full name contains at least first and last name
+ * @param fullName - The full name to validate
+ * @param minParts - Minimum number of name parts required (default: 2)
+ * @returns true if appears to contain required name parts, false otherwise
+ */
+export function isValidFullName(fullName, minParts = 2) {
+    const trimmedName = fullName.trim();
+    const nameParts = trimmedName.split(/\s+/);
+    return nameParts.length >= minParts && nameParts.every(part => part.length > 0);
+}
+/**
+ * Validates if a date is a valid date of birth (not in future, reasonable age range)
+ * @param dateOfBirth - The date string in YYYY-MM-DD format
+ * @param minAge - Minimum age requirement (default: 13)
+ * @param maxAge - Maximum reasonable age (default: 120)
+ * @returns true if valid date of birth, false otherwise
+ */
+export function isValidDateOfBirth(dateOfBirth, minAge = 13, maxAge = 120) {
+    if (!dateOfBirth)
+        return false;
+    const birthDate = new Date(dateOfBirth);
+    const today = new Date();
+    const age = today.getFullYear() - birthDate.getFullYear();
+    const monthDiff = today.getMonth() - birthDate.getMonth();
+    const dayDiff = today.getDate() - birthDate.getDate();
+    // Adjust age if birthday hasn't occurred this year
+    const actualAge = monthDiff < 0 || (monthDiff === 0 && dayDiff < 0) ? age - 1 : age;
+    return actualAge >= minAge && actualAge <= maxAge && birthDate <= today;
+}
+/**
+ * Formats a phone number by removing extra spaces and standardizing format
+ * @param phoneNumber - The phone number to format
+ * @returns The formatted phone number
+ */
+export function formatPhoneNumber(phoneNumber) {
+    return phoneNumber.trim();
+}
+/**
+ * Validates if investment amount is within acceptable range
+ * @param amount - The investment amount to validate
+ * @param minAmount - Minimum investment amount (default: 100)
+ * @param maxAmount - Maximum investment amount (default: 10000000)
+ * @returns true if amount is within range, false otherwise
+ */
+export function isValidInvestmentAmount(amount, minAmount = 100, maxAmount = 10000000) {
+    return amount >= minAmount && amount <= maxAmount;
+}
+/**
+ * Validates if at least minimum number of items are selected
+ * @param items - Array of selected items
+ * @param minItems - Minimum number of items required (default: 1)
+ * @returns true if minimum items are selected, false otherwise
+ */
+export function hasMinimumSelection(items, minItems = 1) {
+    return items && items.length >= minItems;
+}
+/**
+ * Validates if a value is selected (not null, undefined, or empty string)
+ * @param value - The value to check
+ * @returns true if value is selected, false otherwise
+ */
+export function isSelected(value) {
+    return value !== null && value !== undefined && value !== '';
+}
+// ENHANCED VALIDATION UTILITIES (Phase 14)
+/**
+ * Validates that percentage values sum to a target value (default 100)
+ * @param values - Array of percentage values
+ * @param target - Target sum value (default: 100)
+ * @param tolerance - Allowed tolerance for floating point differences (default: 0.01)
+ * @returns true if sum equals target within tolerance, false otherwise
+ * @example
+ * validatePercentageSum([25, 25, 50]) // true (sums to 100)
+ * validatePercentageSum([33.33, 33.33, 33.34]) // true (within tolerance)
+ * validatePercentageSum([50, 30, 15]) // false (sums to 95)
+ */
+export function validatePercentageSum(values, target = 100, tolerance = 0.01) {
+    if (!Array.isArray(values) || values.length === 0)
+        return false;
+    const sum = values.reduce((total, value) => total + (value || 0), 0);
+    return Math.abs(sum - target) <= tolerance;
+}
+/**
+ * Validates that allocation objects with percentage properties sum to 100%
+ * @param allocations - Array of objects with percentage property
+ * @param percentageField - Name of the percentage field (default: 'percentage')
+ * @param tolerance - Allowed tolerance for floating point differences (default: 0.01)
+ * @returns true if sum equals 100 within tolerance, false otherwise
+ * @example
+ * validateAllocationSum([{percentage: 50}, {percentage: 50}]) // true
+ * validateAllocationSum([{percentage: '33.33'}, {percentage: '66.67'}]) // true
+ */
+export function validateAllocationSum(allocations, percentageField = 'percentage', tolerance = 0.01) {
+    if (!Array.isArray(allocations) || allocations.length === 0)
+        return false;
+    const values = allocations.map(allocation => {
+        const value = allocation[percentageField];
+        return typeof value === 'string' ? parseFloat(value) || 0 : Number(value) || 0;
+    });
+    return validatePercentageSum(values, 100, tolerance);
+}
+/**
+ * Validates that a number is within a specified range (inclusive)
+ * @param value - The number to validate
+ * @param min - Minimum allowed value
+ * @param max - Maximum allowed value
+ * @returns true if number is within range, false otherwise
+ * @example
+ * isInNumberRange(50, 0, 100) // true
+ * isInNumberRange(150, 0, 100) // false
+ */
+export function isInNumberRange(value, min, max) {
+    return typeof value === 'number' && !isNaN(value) && value >= min && value <= max;
+}
+/**
+ * Validates that a percentage is between 0 and 100
+ * @param percentage - The percentage to validate
+ * @returns true if valid percentage, false otherwise
+ * @example
+ * isValidPercentage(50) // true
+ * isValidPercentage(150) // false
+ * isValidPercentage(-10) // false
+ */
+export function isValidPercentage(percentage) {
+    return isInNumberRange(percentage, 0, 100);
+}

package/dist/withdrawal.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Withdrawal-related utility functions
+ *
+ * This module provides pure functions for formatting withdrawal amounts,
+ * calculating liquidation progress, and other withdrawal-related operations.
+ * Functions are designed to work with generic types to maintain flexibility.
+ */
+import type { LiquidationProgress } from '@cranberry-money/shared-types';
+/**
+ * Formats a withdrawal amount as currency
+ *
+ * @param amount - Withdrawal amount as string or number
+ * @returns Formatted currency string with AUD symbol
+ *
+ * @example
+ * ```typescript
+ * formatWithdrawalAmount(5000) // 'A$5,000.00'
+ * formatWithdrawalAmount('5000.50') // 'A$5,000.50'
+ * ```
+ */
+export declare function formatWithdrawalAmount(amount: string | number): string;
+/**
+ * Formats a liquidation value as currency
+ *
+ * @param value - Liquidation value as string or number
+ * @returns Formatted currency string with AUD symbol
+ *
+ * @example
+ * ```typescript
+ * formatLiquidationValue(10000) // 'A$10,000.00'
+ * formatLiquidationValue('10000.50') // 'A$10,000.50'
+ * ```
+ */
+export declare function formatLiquidationValue(value: string | number): string;
+/**
+ * Formats share quantity without decimal places
+ *
+ * @param shares - Number of shares
+ * @returns Formatted number string with thousands separators
+ *
+ * @example
+ * ```typescript
+ * formatSharesQuantity(1234) // '1,234'
+ * formatSharesQuantity(1234567) // '1,234,567'
+ * ```
+ */
+export declare function formatSharesQuantity(shares: number): string;
+/**
+ * Calculates liquidation progress statistics
+ *
+ * @param liquidations - Array of liquidation objects with liquidationStatus property
+ * @returns Progress statistics including counts and completion rate
+ *
+ * @example
+ * ```typescript
+ * const liquidations = [
+ *   { liquidationStatus: 'PENDING' },
+ *   { liquidationStatus: 'SETTLED' },
+ *   { liquidationStatus: 'FAILED' }
+ * ];
+ * calculateLiquidationProgress(liquidations)
+ * // Returns: { total: 3, pending: 1, inProgress: 0, completed: 1, failed: 1, completionRate: 33.33 }
+ * ```
+ */
+export declare function calculateLiquidationProgress<T extends {
+    liquidationStatus: string;
+}>(liquidations: T[]): LiquidationProgress;
+/**
+ * Calculates total estimated value from liquidations
+ *
+ * @param liquidations - Array of liquidation objects with estimatedValue property
+ * @returns Total estimated value as number
+ *
+ * @example
+ * ```typescript
+ * const liquidations = [
+ *   { estimatedValue: '1000.50' },
+ *   { estimatedValue: '2000' },
+ *   { estimatedValue: null }
+ * ];
+ * getTotalEstimatedValue(liquidations) // 3000.50
+ * ```
+ */
+export declare function getTotalEstimatedValue<T extends {
+    estimatedValue?: string | null;
+}>(liquidations: T[]): number;
+//# sourceMappingURL=withdrawal.d.ts.map

package/dist/withdrawal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withdrawal.d.ts","sourceRoot":"","sources":["../src/withdrawal.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAazE;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAMtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAMrE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAK3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,SAAS;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE,EAClF,YAAY,EAAE,CAAC,EAAE,GAChB,mBAAmB,CAkBrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,EAAE,YAAY,EAAE,CAAC,EAAE,GAAG,MAAM,CAI9G"}