bangla-stdlib 1.0.2 → 1.0.4

package/dist/index.d.cts

@@ -7,6 +7,15 @@ declare const BANGLA_WEEKDAYS: readonly ["রবিবার", "সোমবা
 
 declare const BANGLA_SEASONS: readonly ["গ্রীষ্ম", "বর্ষা", "শরৎ", "হেমন্ত", "শীত", "বসন্ত"];
 
+/**
+ * Phone operator constants for Bangladesh
+ */
+declare const VALID_OPERATOR_CODES: readonly ["013", "014", "015", "016", "017", "018", "019"];
+declare const OPERATOR_INFO: Record<string, {
+    name: string;
+    nameBangla: string;
+}>;
+
 /**
  * Converts English/Arabic digits to Bangla digits.
  *
@@ -195,9 +204,62 @@ declare function fromBanglaNumber(input: string): number;
 declare function toWords(number: number): string;
 
 /**
- * Formats large numbers with Bengali unit names (হাজার, লক্ষ, কোটি).
+ * Common separator characters used in formatting
+ */
+type Separator = ',' | ' ' | '-' | '.';
+
+/**
+ * Centralized option interfaces for all formatting and conversion functions
+ */
+
+/**
+ * Base formatting options shared across modules
+ */
+interface BaseFormatOptions {
+    /**
+     * Whether to use Bangla digits (০-৯) instead of English digits (0-9)
+     * @default true
+     */
+    useBanglaDigits?: boolean;
+}
+/**
+ * Number formatting options
+ */
+interface NumberFormatOptions extends BaseFormatOptions {
+    /**
+     * Separator character for thousands
+     * @default ','
+     */
+    separator?: Separator;
+    /**
+     * Minimum number of fraction digits
+     * @default undefined
+     */
+    minimumFractionDigits?: number;
+    /**
+     * Maximum number of fraction digits
+     * @default undefined
+     */
+    maximumFractionDigits?: number;
+}
+
+/**
+ * Formats a number with comma separators using Indian/Bangla numbering system
+ * Pattern: rightmost 3 digits, then groups of 2 digits
+ * @param number - The number to format
+ * @param options - Formatting options
+ * @returns Formatted number string
+ * @example
+ * formatNumber(1234567) // '12,34,567'
+ * formatNumber(1234567.89) // '12,34,567.89'
+ * formatNumber(1234567, { useBanglaDigits: false }) // '12,34,567'
+ */
+declare function formatNumber(number: number | string, options?: NumberFormatOptions): string;
+
+/**
+ * Formats large numbers with Bangla unit names (হাজার, লক্ষ, কোটি).
  *
- * This function simplifies large numbers by expressing them in common Bengali units:
+ * This function simplifies large numbers by expressing them in common Bangla units:
  * - হাজার (Thousand): 1,000
  * - লক্ষ (Lakh): 100,000
  * - কোটি (Crore): 10,000,000
@@ -265,25 +327,10 @@ declare function formatWithUnits(number: number, options?: {
     useBanglaDigits?: boolean;
 }): string;
 
-interface FormatNumberOptions {
-    /** Whether to use Bangla digits (default: true) */
-    useBanglaDigits?: boolean;
-    /** Separator character for thousands (default: ',') */
-    separator?: string;
-}
 /**
- * Formats a number with comma separators using Indian/Bangla numbering system
- * Pattern: rightmost 3 digits, then groups of 2 digits
- * @param number - The number to format
- * @param options - Formatting options
- * @returns Formatted number string
- * @example
- * formatNumber(1234567) // '12,34,567'
- * formatNumber(1234567.89) // '12,34,567.89'
- * formatNumber(1234567, { useBanglaDigits: false }) // '12,34,567'
+ * Number validation functions
+ * Uses core validation utilities where applicable while maintaining domain-specific logic
  */
-declare function formatNumber(number: number | string, options?: FormatNumberOptions): string;
-
 /**
  * Validates if a string contains a valid Bangla number.
  *
@@ -390,104 +437,63 @@ declare function isValidNumberForOrdinal(input: number): boolean;
 declare function sanitizeNumberInput(input: string): string;
 
 /**
- * Result of a batch conversion operation.
+ * Result types for batch operations and multi-value returns
  */
-interface BatchConversionResult {
-    /** Successfully converted values */
+/**
+ * Generic batch processing result
+ * Used by batch conversion, validation, and formatting operations
+ */
+interface BatchResult<TInput, TOutput> {
+    /** Successfully processed items */
     success: Array<{
-        input: number | string;
-        output: string;
+        input: TInput;
+        output: TOutput;
     }>;
-    /** Failed conversions with error messages */
+    /** Failed items with error messages */
     errors: Array<{
-        input: number | string;
+        input: TInput;
         error: string;
     }>;
 }
+
 /**
- * Converts multiple numbers to Bangla in a single operation.
- *
- * This function processes an array of numbers/strings and converts them to Bangla,
- * collecting both successful conversions and errors. This is useful for batch
- * processing where you want to continue even if some inputs fail.
+ * Generic range validation utilities
+ * Used across number, date, time, month, weekday, and other modules
+ */
+/**
+ * Check if a number is within a specified range (inclusive)
  *
- * @param inputs - Array of numbers or strings to convert
- * @returns Object containing successful conversions and errors
+ * @param value - Number to check
+ * @param min - Minimum value (inclusive)
+ * @param max - Maximum value (inclusive)
+ * @returns true if value is in range
+ */
+declare function isNumberInRange$1(value: number, min: number, max: number): boolean;
+
+/**
+ * Converts multiple numbers to Bangla in a single operation.
  *
- * @example
- * ```typescript
- * const results = batchToBanglaNumber([123, '456', 'invalid', 789]);
- * console.log(results.success);
- * // [
- * //   { input: 123, output: '১২৩' },
- * //   { input: '456', output: '৪৫৬' },
- * //   { input: 789, output: '৭৮৯' }
- * // ]
- * console.log(results.errors);
- * // [{ input: 'invalid', error: 'Invalid character in number: i' }]
- * ```
+ * Uses the core batch processor pattern to eliminate duplication.
  */
-declare function batchToBanglaNumber(inputs: Array<number | string>): BatchConversionResult;
+declare const batchToBanglaNumber: (inputs: (string | number)[]) => BatchResult<string | number, string>;
 /**
  * Converts multiple Bangla numbers to JavaScript numbers in a single operation.
  *
- * @param inputs - Array of Bangla number strings to convert
- * @returns Object containing successful conversions and errors
- *
- * @example
- * ```typescript
- * const results = batchFromBanglaNumber(['১২৩', '৪৫৬', 'invalid']);
- * console.log(results.success);
- * // [
- * //   { input: '১২৩', output: 123 },
- * //   { input: '৪৫৬', output: 456 }
- * // ]
- * console.log(results.errors);
- * // [{ input: 'invalid', error: 'Invalid Bangla digit: i' }]
- * ```
+ * Uses the core batch processor pattern to eliminate duplication.
  */
-declare function batchFromBanglaNumber(inputs: string[]): {
-    success: Array<{
-        input: string;
-        output: number;
-    }>;
-    errors: Array<{
-        input: string;
-        error: string;
-    }>;
-};
+declare const batchFromBanglaNumber: (inputs: string[]) => BatchResult<string, number>;
 /**
  * Safely converts a number to Bangla with a fallback value.
  *
- * This is useful in UI contexts where you want to always display something,
- * even if the conversion fails.
- *
- * @param input - The number or string to convert
- * @param fallback - Value to return if conversion fails (default: '')
- * @returns Bangla number string or fallback value
- *
- * @example
- * ```typescript
- * safeToBanglaNumber(123); // '১২৩'
- * safeToBanglaNumber(NaN, '---'); // '---'
- * safeToBanglaNumber(Infinity, 'N/A'); // 'N/A'
- * ```
+ * Uses the core safe wrapper pattern to eliminate duplication.
  */
-declare function safeToBanglaNumber(input: number | string, fallback?: string): string;
+declare const safeToBanglaNumber: (input: string | number, fallback?: string | undefined) => string;
 /**
  * Safely converts a Bangla number to a JavaScript number with a fallback.
  *
- * @param input - The Bangla number string to convert
- * @param fallback - Value to return if conversion fails (default: 0)
- * @returns JavaScript number or fallback value
- *
- * @example
- * ```typescript
- * safeFromBanglaNumber('১২৩'); // 123
- * safeFromBanglaNumber('invalid', -1); // -1
- * ```
+ * Uses the core safe wrapper pattern to eliminate duplication.
  */
-declare function safeFromBanglaNumber(input: string, fallback?: number): number;
+declare const safeFromBanglaNumber: (input: string, fallback?: number | undefined) => number;
 /**
  * Parses user input with sanitization and conversion to Bangla.
  *
@@ -523,7 +529,7 @@ declare function parseAndConvertToBangla(input: string): string;
  * formatAndConvert(1234567, true, ' '); // '১২ ৩৪ ৫৬৭'
  * ```
  */
-declare function formatAndConvert(input: number, useBanglaDigits?: boolean, separator?: string): string;
+declare function formatAndConvert(input: number, useBanglaDigits?: boolean, separator?: Separator): string;
 /**
  * Converts a number to its word representation and also provides the Bangla digit form.
  *
@@ -551,8 +557,7 @@ declare function convertToWordsAndDigits(input: number): {
 /**
  * Range validation: checks if a number is within a specified range.
  *
- * This is useful for form validation or business logic where numbers
- * must fall within certain bounds.
+ * Re-exported from core validation utilities for convenience.
  *
  * @param value - The number to check
  * @param min - Minimum allowed value (inclusive)
@@ -566,7 +571,7 @@ declare function convertToWordsAndDigits(input: number): {
  * isNumberInRange(-5, 0, 100); // false
  * ```
  */
-declare function isNumberInRange(value: number, min: number, max: number): boolean;
+declare const isNumberInRange: typeof isNumberInRange$1;
 /**
  * Truncates a number to a specified number of decimal places without rounding.
  *
@@ -588,108 +593,50 @@ declare function truncateDecimals(value: number, decimals?: number): number;
 /**
  * Formats a number as Bangladeshi Taka currency in Bangla.
  *
- * This function converts numeric currency amounts to Bengali format with
- * the Taka symbol (৳) and/or word (টাকা). Amounts are automatically formatted
- * to 2 decimal places.
- *
- * **Currency Symbol:** ৳ (Taka sign)
- * **Currency Word:** টাকা (Taka)
+ * Uses Bangladeshi number grouping (rightmost 3 digits, then groups of 2).
  *
  * @param amount - The amount to format (number or string)
  * @param options - Formatting options
- * @param options.includeSymbol - Include the ৳ symbol (default: true)
- * @param options.includeWord - Include the word "টাকা" (default: false)
+ * @param options.symbol - Show ৳ symbol instead of টাকা word (default: false)
+ * @param options.word - Show টাকা word (default: true, false when symbol is true)
+ * @param options.useBanglaDigits - Use Bangla digits (default: true)
  * @returns Formatted currency string in Bangla
  * @throws {Error} If amount is NaN or cannot be parsed
  *
  * @example
- * Basic formatting with symbol (default):
- * ```typescript
- * formatCurrency(1234.56);
- * // '৳ ১২৩৪.৫৬'
- *
- * formatCurrency(100);
- * // '৳ ১০০.০০'
- *
- * formatCurrency('999.99');
- * // '৳ ৯৯৯.৯৯'
- * ```
- *
- * @example
- * Without symbol:
- * ```typescript
- * formatCurrency(1234.56, { includeSymbol: false });
- * // '১২৩৪.৫৬'
- *
- * formatCurrency(500, { includeSymbol: false });
- * // '৫০০.০০'
- * ```
- *
- * @example
- * With word "টাকা":
- * ```typescript
- * formatCurrency(100, { includeWord: true });
- * // '৳ ১০০.০০ টাকা'
- *
- * formatCurrency(1000, { includeWord: true });
- * // '৳ ১০০০.০০ টাকা'
- *
- * formatCurrency(50, { includeSymbol: false, includeWord: true });
- * // '৫০.০০ টাকা'
- * ```
- *
- * @example
- * Large amounts:
- * ```typescript
- * formatCurrency(1000000);
- * // '৳ ১০০০০০০.০০'
- *
- * formatCurrency(50000000, { includeWord: true });
- * // '৳ ৫০০০০০০০.০০ টাকা'
- * ```
- *
- * @example
- * Small and zero amounts:
+ * Default (with word and separators):
  * ```typescript
- * formatCurrency(0);
- * // '৳ ০.০০'
- *
- * formatCurrency(0.5);
- * // '৳ ০.৫০'
- *
- * formatCurrency(0.01);
- * // '৳ ০.০১'
+ * formatCurrency(1500);       // '১,৫০০ টাকা'
+ * formatCurrency(1234.56);    // '১,২৩৪.৫৬ টাকা'
+ * formatCurrency(10000000);   // '১,০০,০০,০০০ টাকা'
  * ```
  *
  * @example
- * Negative amounts (debits):
+ * With symbol:
  * ```typescript
- * formatCurrency(-100);
- * // '৳ -১০০.০০'
- *
- * formatCurrency(-1234.56, { includeWord: true });
- * // '৳ -১২৩৪.৫৬ টাকা'
+ * formatCurrency(2500, { symbol: true });  // '৳২,৫০০'
+ * formatCurrency(1234.56, { symbol: true }); // '৳১,২৩৪.৫৬'
  * ```
  *
  * @example
- * Error cases:
+ * With English digits:
  * ```typescript
- * formatCurrency('invalid');
- * // throws Error: Invalid amount
- *
- * formatCurrency(NaN);
- * // throws Error: Invalid amount
+ * formatCurrency(1234.56, { symbol: true, useBanglaDigits: false });
+ * // '৳1,234.56'
  * ```
  */
 declare function formatCurrency(amount: number | string, options?: {
+    symbol?: boolean;
+    word?: boolean;
     includeSymbol?: boolean;
     includeWord?: boolean;
+    useBanglaDigits?: boolean;
 }): string;
 
 /**
  * Parses a Bangla currency string to a number.
  *
- * This function extracts numeric values from Bengali currency strings,
+ * This function extracts numeric values from Bangla currency strings,
  * automatically removing currency symbols (৳) and words (টাকা).
  * It supports various formatting styles commonly used in Bangladesh.
  *
@@ -938,63 +885,9 @@ declare function hasTakaSymbol(value: string): boolean;
 declare function hasTakaWord(value: string): boolean;
 
 /**
- * Safely formats a currency amount with a fallback value.
- *
- * Unlike formatCurrency, this function doesn't throw errors for invalid inputs.
- * Instead, it returns the fallback value.
- *
- * @param amount - The amount to format
- * @param options - Formatting options
- * @param fallback - Value to return if formatting fails (default: '')
- * @returns Formatted currency string or fallback value
- *
- * @example
- * ```typescript
- * safeFormatCurrency(1234.56); // '৳ ১২৩৪.৫৬'
- * safeFormatCurrency(NaN); // ''
- * safeFormatCurrency(Infinity, {}, 'N/A'); // 'N/A'
- * safeFormatCurrency(100, { includeWord: true }); // '৳ ১০০.০০ টাকা'
- * ```
- */
-declare function safeFormatCurrency(amount: number | string, options?: {
-    includeSymbol?: boolean;
-    includeWord?: boolean;
-}, fallback?: string): string;
-/**
- * Safely parses a currency string with a fallback value.
- *
- * @param currencyString - The currency string to parse
- * @param fallback - Value to return if parsing fails (default: 0)
- * @returns Parsed amount or fallback value
- *
- * @example
- * ```typescript
- * safeParseCurrency('৳ ১২৩৪.৫৬'); // 1234.56
- * safeParseCurrency('invalid'); // 0
- * safeParseCurrency('invalid', -1); // -1
- * ```
- */
-declare function safeParseCurrency(currencyString: string, fallback?: number): number;
-/**
- * Formats an array of currency amounts.
- *
- * @param amounts - Array of amounts to format
- * @param options - Formatting options
- * @returns Array of formatted currency strings (invalid amounts are skipped)
- *
- * @example
- * ```typescript
- * batchFormatCurrency([100, 200, 300]);
- * // ['৳ ১০০.০০', '৳ ২০০.০০', '৳ ৩০০.০০']
- *
- * batchFormatCurrency([100, NaN, 200], { includeWord: true });
- * // ['৳ ১০০.০০ টাকা', '৳ ২০০.০০ টাকা']
- * ```
+ * Currency arithmetic operations
+ * Basic mathematical operations with proper rounding
  */
-declare function batchFormatCurrency(amounts: number[], options?: {
-    includeSymbol?: boolean;
-    includeWord?: boolean;
-}): string[];
 /**
  * Rounds a currency amount to a specified number of decimal places.
  *
@@ -1025,6 +918,20 @@ declare function roundCurrency(amount: number, decimals?: number): number;
  * ```
  */
 declare function sumCurrency(amounts: number[]): number;
+/**
+ * Adds two currency amounts.
+ *
+ * @param amount1 - First amount
+ * @param amount2 - Second amount
+ * @returns Sum rounded to 2 decimal places
+ *
+ * @example
+ * ```typescript
+ * addCurrency(100, 200); // 300
+ * addCurrency(123.45, 67.89); // 191.34
+ * ```
+ */
+declare function addCurrency(amount1: number, amount2: number): number;
 /**
  * Calculates the difference between two currency amounts.
  *
@@ -1072,6 +979,11 @@ declare function multiplyCurrency(amount: number, factor: number): number;
  * ```
  */
 declare function divideCurrency(amount: number, divisor: number): number;
+
+/**
+ * Currency percentage operations
+ * Tax, discount, and percentage calculations
+ */
 /**
  * Calculates a percentage of a currency amount.
  *
@@ -1117,6 +1029,40 @@ declare function applyDiscount(amount: number, discountPercent: number): number;
  * ```
  */
 declare function addTax(amount: number, taxPercent: number): number;
+/**
+ * Calculates the tax amount only (without adding to base).
+ *
+ * This is an alias for calculatePercentage but with clearer naming for tax calculations.
+ *
+ * @param amount - The base amount
+ * @param taxPercent - Tax percentage
+ * @returns Tax amount rounded to 2 decimal places
+ *
+ * @example
+ * ```typescript
+ * calculateTax(1000, 15); // 150
+ * calculateTax(500, 10); // 50
+ * ```
+ */
+declare function calculateTax(amount: number, taxPercent: number): number;
+/**
+ * Calculates the discount amount only (without subtracting from base).
+ *
+ * @param amount - The base amount
+ * @param discountPercent - Discount percentage
+ * @returns Discount amount rounded to 2 decimal places
+ *
+ * @example
+ * ```typescript
+ * calculateDiscount(1000, 10); // 100
+ * calculateDiscount(500, 25); // 125
+ * ```
+ */
+declare function calculateDiscount(amount: number, discountPercent: number): number;
+
+/**
+ * Currency rounding and splitting operations
+ */
 /**
  * Splits a currency amount into equal parts.
  *
@@ -1132,9 +1078,86 @@ declare function addTax(amount: number, taxPercent: number): number;
  * ```
  */
 declare function splitAmount(amount: number, parts: number): number[];
+/**
+ * Rounds up a currency amount to the nearest whole number.
+ *
+ * @param amount - The amount to round up
+ * @returns Rounded up amount
+ *
+ * @example
+ * ```typescript
+ * ceilCurrency(123.01); // 124.00
+ * ceilCurrency(123.99); // 124.00
+ * ceilCurrency(123); // 123.00
+ * ```
+ */
+declare function ceilCurrency(amount: number): number;
+/**
+ * Rounds down a currency amount to the nearest whole number.
+ *
+ * @param amount - The amount to round down
+ * @returns Rounded down amount
+ *
+ * @example
+ * ```typescript
+ * floorCurrency(123.99); // 123.00
+ * floorCurrency(123.01); // 123.00
+ * floorCurrency(123); // 123.00
+ * ```
+ */
+declare function floorCurrency(amount: number): number;
+
+/**
+ * Currency utility functions
+ * Domain-specific utilities using core patterns
+ */
+/**
+ * Safely formats a currency amount with a fallback value.
+ *
+ * @param amount - The amount to format (number or string)
+ * @param options - Formatting options
+ * @param fallback - Value to return if formatting fails (default: '')
+ * @returns Formatted currency string or fallback value
+ */
+declare function safeFormatCurrency(amount: number | string, options?: {
+    includeSymbol?: boolean;
+    includeWord?: boolean;
+}, fallback?: string): string;
+/**
+ * Safely parses a currency string with a fallback value.
+ *
+ * @param currencyString - The currency string to parse
+ * @param fallback - Value to return if parsing fails (default: 0)
+ * @returns Parsed amount or fallback value
+ */
+declare function safeParseCurrency(currencyString: string, fallback?: number): number;
+/**
+ * Formats an array of currency amounts.
+ *
+ * Uses core validating batch processor to eliminate duplication.
+ *
+ * @param amounts - Array of amounts to format
+ * @param options - Formatting options
+ * @returns Array of formatted currency strings (invalid amounts are skipped)
+ *
+ * @example
+ * ```typescript
+ * batchFormatCurrency([100, 200, 300]);
+ * // ['১০০ টাকা', '২০০ টাকা', '৩০০ টাকা']
+ *
+ * batchFormatCurrency([100, NaN, 200], { symbol: true });
+ * // ['৳১০০', '৳২০০']
+ * ```
+ */
+declare function batchFormatCurrency(amounts: number[], options?: {
+    includeSymbol?: boolean;
+    includeWord?: boolean;
+}): string[];
 /**
  * Compares two currency amounts.
  *
+ * Uses core currency comparator to eliminate duplication.
+ *
  * @param amount1 - First amount
  * @param amount2 - Second amount
  * @returns -1 if amount1 < amount2, 0 if equal, 1 if amount1 > amount2
@@ -1188,9 +1211,9 @@ declare function negateAmount(amount: number): number;
  *
  * @example
  * ```typescript
- * parseAndFormatCurrency('1234.56'); // '৳ ১২৩৪.৫৬'
- * parseAndFormatCurrency('  500  ', { includeWord: true }); // '৳ ৫০০.০০ টাকা'
- * parseAndFormatCurrency(100); // '৳ ১০০.০০'
+ * parseAndFormatCurrency('1234.56'); // '১২৩৪.৫৬ টাকা'
+ * parseAndFormatCurrency('  500  ', { symbol: true }); // '৳৫০০'
+ * parseAndFormatCurrency(100); // '১০০ টাকা'
  * parseAndFormatCurrency('invalid'); // throws Error
  * ```
  */
@@ -1198,97 +1221,84 @@ declare function parseAndFormatCurrency(value: any, options?: {
     includeSymbol?: boolean;
     includeWord?: boolean;
 }): string;
-
 /**
- * Formats a Gregorian date with Bangla digits, month names, and weekdays.
- *
- * This function formats a standard JavaScript Date object using Bengali digits,
- * Bengali month names (based on Gregorian calendar), and Bengali weekday names.
+ * Checks if two currency amounts are equal (after rounding).
  *
- * **Note:** This uses a simplified 1:1 mapping where Gregorian month corresponds
- * directly to a Bengali month name (January = বৈশাখ, etc.). For accurate Bengali
- * calendar conversion, use the `calendar` module's `getBengaliDate` function.
- *
- * **Output Formats:**
- * - Long (default): "day month year" or "weekday day month year"
- * - Short: Combines day and month in one part
- *
- * **Weekday Names:**
- * - রবিবার (Robibar) - Sunday
- * - সোমবার (Sombar) - Monday
- * - মঙ্গলবার (Mongolbar) - Tuesday
- * - বুধবার (Budhbar) - Wednesday
- * - বৃহস্পতিবার (Brihaspotibar) - Thursday
- * - শুক্রবার (Shukrobar) - Friday
- * - শনিবার (Shonibar) - Saturday
- *
- * @param date - Date object to format
- * @param options - Formatting options
- * @param options.includeWeekday - Include weekday name (default: false)
- * @param options.includeYear - Include year (default: true)
- * @param options.format - Format style: 'short' or 'long' (default: 'long')
- * @returns Formatted date string in Bangla
+ * @param amount1 - First amount
+ * @param amount2 - Second amount
+ * @returns true if amounts are equal after rounding to 2 decimals
  *
  * @example
- * Basic formatting (with year):
  * ```typescript
- * formatDate(new Date(2024, 0, 15));
- * // "১৫ বৈশাখ ২০২৪"
+ * isCurrencyEqual(100, 100); // true
+ * isCurrencyEqual(100.001, 100.002); // true (both round to 100.00)
+ * isCurrencyEqual(100, 100.01); // false
  * ```
+ */
+declare function isCurrencyEqual(amount1: number, amount2: number): boolean;
+/**
+ * Checks if first amount is greater than second (after rounding).
  *
- * @example
- * Without year:
- * ```typescript
- * formatDate(new Date(2024, 0, 15), { includeYear: false });
- * // "১৫ বৈশাখ"
- * ```
+ * @param amount1 - First amount
+ * @param amount2 - Second amount
+ * @returns true if amount1 > amount2
  *
  * @example
- * With weekday:
  * ```typescript
- * formatDate(new Date(2024, 0, 15), { includeWeekday: true });
- * // "সোমবার ১৫ বৈশাখ ২০২৪" (if Jan 15, 2024 is Monday)
+ * isGreaterThan(200, 100); // true
+ * isGreaterThan(100, 200); // false
+ * isGreaterThan(100, 100); // false
  * ```
+ */
+declare function isGreaterThan(amount1: number, amount2: number): boolean;
+/**
+ * Checks if first amount is less than second (after rounding).
+ *
+ * @param amount1 - First amount
+ * @param amount2 - Second amount
+ * @returns true if amount1 < amount2
  *
  * @example
- * Short format:
  * ```typescript
- * formatDate(new Date(2024, 0, 15), { format: 'short' });
- * // "১৫ বৈশাখ ২০২৪"
+ * isLessThan(100, 200); // true
+ * isLessThan(200, 100); // false
+ * isLessThan(100, 100); // false
  * ```
+ */
+declare function isLessThan(amount1: number, amount2: number): boolean;
+
+/**
+ * Formats a Gregorian date using the Bangla calendar with Bangla digits, month names, and weekdays.
+ *
+ * This function converts a JavaScript Date object to the Bangla calendar and
+ * formats it using Bangla digits, Bangla month names, and Bangla weekday names.
+ *
+ * @param date - Date object to format
+ * @param options - Formatting options
+ * @param options.includeWeekday - Include weekday name (default: false)
+ * @param options.includeYear - Include year (default: true)
+ * @param options.format - Format style: 'short' or 'long' (default: 'long')
+ * @returns Formatted date string in Bangla calendar
  *
  * @example
- * All options combined:
+ * Basic formatting:
  * ```typescript
- * formatDate(
- *   new Date(2024, 0, 15),
- *   { includeWeekday: true, includeYear: false, format: 'short' }
- * );
- * // "সোমবার ১৫ বৈশাখ"
+ * formatDate(new Date(2024, 3, 14));
+ * // "১ বৈশাখ ১৪৩১" (Pohela Boishakh)
  * ```
  *
  * @example
- * Display current date:
+ * Without year:
  * ```typescript
- * const today = formatDate(new Date(), { includeWeekday: true });
- * console.log(`আজ: ${today}`);
- * // "আজ: মঙ্গলবার ৭ পৌষ ২০২৫" (example)
+ * formatDate(new Date(2024, 3, 14), { includeYear: false });
+ * // "১ বৈশাখ"
  * ```
  *
  * @example
- * Event list formatting:
+ * With weekday:
  * ```typescript
- * const events = [
- *   new Date(2024, 3, 14),
- *   new Date(2024, 11, 16),
- *   new Date(2025, 1, 21)
- * ];
- * events.forEach(event => {
- *   console.log(formatDate(event, { includeWeekday: true, includeYear: false }));
- * });
- * // "রবিবার ১৪ শ্রাবণ"
- * // "সোমবার ১৬ চৈত্র"
- * // "শুক্রবার ২১ জ্যৈষ্ঠ"
+ * formatDate(new Date(2024, 3, 14), { includeWeekday: true });
+ * // "রবিবার ১ বৈশাখ ১৪৩১"
  * ```
  */
 declare function formatDate(date: Date, options?: {
@@ -1298,31 +1308,31 @@ declare function formatDate(date: Date, options?: {
 }): string;
 
 /**
- * Parses a Bengali formatted date string into a JavaScript Date object.
+ * Parses a Bangla formatted date string into a JavaScript Date object.
  *
- * This function supports multiple Bengali date formats with both Bengali
+ * This function supports multiple Bangla date formats with both Bangla
  * and English digits. It handles month names and separator-based formats.
  *
  * **Supported Formats:**
  * 1. Month name format: "day month [year]"
- *    - "১৫ বৈশাখ ১৪৩১" (Bengali digits)
+ *    - "১৫ বৈশাখ ১৪৩১" (Bangla digits)
  *    - "15 বৈশাখ 1431" (English digits)
  *    - "১৫ বৈশাখ" (without year, uses current year)
  *
  * 2. Separator format: "day/month/year" or "day-month-year"
- *    - "১৫/০৪/২০২৪" (Bengali digits with slash)
+ *    - "১৫/০৪/২০২৪" (Bangla digits with slash)
  *    - "15-04-2024" (English digits with dash)
- *    - "১৫/০৪/২০২৪" (mixed Bengali/English)
+ *    - "১৫/০৪/২০২৪" (mixed Bangla/English)
  *
- * **Note:** This parses to Gregorian dates with Bengali formatting.
- * For Bengali calendar date parsing, use the `calendar` module's `fromBengali` function.
+ * **Note:** This parses to Gregorian dates with Bangla formatting.
+ * For Bangla calendar date parsing, use the `calendar` module's `fromBangla` function.
  *
- * @param dateString - Bengali formatted date string
+ * @param dateString - Bangla formatted date string
  * @returns JavaScript Date object
  * @throws {Error} If the date string cannot be parsed
  *
  * @example
- * Month name format with Bengali digits:
+ * Month name format with Bangla digits:
  * ```typescript
  * parseDate('১৫ বৈশাখ ১৪৩১');
  * // Date object for the 15th day of month 1 (Boishakh) in year 1431
@@ -1343,7 +1353,7 @@ declare function formatDate(date: Date, options?: {
  * ```
  *
  * @example
- * Separator format with Bengali digits:
+ * Separator format with Bangla digits:
  * ```typescript
  * parseDate('১৫/০৪/২০২৪');
  * // Date object for April 15, 2024
@@ -1447,94 +1457,94 @@ declare function parseDate(dateString: string): Date;
  */
 declare function isValidDate(date: Date): boolean;
 /**
- * Checks if a string is a valid Bengali date format.
+ * Checks if a string is a valid Bangla date format.
  *
  * Valid formats include:
- * - "১৫ বৈশাখ ১৪৩১" (with Bengali digits and month name)
+ * - "১৫ বৈশাখ ১৪৩১" (with Bangla digits and month name)
  * - "১৫ বৈশাখ" (without year)
  * - "15 বৈশাখ 1431" (with English digits and month name)
- * - "১৫/০৪/২০২৪" or "১৫-০৪-২০২৪" (Bengali digits with separators)
+ * - "১৫/০৪/২০২৪" or "১৫-০৪-২০২৪" (Bangla digits with separators)
  * - "15/04/2024" or "15-04-2024" (English digits with separators)
  *
  * @param dateString - String to validate
- * @returns true if string matches a valid Bengali date format, false otherwise
+ * @returns true if string matches a valid Bangla date format, false otherwise
  *
  * @example
  * Valid formats:
  * ```typescript
- * isValidBengaliDateString('১৫ বৈশাখ ১৪৩১'); // true
- * isValidBengaliDateString('১৫ বৈশাখ'); // true
- * isValidBengaliDateString('15 বৈশাখ 1431'); // true
- * isValidBengaliDateString('১৫/০৪/২০২৪'); // true
- * isValidBengaliDateString('15-04-2024'); // true
+ * isValidBanglaDateString('১৫ বৈশাখ ১৪৩১'); // true
+ * isValidBanglaDateString('১৫ বৈশাখ'); // true
+ * isValidBanglaDateString('15 বৈশাখ 1431'); // true
+ * isValidBanglaDateString('১৫/০৪/২০২৪'); // true
+ * isValidBanglaDateString('15-04-2024'); // true
  * ```
  *
  * @example
  * Invalid formats:
  * ```typescript
- * isValidBengaliDateString('invalid'); // false
- * isValidBengaliDateString('2024-01-15'); // false (ISO format not supported)
- * isValidBengaliDateString(''); // false
- * isValidBengaliDateString('   '); // false
+ * isValidBanglaDateString('invalid'); // false
+ * isValidBanglaDateString('2024-01-15'); // false (ISO format not supported)
+ * isValidBanglaDateString(''); // false
+ * isValidBanglaDateString('   '); // false
  * ```
  */
-declare function isValidBengaliDateString(dateString: string): boolean;
+declare function isValidBanglaDateString(dateString: string): boolean;
 /**
- * Checks if a string contains Bengali digits.
+ * Checks if a string contains Bangla digits.
  *
- * Bengali digits: ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯
+ * Bangla digits: ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯
  *
  * @param text - String to check
- * @returns true if string contains at least one Bengali digit, false otherwise
+ * @returns true if string contains at least one Bangla digit, false otherwise
  *
  * @example
- * Strings with Bengali digits:
+ * Strings with Bangla digits:
  * ```typescript
- * hasBengaliDigits('১৫'); // true
- * hasBengaliDigits('১৫ বৈশাখ'); // true
- * hasBengaliDigits('Today is ১৫ বৈশাখ'); // true
- * hasBengaliDigits('১'); // true
+ * hasBanglaDigits('১৫'); // true
+ * hasBanglaDigits('১৫ বৈশাখ'); // true
+ * hasBanglaDigits('Today is ১৫ বৈশাখ'); // true
+ * hasBanglaDigits('১'); // true
  * ```
  *
  * @example
- * Strings without Bengali digits:
+ * Strings without Bangla digits:
  * ```typescript
- * hasBengaliDigits('15'); // false
- * hasBengaliDigits('বৈশাখ'); // false
- * hasBengaliDigits(''); // false
- * hasBengaliDigits('hello'); // false
+ * hasBanglaDigits('15'); // false
+ * hasBanglaDigits('বৈশাখ'); // false
+ * hasBanglaDigits(''); // false
+ * hasBanglaDigits('hello'); // false
  * ```
  */
-declare function hasBengaliDigits(text: string): boolean;
+declare function hasBanglaDigits(text: string): boolean;
 /**
- * Checks if a string contains a Bengali month name.
+ * Checks if a string contains a Bangla month name.
  *
  * Valid month names:
  * বৈশাখ, জ্যৈষ্ঠ, আষাঢ়, শ্রাবণ, ভাদ্র, আশ্বিন,
  * কার্তিক, অগ্রহায়ণ, পৌষ, মাঘ, ফাল্গুন, চৈত্র
  *
  * @param text - String to check
- * @returns true if string contains a Bengali month name, false otherwise
+ * @returns true if string contains a Bangla month name, false otherwise
  *
  * @example
  * Strings with month names:
  * ```typescript
- * hasBengaliMonth('১৫ বৈশাখ ১৪৩১'); // true
- * hasBengaliMonth('বৈশাখ'); // true
- * hasBengaliMonth('Today is বৈশাখ month'); // true
- * hasBengaliMonth('চৈত্র'); // true
+ * hasBanglaMonth('১৫ বৈশাখ ১৪৩১'); // true
+ * hasBanglaMonth('বৈশাখ'); // true
+ * hasBanglaMonth('Today is বৈশাখ month'); // true
+ * hasBanglaMonth('চৈত্র'); // true
  * ```
  *
  * @example
  * Strings without month names:
  * ```typescript
- * hasBengaliMonth('১৫/০৪/২০২৪'); // false
- * hasBengaliMonth('15'); // false
- * hasBengaliMonth('January'); // false
- * hasBengaliMonth(''); // false
+ * hasBanglaMonth('১৫/০৪/২০২৪'); // false
+ * hasBanglaMonth('15'); // false
+ * hasBanglaMonth('January'); // false
+ * hasBanglaMonth(''); // false
  * ```
  */
-declare function hasBengaliMonth(text: string): boolean;
+declare function hasBanglaMonth(text: string): boolean;
 /**
  * Sanitizes a Date object, returning null if invalid.
  *
@@ -1577,369 +1587,384 @@ declare function hasBengaliMonth(text: string): boolean;
 declare function sanitizeDate(date: Date): Date | null;
 
 /**
- * Utility functions for date formatting and parsing operations.
- *
- * This module provides helper functions for working with Bangla date formatting,
- * including safe conversions, date comparisons, and formatting utilities.
- *
- * @module date/utils
+ * Date comparison operations
+ * Uses core comparison utilities
  */
 /**
- * Safely formats a date with fallback value.
+ * Compares two dates and returns -1, 0, or 1.
  *
- * Unlike formatDate, this function doesn't throw on invalid dates.
- * Returns a fallback string for invalid inputs.
+ * Uses core date comparator for consistent comparison logic.
  *
- * @param date - Date object to format
- * @param options - Formatting options
- * @param fallback - Fallback string if formatting fails (default: empty string)
- * @returns Formatted date string or fallback
+ * @param date1 - First date
+ * @param date2 - Second date
+ * @returns -1 if date1 < date2, 0 if equal, 1 if date1 > date2
+ * @throws Error if either date is invalid
  *
  * @example
- * Valid dates:
+ * First date is earlier:
  * ```typescript
- * safeFormatDate(new Date(2024, 0, 15));
- * // "১৫ বৈশাখ ২০২৪" (example - depends on conversion)
+ * compareDates(new Date(2024, 0, 15), new Date(2024, 0, 20));
+ * // -1
  * ```
  *
  * @example
- * Invalid dates with fallback:
+ * Dates are equal:
  * ```typescript
- * safeFormatDate(new Date('invalid'), {}, 'তারিখ নেই');
- * // "তারিখ নেই"
- *
- * safeFormatDate(null as any, {}, 'N/A');
- * // "N/A"
+ * compareDates(new Date(2024, 0, 15), new Date(2024, 0, 15));
+ * // 0
  * ```
  *
  * @example
- * Default fallback:
+ * First date is later:
  * ```typescript
- * safeFormatDate(new Date('invalid'));
- * // ""
+ * compareDates(new Date(2024, 0, 20), new Date(2024, 0, 15));
+ * // 1
  * ```
  */
-declare function safeFormatDate(date: Date, options?: {
-    includeWeekday?: boolean;
-    includeYear?: boolean;
-    format?: 'short' | 'long';
-}, fallback?: string): string;
+declare function compareDates(date1: Date, date2: Date): -1 | 0 | 1;
+
 /**
- * Safely parses a Bengali date string with fallback.
- *
- * Unlike parseDate, this function doesn't throw on invalid strings.
- * Returns a fallback Date for invalid inputs.
+ * Date calculation operations
+ * Functions for date arithmetic and differences
+ */
+/**
+ * Gets the difference in days between two dates.
  *
- * @param dateString - Bengali date string to parse
- * @param fallback - Fallback Date if parsing fails (default: current date)
- * @returns Parsed Date object or fallback
+ * @param date1 - First date
+ * @param date2 - Second date
+ * @returns Number of days between dates (date2 - date1)
+ * @throws Error if either date is invalid
  *
  * @example
- * Valid date strings:
  * ```typescript
- * safeParseDate('১৫ বৈশাখ ১৪৩১');
- * // Date object for the parsed date
+ * const date1 = new Date(2024, 0, 1);
+ * const date2 = new Date(2024, 0, 11);
+ * getDaysDifference(date1, date2);
+ * // 10
  * ```
  *
  * @example
- * Invalid strings with fallback:
+ * Negative difference:
  * ```typescript
- * const fallbackDate = new Date(2024, 0, 1);
- * safeParseDate('invalid', fallbackDate);
- * // Returns fallbackDate
- *
- * safeParseDate('not a date', fallbackDate);
- * // Returns fallbackDate
+ * const date1 = new Date(2024, 0, 11);
+ * const date2 = new Date(2024, 0, 1);
+ * getDaysDifference(date1, date2);
+ * // -10
  * ```
  */
-declare function safeParseDate(dateString: string, fallback?: Date): Date;
+declare function getDaysDifference(date1: Date, date2: Date): number;
 /**
- * Formats today's date in Bangla.
- *
- * Convenience function that formats the current date.
+ * Adds days to a date.
  *
- * @param options - Formatting options
- * @returns Formatted current date string
+ * @param date - Starting date
+ * @param days - Number of days to add (can be negative)
+ * @returns New Date object
+ * @throws Error if date is invalid
  *
  * @example
+ * Adding days:
  * ```typescript
- * formatToday();
- * // "৭ বৈশাখ ২০২৫" (example for current date)
+ * const date = new Date(2024, 0, 1);
+ * addDays(date, 10);
+ * // Date for 2024-01-11
  * ```
  *
  * @example
- * With weekday:
+ * Subtracting days:
  * ```typescript
- * formatToday({ includeWeekday: true });
- * // "মঙ্গলবার ৭ বৈশাখ ২০২৫" (example)
+ * const date = new Date(2024, 0, 11);
+ * addDays(date, -10);
+ * // Date for 2024-01-01
  * ```
+ */
+declare function addDays(date: Date, days: number): Date;
+
+/**
+ * Date range and relative checking operations
+ * Functions for checking if dates are today, past, future, or in ranges
+ */
+/**
+ * Checks if a date is today.
+ *
+ * @param date - Date to check
+ * @returns true if date is today, false otherwise
  *
  * @example
- * Without year:
  * ```typescript
- * formatToday({ includeYear: false });
- * // "৭ বৈশাখ"
+ * isToday(new Date());
+ * // true
+ *
+ * isToday(new Date(2024, 0, 1));
+ * // false (unless today is 2024-01-01)
  * ```
  */
-declare function formatToday(options?: {
-    includeWeekday?: boolean;
-    includeYear?: boolean;
-    format?: 'short' | 'long';
-}): string;
+declare function isToday(date: Date): boolean;
 /**
- * Formats an array of dates in Bangla.
+ * Checks if a date is in the past.
  *
- * @param dates - Array of Date objects
- * @param options - Formatting options
- * @returns Array of formatted date strings
+ * @param date - Date to check
+ * @returns true if date is before now, false otherwise
  *
  * @example
  * ```typescript
- * const dates = [
- *   new Date(2024, 0, 15),
- *   new Date(2024, 1, 20),
- *   new Date(2024, 2, 25)
- * ];
- * batchFormatDates(dates);
- * // ["১৫ বৈশাখ ২০২৪", "২০ জ্যৈষ্ঠ ২০২৪", "২৫ আষাঢ় ২০২৪"] (examples)
- * ```
+ * isPast(new Date(2020, 0, 1));
+ * // true
  *
- * @example
- * Without year:
- * ```typescript
- * batchFormatDates(dates, { includeYear: false });
- * // ["১৫ বৈশাখ", "২০ জ্যৈষ্ঠ", "২৫ আষাঢ়"]
+ * isPast(new Date(2030, 0, 1));
+ * // false
  * ```
  */
-declare function batchFormatDates(dates: Date[], options?: {
-    includeWeekday?: boolean;
-    includeYear?: boolean;
-    format?: 'short' | 'long';
-}): string[];
+declare function isPast(date: Date): boolean;
 /**
- * Parses an array of Bengali date strings.
+ * Checks if a date is in the future.
  *
- * @param dateStrings - Array of Bengali date strings
- * @returns Array of Date objects
+ * @param date - Date to check
+ * @returns true if date is after now, false otherwise
  *
  * @example
  * ```typescript
- * const dateStrings = [
- *   '১৫ বৈশাখ ১৪৩১',
- *   '২০ জ্যৈষ্ঠ ১৪৩১',
- *   '১৫/০৪/২০২৪'
- * ];
- * const dates = batchParseDates(dateStrings);
- * // Array of Date objects
- * ```
+ * isFuture(new Date(2030, 0, 1));
+ * // true
  *
- * @example
- * Handling invalid dates:
- * ```typescript
- * const mixed = ['১৫ বৈশাখ ১৪৩১', 'invalid'];
- * const dates = batchParseDates(mixed);
- * // First element: parsed Date, second element: current Date (fallback)
+ * isFuture(new Date(2020, 0, 1));
+ * // false
  * ```
  */
-declare function batchParseDates(dateStrings: string[]): Date[];
+declare function isFuture(date: Date): boolean;
 /**
- * Checks if a date string can be parsed.
+ * Checks if a date is in a range (inclusive).
  *
- * @param dateString - String to check
- * @returns true if string can be parsed, false otherwise
+ * @param date - Date to check
+ * @param start - Start of range (inclusive)
+ * @param end - End of range (inclusive)
+ * @returns true if date is in range, false otherwise
  *
  * @example
- * Valid strings:
+ * Date within range:
  * ```typescript
- * canParseBengaliDate('১৫ বৈশাখ ১৪৩১'); // true
- * canParseBengaliDate('১৫/০৪/২০২৪'); // true
- * canParseBengaliDate('15 বৈশাখ 1431'); // true
+ * isDateInRange(
+ *   new Date(2024, 0, 15),
+ *   new Date(2024, 0, 10),
+ *   new Date(2024, 0, 20)
+ * );
+ * // true
  * ```
  *
  * @example
- * Invalid strings:
+ * Date on boundary:
  * ```typescript
- * canParseBengaliDate('invalid'); // false
- * canParseBengaliDate('2024-01-15'); // false
- * canParseBengaliDate(''); // false
+ * isDateInRange(
+ *   new Date(2024, 0, 10),
+ *   new Date(2024, 0, 10),
+ *   new Date(2024, 0, 20)
+ * );
+ * // true
+ * ```
+ *
+ * @example
+ * Date outside range:
+ * ```typescript
+ * isDateInRange(
+ *   new Date(2024, 0, 25),
+ *   new Date(2024, 0, 10),
+ *   new Date(2024, 0, 20)
+ * );
+ * // false
  * ```
  */
-declare function canParseBengaliDate(dateString: string): boolean;
+declare function isDateInRange(date: Date, start: Date, end: Date): boolean;
+
 /**
- * Compares two dates.
+ * Date utility functions
+ * Domain-specific utilities using core patterns
+ */
+/**
+ * Safely formats a date with fallback value.
  *
- * @param date1 - First date
- * @param date2 - Second date
- * @returns -1 if date1 < date2, 0 if equal, 1 if date1 > date2
+ * Unlike formatDate, this function doesn't throw on invalid dates.
+ * Returns a fallback string for invalid inputs.
+ *
+ * @param date - Date object to format
+ * @param options - Formatting options
+ * @param fallback - Fallback string if formatting fails (default: empty string)
+ * @returns Formatted date string or fallback
  *
  * @example
- * First date is earlier:
+ * Valid dates:
  * ```typescript
- * compareDates(new Date(2024, 0, 10), new Date(2024, 0, 15));
- * // -1
+ * safeFormatDate(new Date(2024, 0, 15));
+ * // "১৫ বৈশাখ ২০২৪" (example - depends on conversion)
  * ```
  *
  * @example
- * Dates are equal:
+ * Invalid dates with fallback:
  * ```typescript
- * const date = new Date(2024, 0, 15);
- * compareDates(date, new Date(date));
- * // 0
+ * safeFormatDate(new Date('invalid'), {}, 'তারিখ নেই');
+ * // "তারিখ নেই"
+ *
+ * safeFormatDate(null as any, {}, 'N/A');
+ * // "N/A"
  * ```
  *
  * @example
- * First date is later:
+ * Default fallback:
  * ```typescript
- * compareDates(new Date(2024, 0, 20), new Date(2024, 0, 15));
- * // 1
+ * safeFormatDate(new Date('invalid'));
+ * // ""
  * ```
  */
-declare function compareDates(date1: Date, date2: Date): -1 | 0 | 1;
+declare function safeFormatDate(date: Date, options?: {
+    includeWeekday?: boolean;
+    includeYear?: boolean;
+    format?: 'short' | 'long';
+}, fallback?: string): string;
 /**
- * Checks if a date is today.
+ * Safely parses a Bangla date string with fallback.
  *
- * @param date - Date to check
- * @returns true if date is today, false otherwise
+ * Unlike parseDate, this function doesn't throw on invalid strings.
+ * Returns a fallback Date for invalid inputs.
+ *
+ * @param dateString - Bangla date string to parse
+ * @param fallback - Fallback Date if parsing fails (default: current date)
+ * @returns Parsed Date object or fallback
  *
  * @example
+ * Valid date strings:
  * ```typescript
- * isToday(new Date());
- * // true
- *
- * isToday(new Date(2024, 0, 1));
- * // false (unless today is 2024-01-01)
+ * safeParseDate('১৫ বৈশাখ ১৪৩১');
+ * // Date object for the parsed date
  * ```
- */
-declare function isToday(date: Date): boolean;
-/**
- * Checks if a date is in the past.
- *
- * @param date - Date to check
- * @returns true if date is before now, false otherwise
  *
  * @example
+ * Invalid strings with fallback:
  * ```typescript
- * isPast(new Date(2020, 0, 1));
- * // true
+ * const fallbackDate = new Date(2024, 0, 1);
+ * safeParseDate('invalid', fallbackDate);
+ * // Returns fallbackDate
  *
- * isPast(new Date(2030, 0, 1));
- * // false
+ * safeParseDate('not a date', fallbackDate);
+ * // Returns fallbackDate
  * ```
  */
-declare function isPast(date: Date): boolean;
+declare function safeParseDate(dateString: string, fallback?: Date): Date;
 /**
- * Checks if a date is in the future.
+ * Formats today's date in Bangla.
+ *
+ * Convenience function that formats the current date.
+ *
+ * @param options - Formatting options
+ * @returns Formatted current date string
  *
- * @param date - Date to check
- * @returns true if date is after now, false otherwise
+ * @example
+ * ```typescript
+ * formatToday();
+ * // "৭ বৈশাখ ২০২৫" (example for current date)
+ * ```
  *
  * @example
+ * With weekday:
  * ```typescript
- * isFuture(new Date(2030, 0, 1));
- * // true
+ * formatToday({ includeWeekday: true });
+ * // "মঙ্গলবার ৭ বৈশাখ ২০২৫" (example)
+ * ```
  *
- * isFuture(new Date(2020, 0, 1));
- * // false
+ * @example
+ * Without year:
+ * ```typescript
+ * formatToday({ includeYear: false });
+ * // "৭ বৈশাখ"
  * ```
  */
-declare function isFuture(date: Date): boolean;
+declare function formatToday(options?: {
+    includeWeekday?: boolean;
+    includeYear?: boolean;
+    format?: 'short' | 'long';
+}): string;
 /**
- * Gets the difference in days between two dates.
+ * Formats an array of dates in Bangla.
  *
- * @param date1 - First date
- * @param date2 - Second date
- * @returns Number of days between dates (date2 - date1)
+ * @param dates - Array of Date objects
+ * @param options - Formatting options
+ * @returns Array of formatted date strings
  *
  * @example
  * ```typescript
- * const date1 = new Date(2024, 0, 1);
- * const date2 = new Date(2024, 0, 11);
- * getDaysDifference(date1, date2);
- * // 10
+ * const dates = [
+ *   new Date(2024, 0, 15),
+ *   new Date(2024, 1, 20),
+ *   new Date(2024, 2, 25)
+ * ];
+ * batchFormatDates(dates);
+ * // ["১৫ বৈশাখ ২০২৪", "২০ জ্যৈষ্ঠ ২০২৪", "২৫ আষাঢ় ২০২৪"] (examples)
  * ```
  *
  * @example
- * Negative difference:
+ * Without year:
  * ```typescript
- * const date1 = new Date(2024, 0, 11);
- * const date2 = new Date(2024, 0, 1);
- * getDaysDifference(date1, date2);
- * // -10
+ * batchFormatDates(dates, { includeYear: false });
+ * // ["১৫ বৈশাখ", "২০ জ্যৈষ্ঠ", "২৫ আষাঢ়"]
  * ```
  */
-declare function getDaysDifference(date1: Date, date2: Date): number;
+declare function batchFormatDates(dates: Date[], options?: {
+    includeWeekday?: boolean;
+    includeYear?: boolean;
+    format?: 'short' | 'long';
+}): string[];
 /**
- * Adds days to a date.
+ * Parses an array of Bangla date strings.
  *
- * @param date - Starting date
- * @param days - Number of days to add (can be negative)
- * @returns New Date object
+ * @param dateStrings - Array of Bangla date strings
+ * @returns Array of Date objects
  *
  * @example
- * Adding days:
  * ```typescript
- * const date = new Date(2024, 0, 1);
- * addDays(date, 10);
- * // Date for 2024-01-11
+ * const dateStrings = [
+ *   '১৫ বৈশাখ ১৪৩১',
+ *   '২০ জ্যৈষ্ঠ ১৪৩১',
+ *   '১৫/০৪/২০২৪'
+ * ];
+ * const dates = batchParseDates(dateStrings);
+ * // Array of Date objects
  * ```
  *
  * @example
- * Subtracting days:
+ * Handling invalid dates:
  * ```typescript
- * const date = new Date(2024, 0, 11);
- * addDays(date, -10);
- * // Date for 2024-01-01
+ * const mixed = ['১৫ বৈশাখ ১৪৩১', 'invalid'];
+ * const dates = batchParseDates(mixed);
+ * // First element: parsed Date, second element: current Date (fallback)
  * ```
  */
-declare function addDays(date: Date, days: number): Date;
+declare function batchParseDates(dateStrings: string[]): Date[];
 /**
- * Checks if a date is in a range (inclusive).
- *
- * @param date - Date to check
- * @param start - Start of range (inclusive)
- * @param end - End of range (inclusive)
- * @returns true if date is in range, false otherwise
+ * Checks if a date string can be parsed.
  *
- * @example
- * Date within range:
- * ```typescript
- * isDateInRange(
- *   new Date(2024, 0, 15),
- *   new Date(2024, 0, 10),
- *   new Date(2024, 0, 20)
- * );
- * // true
- * ```
+ * @param dateString - String to check
+ * @returns true if string can be parsed, false otherwise
  *
  * @example
- * Date on boundary:
+ * Valid strings:
  * ```typescript
- * isDateInRange(
- *   new Date(2024, 0, 10),
- *   new Date(2024, 0, 10),
- *   new Date(2024, 0, 20)
- * );
- * // true
+ * canParseBanglaDate('১৫ বৈশাখ ১৪৩১'); // true
+ * canParseBanglaDate('১৫/০৪/২০২৪'); // true
+ * canParseBanglaDate('15 বৈশাখ 1431'); // true
  * ```
  *
  * @example
- * Date outside range:
+ * Invalid strings:
  * ```typescript
- * isDateInRange(
- *   new Date(2024, 0, 25),
- *   new Date(2024, 0, 10),
- *   new Date(2024, 0, 20)
- * );
- * // false
+ * canParseBanglaDate('invalid'); // false
+ * canParseBanglaDate('2024-01-15'); // false
+ * canParseBanglaDate(''); // false
  * ```
  */
-declare function isDateInRange(date: Date, start: Date, end: Date): boolean;
+declare function canParseBanglaDate(dateString: string): boolean;
 
 /**
  * Converts a month number (1-12) to Bangla month name.
  *
- * This function maps standard month numbers to Bengali calendar month names.
- * The Bengali calendar has 12 months, each with its traditional name.
+ * This function maps standard month numbers to Bangla calendar month names.
+ * The Bangla calendar has 12 months, each with its traditional name.
  *
  * **Month Mapping:**
  * 1. বৈশাখ (Boishakh)
@@ -2005,7 +2030,7 @@ declare function toBanglaMonth(monthNumber: number): string;
  * Converts a Bangla month name to month number (1-12).
  *
  * This function performs the reverse operation of toBanglaMonth,
- * converting Bengali month names to their numeric equivalents.
+ * converting Bangla month names to their numeric equivalents.
  *
  * **Valid Month Names:**
  * - বৈশাখ → 1
@@ -2072,44 +2097,18 @@ declare function fromBanglaMonth(monthName: string): number;
 /**
  * Gets the Bangla month name from a Date object.
  *
- * This function extracts the month from a JavaScript Date object and
- * converts it to the corresponding Bangla month name. Note that this
- * uses a direct 1:1 mapping (JS month + 1 = Bangla month number).
- *
- * **Note:** This is a simplified mapping. For accurate Bengali calendar
- * conversions, use the calendar module which accounts for Bengali new year
- * and proper date calculations.
+ * This function converts the given date to the Bangla calendar and returns
+ * the corresponding Bangla month name.
  *
  * @param date - Date object
  * @returns Bangla month name
  *
  * @example
- * Getting month name from current date:
- * ```typescript
- * const today = new Date();
- * const monthName = getMonthName(today);
- * console.log(`Current month: ${monthName}`);
- * ```
- *
- * @example
  * Getting month name from specific dates:
  * ```typescript
- * const jan = new Date(2024, 0, 15); // January
- * getMonthName(jan); // 'বৈশাখ'
- *
- * const june = new Date(2024, 5, 15); // June
- * getMonthName(june); // 'আশ্বিন'
- *
- * const dec = new Date(2024, 11, 31); // December
- * getMonthName(dec); // 'চৈত্র'
- * ```
- *
- * @example
- * Practical usage (display):
- * ```typescript
- * const appointment = new Date(2024, 3, 20);
- * const monthName = getMonthName(appointment);
- * console.log(`Appointment in ${monthName}`); // 'Appointment in শ্রাবণ'
+ * getMonthName(new Date(2024, 3, 14)); // 'বৈশাখ' (Pohela Boishakh)
+ * getMonthName(new Date(2024, 0, 15)); // 'পৌষ' (January falls in Poush)
+ * getMonthName(new Date(2024, 6, 15)); // 'শ্রাবণ' (July falls in Srabon)
  * ```
  */
 declare function getMonthName(date: Date): string;
@@ -2867,14 +2866,14 @@ declare function getDaysBetween(from: number, to: number): number;
 /**
  * Gets the Bangla season name from a Date object.
  *
- * This function determines the current Bengali season based on the Bengali month of the given date.
- * It follows the traditional Bengali calendar system which divides the year into six seasons.
+ * This function determines the current Bangla season based on the Bangla month of the given date.
+ * It follows the traditional Bangla calendar system which divides the year into six seasons.
  *
- * **Bengali Seasons (ঋতু):**
+ * **Bangla Seasons (ঋতু) — 2 months per season:**
  * - গ্রীষ্ম (Grisshô - Summer): months 1-2 (বৈশাখ-জ্যৈষ্ঠ)
- * - বর্ষা (Bôrsha - Monsoon): months 3-5 (আষাঢ়-শ্রাবণ-ভাদ্র)
- * - শরৎ (Shôrôt - Autumn): months 6-7 (আশ্বিন-কার্তিক)
- * - হেমন্ত (Hemonto - Late Autumn): month 8 (অগ্রহায়ণ)
+ * - বর্ষা (Bôrsha - Monsoon): months 3-4 (আষাঢ়-শ্রাবণ)
+ * - শরৎ (Shôrôt - Autumn): months 5-6 (ভাদ্র-আশ্বিন)
+ * - হেমন্ত (Hemonto - Late Autumn): months 7-8 (কার্তিক-অগ্রহায়ণ)
  * - শীত (Sheet - Winter): months 9-10 (পৌষ-মাঘ)
  * - বসন্ত (Bôshonto - Spring): months 11-12 (ফাল্গুন-চৈত্র)
  *
@@ -2884,10 +2883,10 @@ declare function getDaysBetween(from: number, to: number): number;
  * @example
  * Basic usage:
  * ```typescript
- * const date1 = new Date('2024-04-15'); // Bengali month 1 (Boishakh)
+ * const date1 = new Date('2024-04-15'); // Bangla month 1 (Boishakh)
  * getSeason(date1); // 'গ্রীষ্ম'
  *
- * const date2 = new Date('2024-07-15'); // Bengali month 4 (Monsoon period)
+ * const date2 = new Date('2024-07-15'); // Bangla month 4 (Monsoon period)
  * getSeason(date2); // 'বর্ষা'
  * ```
  *
@@ -2932,20 +2931,20 @@ declare function getDaysBetween(from: number, to: number): number;
 declare function getSeason(date: Date): string;
 
 /**
- * Gets the Bangla season name from a Bengali month number.
+ * Gets the Bangla season name from a Bangla month number.
  *
- * This function maps Bengali month numbers (1-12) to their corresponding seasons
- * according to the traditional Bengali calendar system.
+ * This function maps Bangla month numbers (1-12) to their corresponding seasons
+ * according to the traditional Bangla calendar system.
  *
- * **Month to Season Mapping:**
+ * **Month to Season Mapping (2 months per season):**
  * - Months 1-2 (বৈশাখ-জ্যৈষ্ঠ) → গ্রীষ্ম (Summer)
- * - Months 3-5 (আষাঢ়-শ্রাবণ-ভাদ্র) → বর্ষা (Monsoon)
- * - Months 6-7 (আশ্বিন-কার্তিক) → শরৎ (Autumn)
- * - Month 8 (অগ্রহায়ণ) → হেমন্ত (Late Autumn)
+ * - Months 3-4 (আষাঢ়-শ্রাবণ) → বর্ষা (Monsoon)
+ * - Months 5-6 (ভাদ্র-আশ্বিন) → শরৎ (Autumn)
+ * - Months 7-8 (কার্তিক-অগ্রহায়ণ) → হেমন্ত (Late Autumn)
  * - Months 9-10 (পৌষ-মাঘ) → শীত (Winter)
  * - Months 11-12 (ফাল্গুন-চৈত্র) → বসন্ত (Spring)
  *
- * @param monthNumber - Bengali month number (1-12)
+ * @param monthNumber - Bangla month number (1-12)
  * @returns Bangla season name
  * @throws {Error} If monthNumber is not between 1 and 12
  *
@@ -2968,13 +2967,13 @@ declare function getSeason(date: Date): string;
  * // Monsoon months
  * getSeasonFromMonth(3); // 'বর্ষা' (Asharh)
  * getSeasonFromMonth(4); // 'বর্ষা' (Shrabon)
- * getSeasonFromMonth(5); // 'বর্ষা' (Bhadro)
  *
  * // Autumn months
+ * getSeasonFromMonth(5); // 'শরৎ' (Bhadro)
  * getSeasonFromMonth(6); // 'শরৎ' (Ashwin)
- * getSeasonFromMonth(7); // 'শরৎ' (Kartik)
  *
- * // Late Autumn
+ * // Late Autumn months
+ * getSeasonFromMonth(7); // 'হেমন্ত' (Kartik)
  * getSeasonFromMonth(8); // 'হেমন্ত' (Ogrohayon)
  *
  * // Winter months
@@ -3100,13 +3099,13 @@ declare function getAllSeasons(): string[];
  * Gets the month numbers for a given season.
  *
  * This function returns an array of month numbers (1-12) that belong to
- * the specified season in the Bengali calendar system.
+ * the specified season in the Bangla calendar system.
  *
- * **Season to Month Mapping:**
+ * **Season to Month Mapping (2 months per season):**
  * - গ্রীষ্ম (Summer): months 1-2 (বৈশাখ-জ্যৈষ্ঠ)
- * - বর্ষা (Monsoon): months 3-5 (আষাঢ়-শ্রাবণ-ভাদ্র)
- * - শরৎ (Autumn): months 6-7 (আশ্বিন-কার্তিক)
- * - হেমন্ত (Late Autumn): month 8 (অগ্রহায়ণ)
+ * - বর্ষা (Monsoon): months 3-4 (আষাঢ়-শ্রাবণ)
+ * - শরৎ (Autumn): months 5-6 (ভাদ্র-আশ্বিন)
+ * - হেমন্ত (Late Autumn): months 7-8 (কার্তিক-অগ্রহায়ণ)
  * - শীত (Winter): months 9-10 (পৌষ-মাঘ)
  * - বসন্ত (Spring): months 11-12 (ফাল্গুন-চৈত্র)
  *
@@ -3117,9 +3116,9 @@ declare function getAllSeasons(): string[];
  * @example
  * ```typescript
  * getSeasonMonths('গ্রীষ্ম'); // [1, 2]
- * getSeasonMonths('বর্ষা'); // [3, 4, 5]
- * getSeasonMonths('শরৎ'); // [6, 7]
- * getSeasonMonths('হেমন্ত'); // [8]
+ * getSeasonMonths('বর্ষা'); // [3, 4]
+ * getSeasonMonths('শরৎ'); // [5, 6]
+ * getSeasonMonths('হেমন্ত'); // [7, 8]
  * getSeasonMonths('শীত'); // [9, 10]
  * getSeasonMonths('বসন্ত'); // [11, 12]
  * ```
@@ -3494,6 +3493,8 @@ declare function safeToOrdinal(number: number, fallback?: string): string;
  * This function processes multiple numbers at once, converting each to
  * its ordinal form. Invalid numbers are skipped.
  *
+ * Uses core validating batch processor to eliminate duplication.
+ *
  * @param numbers - Array of numbers to convert
  * @returns Array of ordinal strings (invalid numbers are skipped)
  *
@@ -3509,7 +3510,7 @@ declare function safeToOrdinal(number: number, fallback?: string): string;
  * // ['দশম', 'বিংশ', 'ত্রিংশ']
  * ```
  */
-declare function batchToOrdinal(numbers: number[]): string[];
+declare const batchToOrdinal: (inputs: number[]) => string[];
 /**
  * Parses and converts input to ordinal in one step.
  *
@@ -3734,10 +3735,12 @@ declare function createOrdinalList<T>(items: T[], startFrom?: number): Array<{
  * It can accept either a Date object or a time string in HH:mm or HH:mm:ss format.
  *
  * **12-Hour Format Periods:**
- * - রাত (night): 12:00 AM - 11:59 PM when hour is 0
- * - সকাল (morning): 1:00 AM - 11:59 AM
- * - দুপুর (noon): 12:00 PM - 12:59 PM
- * - বিকাল (afternoon/evening): 1:00 PM - 11:59 PM
+ * - রাত (night): 12:00 AM - 5:59 AM (hours 0-5)
+ * - সকাল (morning): 6:00 AM - 11:59 AM (hours 6-11)
+ * - দুপুর (noon/afternoon): 12:00 PM - 2:59 PM (hours 12-14)
+ * - বিকাল (late afternoon): 3:00 PM - 5:59 PM (hours 15-17)
+ * - সন্ধ্যা (evening): 6:00 PM - 7:59 PM (hours 18-19)
+ * - রাত (night): 8:00 PM - 11:59 PM (hours 20-23)
  *
  * @param date - Date object or time string (HH:mm or HH:mm:ss format)
  * @param options - Formatting options
@@ -3755,47 +3758,15 @@ declare function createOrdinalList<T>(items: T[], startFrom?: number): Array<{
  * ```
  *
  * @example
- * With seconds:
- * ```typescript
- * formatTime('14:30:45', { includeSeconds: true }); // '১৪:৩০:৪৫'
- * formatTime(new Date('2024-01-07T09:15:30'), { includeSeconds: true }); // '০৯:১৫:৩০'
- * ```
- *
- * @example
  * 12-hour format with Bangla periods:
  * ```typescript
- * formatTime('09:30', { use12Hour: true }); // '০৯:৩০ সকাল'
- * formatTime('14:30', { use12Hour: true }); // '০২:৩০ বিকাল'
- * formatTime('12:00', { use12Hour: true }); // '১২:০০ দুপুর'
- * formatTime('00:00', { use12Hour: true }); // '১২:০০ রাত'
- * ```
- *
- * @example
- * Combining options:
- * ```typescript
- * formatTime('14:30:45', { use12Hour: true, includeSeconds: true }); // '০২:৩০:৪৫ বিকাল'
- * formatTime('09:15:30', { use12Hour: true, includeSeconds: true }); // '০৯:১৫:৩০ সকাল'
- * ```
- *
- * @example
- * Error cases:
- * ```typescript
- * formatTime('invalid'); // throws Error: Invalid time string format
- * formatTime('25:00'); // throws Error: Invalid time string format
- * formatTime('12:70'); // throws Error: Invalid time string format
- * ```
- *
- * @example
- * Real-world usage:
- * ```typescript
- * const event = {
- *   name: 'Team Meeting',
- *   time: new Date('2024-01-07T10:30:00')
- * };
- *
- * const formattedTime = formatTime(event.time, { use12Hour: true });
- * console.log(`${event.name}: ${formattedTime}`);
- * // Output: "Team Meeting: ১০:৩০ সকাল"
+ * formatTime('09:30', { use12Hour: true }); // 'সকাল ০৯:৩০'
+ * formatTime('14:30', { use12Hour: true }); // 'দুপুর ০২:৩০'
+ * formatTime('16:00', { use12Hour: true }); // 'বিকাল ০৪:০০'
+ * formatTime('18:30', { use12Hour: true }); // 'সন্ধ্যা ০৬:৩০'
+ * formatTime('22:00', { use12Hour: true }); // 'রাত ১০:০০'
+ * formatTime('04:30', { use12Hour: true }); // 'রাত ০৪:৩০'
+ * formatTime('00:00', { use12Hour: true }); // 'রাত ১২:০০'
  * ```
  */
 declare function formatTime(date: Date | string, options?: {
@@ -3967,6 +3938,59 @@ declare function relativeTime(date: Date, baseDate?: Date): string;
  */
 declare function relativeDay(date: Date, baseDate?: Date): string;
 
+/**
+ * Time conversion utilities
+ * Functions for parsing and converting time strings
+ */
+/**
+ * Parses a time string and returns hours, minutes, and seconds.
+ *
+ * @param timeString - Time string in HH:mm or HH:mm:ss format
+ * @returns Object with hours, minutes, and seconds
+ * @throws Error if the time string is invalid
+ *
+ * @example
+ * ```typescript
+ * parseTime('14:30'); // { hours: 14, minutes: 30, seconds: 0 }
+ * parseTime('09:15:45'); // { hours: 9, minutes: 15, seconds: 45 }
+ * parseTime('23:59:59'); // { hours: 23, minutes: 59, seconds: 59 }
+ * ```
+ */
+declare function parseTime(timeString: string): {
+    hours: number;
+    minutes: number;
+    seconds: number;
+};
+/**
+ * Converts a time string to total seconds since midnight.
+ *
+ * @param timeString - Time string in HH:mm or HH:mm:ss format
+ * @returns Total seconds since midnight
+ *
+ * @example
+ * ```typescript
+ * timeToSeconds('01:00'); // 3600
+ * timeToSeconds('01:30'); // 5400
+ * timeToSeconds('12:00:00'); // 43200
+ * ```
+ */
+declare function timeToSeconds(timeString: string): number;
+/**
+ * Converts seconds since midnight to a time string.
+ *
+ * @param totalSeconds - Total seconds since midnight
+ * @returns Time string in HH:mm:ss format
+ * @throws Error if seconds is out of valid range
+ *
+ * @example
+ * ```typescript
+ * secondsToTime(3600); // '01:00:00'
+ * secondsToTime(5400); // '01:30:00'
+ * secondsToTime(43200); // '12:00:00'
+ * ```
+ */
+declare function secondsToTime(totalSeconds: number): string;
+
 /**
  * Validates if a string represents a valid time format.
  *
@@ -4014,74 +4038,30 @@ declare function isValidTimeInput(value: any): boolean;
  * @param timeString - The time string to check
  * @returns true if the time string includes seconds, false otherwise
  *
- * @example
- * ```typescript
- * hasSeconds('14:30:45'); // true
- * hasSeconds('14:30'); // false
- * ```
- */
-declare function hasSeconds(timeString: string): boolean;
-/**
- * Sanitizes time string input by trimming whitespace.
- *
- * @param input - The time string to sanitize
- * @returns Sanitized time string
- *
- * @example
- * ```typescript
- * sanitizeTimeInput('  14:30  '); // '14:30'
- * sanitizeTimeInput('09:15:45  '); // '09:15:45'
- * ```
- */
-declare function sanitizeTimeInput(input: string): string;
-
-/**
- * Parses a time string and returns hours, minutes, and seconds.
- *
- * @param timeString - Time string in HH:mm or HH:mm:ss format
- * @returns Object with hours, minutes, and seconds
- * @throws Error if the time string is invalid
- *
- * @example
- * ```typescript
- * parseTime('14:30'); // { hours: 14, minutes: 30, seconds: 0 }
- * parseTime('09:15:45'); // { hours: 9, minutes: 15, seconds: 45 }
- * parseTime('23:59:59'); // { hours: 23, minutes: 59, seconds: 59 }
- * ```
- */
-declare function parseTime(timeString: string): {
-    hours: number;
-    minutes: number;
-    seconds: number;
-};
-/**
- * Converts a time string to total seconds since midnight.
- *
- * @param timeString - Time string in HH:mm or HH:mm:ss format
- * @returns Total seconds since midnight
- *
- * @example
- * ```typescript
- * timeToSeconds('01:00'); // 3600
- * timeToSeconds('01:30'); // 5400
- * timeToSeconds('12:00:00'); // 43200
+ * @example
+ * ```typescript
+ * hasSeconds('14:30:45'); // true
+ * hasSeconds('14:30'); // false
  * ```
  */
-declare function timeToSeconds(timeString: string): number;
+declare function hasSeconds(timeString: string): boolean;
 /**
- * Converts seconds since midnight to a time string.
+ * Sanitizes time string input by trimming whitespace.
  *
- * @param totalSeconds - Total seconds since midnight
- * @returns Time string in HH:mm:ss format
+ * @param input - The time string to sanitize
+ * @returns Sanitized time string
  *
  * @example
  * ```typescript
- * secondsToTime(3600); // '01:00:00'
- * secondsToTime(5400); // '01:30:00'
- * secondsToTime(43200); // '12:00:00'
+ * sanitizeTimeInput('  14:30  '); // '14:30'
+ * sanitizeTimeInput('09:15:45  '); // '09:15:45'
  * ```
  */
-declare function secondsToTime(totalSeconds: number): string;
+declare function sanitizeTimeInput(input: string): string;
+
+/**
+ * Time comparison operations
+ */
 /**
  * Compares two time strings and returns -1, 0, or 1.
  *
@@ -4098,21 +4078,28 @@ declare function secondsToTime(totalSeconds: number): string;
  */
 declare function compareTimes(time1: string, time2: string): number;
 /**
- * Checks if a time string falls within a given time range.
+ * Checks if two dates are on the same day.
  *
- * @param time - Time to check
- * @param startTime - Start of range (inclusive)
- * @param endTime - End of range (inclusive)
- * @returns true if time is within range, false otherwise
+ * @param date1 - First date
+ * @param date2 - Second date
+ * @returns true if dates are on the same day, false otherwise
  *
  * @example
  * ```typescript
- * isTimeInRange('10:00', '09:00', '11:00'); // true
- * isTimeInRange('08:00', '09:00', '11:00'); // false
- * isTimeInRange('09:00', '09:00', '11:00'); // true (inclusive)
+ * const date1 = new Date(2024, 0, 15, 10, 30);
+ * const date2 = new Date(2024, 0, 15, 14, 45);
+ * isSameDay(date1, date2); // true
+ *
+ * const date3 = new Date(2024, 0, 16, 10, 30);
+ * isSameDay(date1, date3); // false
  * ```
  */
-declare function isTimeInRange(time: string, startTime: string, endTime: string): boolean;
+declare function isSameDay(date1: Date, date2: Date): boolean;
+
+/**
+ * Time calculation operations
+ * Functions for time arithmetic and differences
+ */
 /**
  * Adds a duration (in minutes) to a time string.
  *
@@ -4143,6 +4130,31 @@ declare function addMinutesToTime(timeString: string, minutes: number): string;
  * ```
  */
 declare function timeDifferenceMinutes(time1: string, time2: string): number;
+
+/**
+ * Time range checking operations
+ */
+/**
+ * Checks if a time string falls within a given time range.
+ *
+ * @param time - Time to check
+ * @param startTime - Start of range (inclusive)
+ * @param endTime - End of range (inclusive)
+ * @returns true if time is within range, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isTimeInRange('10:00', '09:00', '11:00'); // true
+ * isTimeInRange('08:00', '09:00', '11:00'); // false
+ * isTimeInRange('09:00', '09:00', '11:00'); // true (inclusive)
+ * ```
+ */
+declare function isTimeInRange(time: string, startTime: string, endTime: string): boolean;
+
+/**
+ * Time utility functions
+ * Domain-specific utilities
+ */
 /**
  * Safely formats time with a fallback value.
  *
@@ -4217,33 +4229,112 @@ declare function getCurrentTimeBangla(options?: {
     includeSeconds?: boolean;
     use12Hour?: boolean;
 }): string;
+
 /**
- * Checks if two dates are on the same day.
+ * Formats a Gregorian date as a Bangla calendar date string with Bangla text.
  *
- * @param date1 - First date
- * @param date2 - Second date
- * @returns true if both dates are on the same calendar day
+ * This function converts a Gregorian date to the Bangla calendar and formats it
+ * with Bangla digits and month names. It's ideal for displaying dates in
+ * Bangla cultural contexts.
+ *
+ * **Output Format:**
+ * - Default: "day month year" (e.g., "১৫ বৈশাখ ১৪৩১")
+ * - With weekday: "weekday day month year" (e.g., "রবিবার ১৫ বৈশাখ ১৪৩১")
+ * - Without year: "day month" (e.g., "১৫ বৈশাখ")
+ *
+ * **Weekday Names:**
+ * - রবিবার (Robibar) - Sunday
+ * - সোমবার (Sombar) - Monday
+ * - মঙ্গলবার (Mongolbar) - Tuesday
+ * - বুধবার (Budhbar) - Wednesday
+ * - বৃহস্পতিবার (Brihaspotibar) - Thursday
+ * - শুক্রবার (Shukrobar) - Friday
+ * - শনিবার (Shonibar) - Saturday
+ *
+ * @param date - Gregorian Date object to format
+ * @param options - Formatting options
+ * @param options.includeYear - Include Bangla year in output (default: true)
+ * @param options.includeWeekday - Include weekday name in output (default: false)
+ * @returns Formatted Bangla date string
  *
  * @example
+ * Basic formatting (with year):
  * ```typescript
- * const date1 = new Date('2024-01-07T10:00:00');
- * const date2 = new Date('2024-01-07T15:00:00');
- * isSameDay(date1, date2); // true
+ * getBanglaDate(new Date(2024, 3, 14));
+ * // "১ বৈশাখ ১৪৩১" (Pohela Boishakh 1431)
+ * ```
  *
- * const date3 = new Date('2024-01-08T10:00:00');
- * isSameDay(date1, date3); // false
+ * @example
+ * Without year:
+ * ```typescript
+ * getBanglaDate(new Date(2024, 3, 14), { includeYear: false });
+ * // "১ বৈশাখ"
+ * ```
+ *
+ * @example
+ * With weekday:
+ * ```typescript
+ * getBanglaDate(new Date(2024, 3, 14), { includeWeekday: true });
+ * // "রবিবার ১ বৈশাখ ১৪৩১" (if April 14, 2024 is Sunday)
+ * ```
+ *
+ * @example
+ * With weekday, without year:
+ * ```typescript
+ * getBanglaDate(
+ *   new Date(2024, 3, 14),
+ *   { includeWeekday: true, includeYear: false }
+ * );
+ * // "রবিবার ১ বৈশাখ"
+ * ```
+ *
+ * @example
+ * Display current date in Bangla:
+ * ```typescript
+ * const today = new Date();
+ * const bengaliToday = getBanglaDate(today, { includeWeekday: true });
+ * console.log(`আজ: ${bengaliToday}`);
+ * // "আজ: মঙ্গলবার ২৪ পৌষ ১৪৩১" (example)
+ * ```
+ *
+ * @example
+ * Birthday display:
+ * ```typescript
+ * const birthday = new Date(2024, 6, 15);
+ * const bengaliBirthday = getBanglaDate(birthday);
+ * console.log(`জন্মদিন: ${bengaliBirthday}`);
+ * // "জন্মদিন: ১ শ্রাবণ ১৪৩১" (example)
+ * ```
+ *
+ * @example
+ * Event calendar:
+ * ```typescript
+ * const events = [
+ *   new Date(2024, 3, 14),
+ *   new Date(2024, 11, 16),
+ *   new Date(2025, 1, 21)
+ * ];
+ * events.forEach(event => {
+ *   console.log(getBanglaDate(event, { includeWeekday: true }));
+ * });
+ * // "রবিবার ১ বৈশাখ ১৪৩১"
+ * // "সোমবার ২ পৌষ ১৪৩১"
+ * // "শুক্রবার ৯ ফাল্গুন ১৪৩১"
  * ```
  */
-declare function isSameDay(date1: Date, date2: Date): boolean;
+declare function getBanglaDate(date: Date, options?: {
+    includeYear?: boolean;
+    includeWeekday?: boolean;
+}): string;
 
 /**
- * Converts a Gregorian date to Bengali calendar date.
+ * Converts a Gregorian date to Bangla calendar date.
  *
  * This function performs accurate conversion from the Gregorian calendar
- * to the Bengali calendar (also known as Bangla calendar or Bengali calendar).
- * The Bengali calendar year is typically 593-594 years behind the Gregorian calendar.
+ * to the Bangla calendar (also known as Bangla calendar or Bangla calendar).
+ * The Bangla calendar year is typically 593-594 years behind the Gregorian calendar.
  *
- * **Bengali Calendar System:**
+ * **Bangla Calendar System:**
  * - New Year (Pohela Boishakh): April 14 (Gregorian)
  * - 12 months with varying lengths (31, 30, or 29/30 days)
  * - Leap year adjustment in Falgun (month 11)
@@ -4263,29 +4354,29 @@ declare function isSameDay(date1: Date, date2: Date): boolean;
  * 12. চৈত্র (Chaitra) - 30 days
  *
  * @param date - Gregorian Date object to convert
- * @returns Bengali date object with year, month (1-12), and day properties
+ * @returns Bangla date object with year, month (1-12), and day properties
  *
  * @example
- * Bengali New Year (Pohela Boishakh):
+ * Bangla New Year (Pohela Boishakh):
  * ```typescript
- * toBengali(new Date(2024, 3, 14)); // April 14, 2024
+ * toBangla(new Date(2024, 3, 14)); // April 14, 2024
  * // { year: 1431, month: 1, day: 1 }
  * ```
  *
  * @example
  * Mid-year dates:
  * ```typescript
- * toBengali(new Date(2024, 6, 15)); // July 15, 2024
+ * toBangla(new Date(2024, 6, 15)); // July 15, 2024
  * // { year: 1431, month: 4, day: 1 } (approx - Srabon)
  *
- * toBengali(new Date(2024, 11, 31)); // December 31, 2024
+ * toBangla(new Date(2024, 11, 31)); // December 31, 2024
  * // { year: 1431, month: 9, day: 17 } (approx - Poush)
  * ```
  *
  * @example
- * Before Bengali New Year (same Gregorian year):
+ * Before Bangla New Year (same Gregorian year):
  * ```typescript
- * toBengali(new Date(2024, 0, 15)); // January 15, 2024
+ * toBangla(new Date(2024, 0, 15)); // January 15, 2024
  * // { year: 1430, month: 10, day: 2 } (approx - Magh)
  * ```
  *
@@ -4293,7 +4384,7 @@ declare function isSameDay(date1: Date, date2: Date): boolean;
  * Practical usage:
  * ```typescript
  * const today = new Date();
- * const bengaliDate = toBengali(today);
+ * const bengaliDate = toBangla(today);
  * console.log(`${bengaliDate.day}/${bengaliDate.month}/${bengaliDate.year}`);
  * // "24/9/1431" (example)
  * ```
@@ -4302,57 +4393,57 @@ declare function isSameDay(date1: Date, date2: Date): boolean;
  * Leap year handling:
  * ```typescript
  * // 2020 is a leap year, affecting Falgun (month 11)
- * toBengali(new Date(2021, 2, 14)); // March 14, 2021
- * // Month 11 (Falgun) will have 30 days in Bengali year 1427
+ * toBangla(new Date(2021, 2, 14)); // March 14, 2021
+ * // Month 11 (Falgun) will have 30 days in Bangla year 1427
  * ```
  */
-declare function toBengali(date: Date): {
+declare function toBanglaCalendar(date: Date): {
     year: number;
     month: number;
     day: number;
 };
 
 /**
- * Converts a Bengali calendar date to Gregorian date.
+ * Converts a Bangla calendar date to Gregorian date.
  *
- * This function performs the reverse operation of toBengali, converting
- * from the Bengali calendar to the Gregorian calendar. It accurately
+ * This function performs the reverse operation of toBangla, converting
+ * from the Bangla calendar to the Gregorian calendar. It accurately
  * handles month boundaries, year transitions, and leap years.
  *
  * **Input Format:**
- * - year: Bengali year (positive integer)
- * - month: Bengali month (1-12)
+ * - year: Bangla year (positive integer)
+ * - month: Bangla month (1-12)
  * - day: Day of month (1-31, depending on month)
  *
- * **Bengali to Gregorian Mapping:**
- * - Bengali year + 593 or 594 = Gregorian year (depends on date)
- * - 1 Boishakh (Bengali New Year) = April 14 (Gregorian)
+ * **Bangla to Gregorian Mapping:**
+ * - Bangla year + 593 or 594 = Gregorian year (depends on date)
+ * - 1 Boishakh (Bangla New Year) = April 14 (Gregorian)
  *
- * @param bengaliDate - Bengali date object with year, month, and day properties
+ * @param bengaliDate - Bangla date object with year, month, and day properties
  * @returns Gregorian Date object
- * @throws {Error} If the Bengali date is invalid
+ * @throws {Error} If the Bangla date is invalid
  *
  * @example
- * Bengali New Year to Gregorian:
+ * Bangla New Year to Gregorian:
  * ```typescript
- * fromBengali({ year: 1431, month: 1, day: 1 });
+ * fromBangla({ year: 1431, month: 1, day: 1 });
  * // Date object for April 14, 2024 (Pohela Boishakh)
  * ```
  *
  * @example
  * Mid-year conversions:
  * ```typescript
- * fromBengali({ year: 1431, month: 6, day: 15 });
+ * fromBangla({ year: 1431, month: 6, day: 15 });
  * // Date object for October 1, 2024 (approx - Ashwin)
  *
- * fromBengali({ year: 1431, month: 9, day: 1 });
+ * fromBangla({ year: 1431, month: 9, day: 1 });
  * // Date object for December 16, 2024 (approx - Poush)
  * ```
  *
  * @example
  * End of year:
  * ```typescript
- * fromBengali({ year: 1431, month: 12, day: 30 });
+ * fromBangla({ year: 1431, month: 12, day: 30 });
  * // Date object for April 13, 2025 (last day before new year)
  * ```
  *
@@ -4360,7 +4451,7 @@ declare function toBengali(date: Date): {
  * Practical usage (event scheduling):
  * ```typescript
  * const bengaliEvent = { year: 1431, month: 1, day: 1 };
- * const gregorianDate = fromBengali(bengaliEvent);
+ * const gregorianDate = fromBangla(bengaliEvent);
  * console.log(`Event date: ${gregorianDate.toLocaleDateString()}`);
  * // "Event date: 4/14/2024"
  * ```
@@ -4369,7 +4460,7 @@ declare function toBengali(date: Date): {
  * Leap year handling:
  * ```typescript
  * // Falgun 30 in a leap year
- * fromBengali({ year: 1427, month: 11, day: 30 });
+ * fromBangla({ year: 1427, month: 11, day: 30 });
  * // Valid conversion (2020 is a leap year)
  *
  * // Falgun 30 in a non-leap year would be invalid
@@ -4380,291 +4471,194 @@ declare function toBengali(date: Date): {
  * Round-trip conversion:
  * ```typescript
  * const original = new Date(2024, 6, 15);
- * const bengali = toBengali(original);
- * const converted = fromBengali(bengali);
+ * const bengali = toBangla(original);
+ * const converted = fromBangla(bengali);
  * // converted should equal original date
  * ```
  */
-declare function fromBengali(b: {
+declare function fromBanglaCalendar(b: {
     year: number;
     month: number;
     day: number;
 }): Date;
 
 /**
- * Formats a Gregorian date as a Bengali calendar date string with Bengali text.
- *
- * This function converts a Gregorian date to the Bengali calendar and formats it
- * with Bengali digits and month names. It's ideal for displaying dates in
- * Bengali cultural contexts.
- *
- * **Output Format:**
- * - Default: "day month year" (e.g., "১৫ বৈশাখ ১৪৩১")
- * - With weekday: "weekday day month year" (e.g., "রবিবার ১৫ বৈশাখ ১৪৩১")
- * - Without year: "day month" (e.g., "১৫ বৈশাখ")
- *
- * **Weekday Names:**
- * - রবিবার (Robibar) - Sunday
- * - সোমবার (Sombar) - Monday
- * - মঙ্গলবার (Mongolbar) - Tuesday
- * - বুধবার (Budhbar) - Wednesday
- * - বৃহস্পতিবার (Brihaspotibar) - Thursday
- * - শুক্রবার (Shukrobar) - Friday
- * - শনিবার (Shonibar) - Saturday
- *
- * @param date - Gregorian Date object to format
- * @param options - Formatting options
- * @param options.includeYear - Include Bengali year in output (default: true)
- * @param options.includeWeekday - Include weekday name in output (default: false)
- * @returns Formatted Bengali date string
- *
- * @example
- * Basic formatting (with year):
- * ```typescript
- * getBengaliDate(new Date(2024, 3, 14));
- * // "১ বৈশাখ ১৪৩১" (Pohela Boishakh 1431)
- * ```
- *
- * @example
- * Without year:
- * ```typescript
- * getBengaliDate(new Date(2024, 3, 14), { includeYear: false });
- * // "১ বৈশাখ"
- * ```
- *
- * @example
- * With weekday:
- * ```typescript
- * getBengaliDate(new Date(2024, 3, 14), { includeWeekday: true });
- * // "রবিবার ১ বৈশাখ ১৪৩১" (if April 14, 2024 is Sunday)
- * ```
- *
- * @example
- * With weekday, without year:
- * ```typescript
- * getBengaliDate(
- *   new Date(2024, 3, 14),
- *   { includeWeekday: true, includeYear: false }
- * );
- * // "রবিবার ১ বৈশাখ"
- * ```
- *
- * @example
- * Display current date in Bengali:
- * ```typescript
- * const today = new Date();
- * const bengaliToday = getBengaliDate(today, { includeWeekday: true });
- * console.log(`আজ: ${bengaliToday}`);
- * // "আজ: মঙ্গলবার ২৪ পৌষ ১৪৩১" (example)
- * ```
- *
- * @example
- * Birthday display:
- * ```typescript
- * const birthday = new Date(2024, 6, 15);
- * const bengaliBirthday = getBengaliDate(birthday);
- * console.log(`জন্মদিন: ${bengaliBirthday}`);
- * // "জন্মদিন: ১ শ্রাবণ ১৪৩১" (example)
- * ```
- *
- * @example
- * Event calendar:
- * ```typescript
- * const events = [
- *   new Date(2024, 3, 14),
- *   new Date(2024, 11, 16),
- *   new Date(2025, 1, 21)
- * ];
- * events.forEach(event => {
- *   console.log(getBengaliDate(event, { includeWeekday: true }));
- * });
- * // "রবিবার ১ বৈশাখ ১৪৩১"
- * // "সোমবার ২ পৌষ ১৪৩১"
- * // "শুক্রবার ৯ ফাল্গুন ১৪৩১"
- * ```
- */
-declare function getBengaliDate(date: Date, options?: {
-    includeYear?: boolean;
-    includeWeekday?: boolean;
-}): string;
-
-/**
- * Validation utilities for Bengali calendar operations.
+ * Validation utilities for Bangla calendar operations.
  *
- * This module provides non-throwing validation functions for Bengali calendar dates.
+ * This module provides non-throwing validation functions for Bangla calendar dates.
  * All validators return boolean values or null for sanitization functions.
  *
  * @module calendar/validate
  */
 /**
- * Checks if a year is a valid Bengali calendar year.
+ * Checks if a year is a valid Bangla calendar year.
  *
- * Valid Bengali years are positive integers. The Bengali calendar
+ * Valid Bangla years are positive integers. The Bangla calendar
  * is typically 593-594 years behind the Gregorian calendar.
  *
  * @param year - Year to validate
- * @returns true if year is a valid Bengali year, false otherwise
+ * @returns true if year is a valid Bangla year, false otherwise
  *
  * @example
  * Valid years:
  * ```typescript
- * isValidBengaliYear(1431); // true
- * isValidBengaliYear(1400); // true
- * isValidBengaliYear(1); // true
+ * isValidBanglaYear(1431); // true
+ * isValidBanglaYear(1400); // true
+ * isValidBanglaYear(1); // true
  * ```
  *
  * @example
  * Invalid years:
  * ```typescript
- * isValidBengaliYear(0); // false
- * isValidBengaliYear(-10); // false
- * isValidBengaliYear(1431.5); // false
- * isValidBengaliYear('1431' as any); // false
+ * isValidBanglaYear(0); // false
+ * isValidBanglaYear(-10); // false
+ * isValidBanglaYear(1431.5); // false
+ * isValidBanglaYear('1431' as any); // false
  * ```
  */
-declare function isValidBengaliYear(year: number): boolean;
+declare function isValidBanglaYear(year: number): boolean;
 /**
- * Checks if a month is a valid Bengali calendar month (1-12).
+ * Checks if a month number is a valid Bangla calendar month (1-12).
  *
- * Bengali calendar has 12 months:
+ * Bangla calendar has 12 months:
  * 1=বৈশাখ, 2=জ্যৈষ্ঠ, 3=আষাঢ়, 4=শ্রাবণ, 5=ভাদ্র, 6=আশ্বিন,
  * 7=কার্তিক, 8=অগ্রহায়ণ, 9=পৌষ, 10=মাঘ, 11=ফাল্গুন, 12=চৈত্র
  *
- * @param month - Month to validate (1-12)
+ * @param month - Month number to validate (1-12)
  * @returns true if month is valid, false otherwise
  *
  * @example
  * Valid months:
  * ```typescript
- * isValidBengaliMonth(1); // true (Boishakh)
- * isValidBengaliMonth(6); // true (Ashwin)
- * isValidBengaliMonth(12); // true (Chaitra)
+ * isValidBanglaMonthNumber(1); // true (Boishakh)
+ * isValidBanglaMonthNumber(6); // true (Ashwin)
+ * isValidBanglaMonthNumber(12); // true (Chaitra)
  * ```
  *
  * @example
  * Invalid months:
  * ```typescript
- * isValidBengaliMonth(0); // false
- * isValidBengaliMonth(13); // false
- * isValidBengaliMonth(6.5); // false
+ * isValidBanglaMonthNumber(0); // false
+ * isValidBanglaMonthNumber(13); // false
+ * isValidBanglaMonthNumber(6.5); // false
  * ```
  */
-declare function isValidBengaliMonth(month: number): boolean;
+declare function isValidBanglaMonthNumber(month: number): boolean;
 /**
- * Checks if a day is valid for a given Bengali month and year.
+ * Checks if a day is valid for a given Bangla month and year.
  *
- * Bengali calendar month lengths:
+ * Bangla calendar month lengths:
  * - Months 1-5 (বৈশাখ-ভাদ্র): 31 days
  * - Months 6-10 (আশ্বিন-মাঘ): 30 days
  * - Month 11 (ফাল্গুন): 29 or 30 days (depends on Gregorian leap year)
  * - Month 12 (চৈত্র): 30 days
  *
  * @param day - Day to validate
- * @param month - Bengali month (1-12)
- * @param year - Bengali year
+ * @param month - Bangla month (1-12)
+ * @param year - Bangla year
  * @returns true if day is valid for the given month/year, false otherwise
  *
  * @example
  * Valid days:
  * ```typescript
- * isValidBengaliDay(15, 1, 1431); // true (Boishakh has 31 days)
- * isValidBengaliDay(31, 1, 1431); // true (last day of Boishakh)
- * isValidBengaliDay(30, 6, 1431); // true (Ashwin has 30 days)
+ * isValidBanglaDay(15, 1, 1431); // true (Boishakh has 31 days)
+ * isValidBanglaDay(31, 1, 1431); // true (last day of Boishakh)
+ * isValidBanglaDay(30, 6, 1431); // true (Ashwin has 30 days)
  * ```
  *
  * @example
  * Invalid days:
  * ```typescript
- * isValidBengaliDay(32, 1, 1431); // false (Boishakh has only 31 days)
- * isValidBengaliDay(31, 6, 1431); // false (Ashwin has only 30 days)
- * isValidBengaliDay(0, 1, 1431); // false (day must be >= 1)
- * isValidBengaliDay(15.5, 1, 1431); // false (must be integer)
+ * isValidBanglaDay(32, 1, 1431); // false (Boishakh has only 31 days)
+ * isValidBanglaDay(31, 6, 1431); // false (Ashwin has only 30 days)
+ * isValidBanglaDay(0, 1, 1431); // false (day must be >= 1)
+ * isValidBanglaDay(15.5, 1, 1431); // false (must be integer)
  * ```
  *
  * @example
  * Leap year handling:
  * ```typescript
- * // 1427 Bengali corresponds to 2020 Gregorian (leap year)
- * isValidBengaliDay(30, 11, 1427); // true (Falgun has 30 days in leap year)
+ * // 1427 Bangla corresponds to 2020 Gregorian (leap year)
+ * isValidBanglaDay(30, 11, 1427); // true (Falgun has 30 days in leap year)
  *
- * // 1428 Bengali corresponds to 2021 Gregorian (not leap year)
- * isValidBengaliDay(30, 11, 1428); // false (Falgun has only 29 days)
- * isValidBengaliDay(29, 11, 1428); // true
+ * // 1428 Bangla corresponds to 2021 Gregorian (not leap year)
+ * isValidBanglaDay(30, 11, 1428); // false (Falgun has only 29 days)
+ * isValidBanglaDay(29, 11, 1428); // true
  * ```
  */
-declare function isValidBengaliDay(day: number, month: number, year: number): boolean;
+declare function isValidBanglaDay(day: number, month: number, year: number): boolean;
 /**
- * Checks if a Bengali date object is valid.
+ * Checks if a Bangla date object is valid.
  *
- * A valid Bengali date object must have valid year, month, and day properties
+ * A valid Bangla date object must have valid year, month, and day properties
  * that form a valid date combination.
  *
- * @param date - Bengali date object with year, month, day properties
+ * @param date - Bangla date object with year, month, day properties
  * @returns true if the date object is valid, false otherwise
  *
  * @example
  * Valid dates:
  * ```typescript
- * isValidBengaliDate({ year: 1431, month: 1, day: 1 }); // true
- * isValidBengaliDate({ year: 1431, month: 6, day: 15 }); // true
- * isValidBengaliDate({ year: 1431, month: 12, day: 30 }); // true
+ * isValidBanglaDate({ year: 1431, month: 1, day: 1 }); // true
+ * isValidBanglaDate({ year: 1431, month: 6, day: 15 }); // true
+ * isValidBanglaDate({ year: 1431, month: 12, day: 30 }); // true
  * ```
  *
  * @example
  * Invalid dates:
  * ```typescript
- * isValidBengaliDate({ year: 1431, month: 13, day: 1 }); // false (invalid month)
- * isValidBengaliDate({ year: 1431, month: 1, day: 32 }); // false (day > 31)
- * isValidBengaliDate({ year: 0, month: 1, day: 1 }); // false (invalid year)
- * isValidBengaliDate({ year: 1431, month: 6, day: 31 }); // false (Ashwin has only 30 days)
+ * isValidBanglaDate({ year: 1431, month: 13, day: 1 }); // false (invalid month)
+ * isValidBanglaDate({ year: 1431, month: 1, day: 32 }); // false (day > 31)
+ * isValidBanglaDate({ year: 0, month: 1, day: 1 }); // false (invalid year)
+ * isValidBanglaDate({ year: 1431, month: 6, day: 31 }); // false (Ashwin has only 30 days)
  * ```
  *
  * @example
  * Type validation:
  * ```typescript
- * isValidBengaliDate({ year: 1431, month: 1 } as any); // false (missing day)
- * isValidBengaliDate({ year: '1431', month: 1, day: 1 } as any); // false (year not number)
- * isValidBengaliDate(null as any); // false
+ * isValidBanglaDate({ year: 1431, month: 1 } as any); // false (missing day)
+ * isValidBanglaDate({ year: '1431', month: 1, day: 1 } as any); // false (year not number)
+ * isValidBanglaDate(null as any); // false
  * ```
  */
-declare function isValidBengaliDate(date: {
+declare function isValidBanglaDate(date: {
     year: number;
     month: number;
     day: number;
 }): boolean;
 /**
- * Sanitizes a Bengali date object, returning null if invalid.
+ * Sanitizes a Bangla date object, returning null if invalid.
  *
- * This function validates all components of a Bengali date and returns
+ * This function validates all components of a Bangla date and returns
  * the date object if valid, or null if any component is invalid.
  *
- * @param date - Bengali date object to sanitize
+ * @param date - Bangla date object to sanitize
  * @returns The date object if valid, null otherwise
  *
  * @example
  * Valid dates:
  * ```typescript
- * sanitizeBengaliDate({ year: 1431, month: 1, day: 1 });
+ * sanitizeBanglaDate({ year: 1431, month: 1, day: 1 });
  * // { year: 1431, month: 1, day: 1 }
  *
- * sanitizeBengaliDate({ year: 1431, month: 6, day: 15 });
+ * sanitizeBanglaDate({ year: 1431, month: 6, day: 15 });
  * // { year: 1431, month: 6, day: 15 }
  * ```
  *
  * @example
  * Invalid dates:
  * ```typescript
- * sanitizeBengaliDate({ year: 1431, month: 13, day: 1 }); // null
- * sanitizeBengaliDate({ year: 1431, month: 1, day: 32 }); // null
- * sanitizeBengaliDate({ year: 0, month: 1, day: 1 }); // null
- * sanitizeBengaliDate(null as any); // null
+ * sanitizeBanglaDate({ year: 1431, month: 13, day: 1 }); // null
+ * sanitizeBanglaDate({ year: 1431, month: 1, day: 32 }); // null
+ * sanitizeBanglaDate({ year: 0, month: 1, day: 1 }); // null
+ * sanitizeBanglaDate(null as any); // null
  * ```
  *
  * @example
  * Practical usage (form validation):
  * ```typescript
  * const userInput = { year: 1431, month: 1, day: 15 };
- * const validDate = sanitizeBengaliDate(userInput);
+ * const validDate = sanitizeBanglaDate(userInput);
  *
  * if (validDate) {
  *   console.log('Valid date:', validDate);
@@ -4673,7 +4667,7 @@ declare function isValidBengaliDate(date: {
  * }
  * ```
  */
-declare function sanitizeBengaliDate(date: {
+declare function sanitizeBanglaDate(date: {
     year: number;
     month: number;
     day: number;
@@ -4684,48 +4678,48 @@ declare function sanitizeBengaliDate(date: {
 } | null;
 
 /**
- * Utility functions for Bengali calendar operations.
+ * Utility functions for Bangla calendar operations.
  *
- * This module provides helper functions for working with Bengali calendar dates,
+ * This module provides helper functions for working with Bangla calendar dates,
  * including safe conversions, date arithmetic, comparisons, and formatting utilities.
  *
  * @module calendar/utils
  */
 /**
- * Safely converts a Gregorian date to Bengali date with fallback.
+ * Safely converts a Gregorian date to Bangla date with fallback.
  *
- * Unlike toBengali, this function doesn't throw on invalid dates.
+ * Unlike toBangla, this function doesn't throw on invalid dates.
  * Returns a fallback date object for invalid inputs.
  *
  * @param date - Gregorian Date object
  * @param fallback - Fallback value if conversion fails
- * @returns Bengali date object or fallback
+ * @returns Bangla date object or fallback
  *
  * @example
  * Valid dates:
  * ```typescript
- * const bengaliDate = safeToBengali(new Date(2024, 0, 15));
+ * const bengaliDate = safeToBangla(new Date(2024, 0, 15));
  * // { year: 1430, month: 10, day: 2 }
  * ```
  *
  * @example
  * Invalid dates with fallback:
  * ```typescript
- * safeToBengali(new Date('invalid'), { year: 1431, month: 1, day: 1 });
+ * safeToBangla(new Date('invalid'), { year: 1431, month: 1, day: 1 });
  * // { year: 1431, month: 1, day: 1 }
  *
- * safeToBengali(null as any, { year: 1431, month: 1, day: 1 });
+ * safeToBangla(null as any, { year: 1431, month: 1, day: 1 });
  * // { year: 1431, month: 1, day: 1 }
  * ```
  *
  * @example
- * Default fallback (current Bengali date):
+ * Default fallback (current Bangla date):
  * ```typescript
- * safeToBengali(new Date('invalid'));
- * // Returns current Bengali date
+ * safeToBangla(new Date('invalid'));
+ * // Returns current Bangla date
  * ```
  */
-declare function safeToBengali(date: Date, fallback?: {
+declare function safeToBangla(date: Date, fallback?: {
     year: number;
     month: number;
     day: number;
@@ -4735,19 +4729,19 @@ declare function safeToBengali(date: Date, fallback?: {
     day: number;
 };
 /**
- * Safely converts a Bengali date to Gregorian date with fallback.
+ * Safely converts a Bangla date to Gregorian date with fallback.
  *
- * Unlike fromBengali, this function doesn't throw on invalid dates.
+ * Unlike fromBangla, this function doesn't throw on invalid dates.
  * Returns a fallback Date object for invalid inputs.
  *
- * @param bengaliDate - Bengali date object with year, month, day
+ * @param bengaliDate - Bangla date object with year, month, day
  * @param fallback - Fallback Date if conversion fails (default: current date)
  * @returns Gregorian Date object or fallback
  *
  * @example
  * Valid conversions:
  * ```typescript
- * safeFromBengali({ year: 1431, month: 1, day: 1 });
+ * safeFromBangla({ year: 1431, month: 1, day: 1 });
  * // Date object for 2024-04-14
  * ```
  *
@@ -4755,101 +4749,101 @@ declare function safeToBengali(date: Date, fallback?: {
  * Invalid dates with fallback:
  * ```typescript
  * const fallbackDate = new Date(2024, 0, 1);
- * safeFromBengali({ year: 1431, month: 13, day: 1 }, fallbackDate);
+ * safeFromBangla({ year: 1431, month: 13, day: 1 }, fallbackDate);
  * // Returns fallbackDate
  *
- * safeFromBengali({ year: 0, month: 1, day: 1 }, fallbackDate);
+ * safeFromBangla({ year: 0, month: 1, day: 1 }, fallbackDate);
  * // Returns fallbackDate
  * ```
  */
-declare function safeFromBengali(bengaliDate: {
+declare function safeFromBangla(bengaliDate: {
     year: number;
     month: number;
     day: number;
 }, fallback?: Date): Date;
 /**
- * Gets the number of days in a Bengali month.
+ * Gets the number of days in a Bangla month.
  *
- * Bengali calendar month lengths:
+ * Bangla calendar month lengths (Bangladesh Revised Calendar):
  * - Months 1-5: 31 days
  * - Months 6-10: 30 days
- * - Month 11: 29 or 30 days (depends on leap year)
+ * - Month 11: 30 or 31 days (31 in leap year)
  * - Month 12: 30 days
  *
- * @param month - Bengali month (1-12)
- * @param year - Bengali year (for leap year calculation)
+ * @param month - Bangla month (1-12)
+ * @param year - Bangla year (for leap year calculation)
  * @returns Number of days in the month, or 0 if invalid
  *
  * @example
  * First five months (31 days):
  * ```typescript
- * getBengaliMonthDays(1, 1431); // 31 (Boishakh)
- * getBengaliMonthDays(2, 1431); // 31 (Joishtho)
- * getBengaliMonthDays(5, 1431); // 31 (Bhadro)
+ * getBanglaMonthDays(1, 1431); // 31 (Boishakh)
+ * getBanglaMonthDays(2, 1431); // 31 (Joishtho)
+ * getBanglaMonthDays(5, 1431); // 31 (Bhadro)
  * ```
  *
  * @example
  * Months 6-10 and 12 (30 days):
  * ```typescript
- * getBengaliMonthDays(6, 1431); // 30 (Ashwin)
- * getBengaliMonthDays(10, 1431); // 30 (Magh)
- * getBengaliMonthDays(12, 1431); // 30 (Chaitra)
+ * getBanglaMonthDays(6, 1431); // 30 (Ashwin)
+ * getBanglaMonthDays(10, 1431); // 30 (Magh)
+ * getBanglaMonthDays(12, 1431); // 30 (Chaitra)
  * ```
  *
  * @example
  * Falgun (month 11) - leap year handling:
  * ```typescript
- * getBengaliMonthDays(11, 1427); // 30 (2020 is leap year)
- * getBengaliMonthDays(11, 1428); // 29 (2021 is not leap year)
+ * getBanglaMonthDays(11, 1426); // 31 (Falgun 1426 → Feb-Mar 2020, leap year)
+ * getBanglaMonthDays(11, 1427); // 30 (Falgun 1427 → Feb-Mar 2021, not leap year)
  * ```
  *
  * @example
  * Invalid inputs:
  * ```typescript
- * getBengaliMonthDays(0, 1431); // 0
- * getBengaliMonthDays(13, 1431); // 0
+ * getBanglaMonthDays(0, 1431); // 0
+ * getBanglaMonthDays(13, 1431); // 0
  * ```
  */
-declare function getBengaliMonthDays(month: number, year: number): number;
+declare function getBanglaMonthDays(month: number, year: number): number;
 /**
- * Adds days to a Bengali date.
+ * Adds days to a Bangla date.
  *
  * This function properly handles month and year boundaries, including
  * varying month lengths and leap years.
  *
- * @param bengaliDate - Starting Bengali date
+ * @param bengaliDate - Starting Bangla date
  * @param days - Number of days to add (can be negative to subtract)
- * @returns New Bengali date object
+ * @returns New Bangla date object
  *
  * @example
  * Adding days within same month:
  * ```typescript
- * addDaysToBengaliDate({ year: 1431, month: 1, day: 10 }, 5);
+ * addDaysToBanglaDate({ year: 1431, month: 1, day: 10 }, 5);
  * // { year: 1431, month: 1, day: 15 }
  * ```
  *
  * @example
  * Adding days across months:
  * ```typescript
- * addDaysToBengaliDate({ year: 1431, month: 1, day: 30 }, 5);
+ * addDaysToBanglaDate({ year: 1431, month: 1, day: 30 }, 5);
  * // { year: 1431, month: 2, day: 4 } (crosses to Joishtho)
  * ```
  *
  * @example
  * Adding days across years:
  * ```typescript
- * addDaysToBengaliDate({ year: 1431, month: 12, day: 29 }, 5);
+ * addDaysToBanglaDate({ year: 1431, month: 12, day: 29 }, 5);
  * // { year: 1432, month: 1, day: 3 } (crosses to new year)
  * ```
  *
  * @example
  * Subtracting days:
  * ```typescript
- * addDaysToBengaliDate({ year: 1431, month: 2, day: 5 }, -10);
+ * addDaysToBanglaDate({ year: 1431, month: 2, day: 5 }, -10);
  * // { year: 1431, month: 1, day: 26 }
  * ```
  */
-declare function addDaysToBengaliDate(bengaliDate: {
+declare function addDaysToBanglaDate(bengaliDate: {
     year: number;
     month: number;
     day: number;
@@ -4859,18 +4853,18 @@ declare function addDaysToBengaliDate(bengaliDate: {
     day: number;
 };
 /**
- * Calculates the difference in days between two Bengali dates.
+ * Calculates the difference in days between two Bangla dates.
  *
  * The result is positive if the second date is later, negative if earlier.
  *
- * @param date1 - First Bengali date
- * @param date2 - Second Bengali date
+ * @param date1 - First Bangla date
+ * @param date2 - Second Bangla date
  * @returns Number of days between dates (date2 - date1)
  *
  * @example
  * Difference within same month:
  * ```typescript
- * const diff = getBengaliDateDifference(
+ * const diff = getBanglaDateDifference(
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 15 }
  * );
@@ -4880,7 +4874,7 @@ declare function addDaysToBengaliDate(bengaliDate: {
  * @example
  * Difference across months:
  * ```typescript
- * const diff = getBengaliDateDifference(
+ * const diff = getBanglaDateDifference(
  *   { year: 1431, month: 1, day: 1 },
  *   { year: 1431, month: 2, day: 1 }
  * );
@@ -4890,7 +4884,7 @@ declare function addDaysToBengaliDate(bengaliDate: {
  * @example
  * Negative difference (earlier date):
  * ```typescript
- * const diff = getBengaliDateDifference(
+ * const diff = getBanglaDateDifference(
  *   { year: 1431, month: 1, day: 15 },
  *   { year: 1431, month: 1, day: 10 }
  * );
@@ -4900,14 +4894,14 @@ declare function addDaysToBengaliDate(bengaliDate: {
  * @example
  * Across years:
  * ```typescript
- * const diff = getBengaliDateDifference(
+ * const diff = getBanglaDateDifference(
  *   { year: 1431, month: 1, day: 1 },
  *   { year: 1432, month: 1, day: 1 }
  * );
- * // 366 (days in Bengali year 1431)
+ * // 366 (days in Bangla year 1431)
  * ```
  */
-declare function getBengaliDateDifference(date1: {
+declare function getBanglaDateDifference(date1: {
     year: number;
     month: number;
     day: number;
@@ -4917,16 +4911,16 @@ declare function getBengaliDateDifference(date1: {
     day: number;
 }): number;
 /**
- * Compares two Bengali dates.
+ * Compares two Bangla dates.
  *
- * @param date1 - First Bengali date
- * @param date2 - Second Bengali date
+ * @param date1 - First Bangla date
+ * @param date2 - Second Bangla date
  * @returns -1 if date1 < date2, 0 if equal, 1 if date1 > date2
  *
  * @example
  * First date is earlier:
  * ```typescript
- * compareBengaliDates(
+ * compareBanglaDates(
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 15 }
  * ); // -1
@@ -4935,7 +4929,7 @@ declare function getBengaliDateDifference(date1: {
  * @example
  * Dates are equal:
  * ```typescript
- * compareBengaliDates(
+ * compareBanglaDates(
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 10 }
  * ); // 0
@@ -4944,13 +4938,13 @@ declare function getBengaliDateDifference(date1: {
  * @example
  * First date is later:
  * ```typescript
- * compareBengaliDates(
+ * compareBanglaDates(
  *   { year: 1431, month: 2, day: 1 },
  *   { year: 1431, month: 1, day: 31 }
  * ); // 1
  * ```
  */
-declare function compareBengaliDates(date1: {
+declare function compareBanglaDates(date1: {
     year: number;
     month: number;
     day: number;
@@ -4960,9 +4954,9 @@ declare function compareBengaliDates(date1: {
     day: number;
 }): -1 | 0 | 1;
 /**
- * Checks if a Bengali date is in a range (inclusive).
+ * Checks if a Bangla date is in a range (inclusive).
  *
- * @param date - Bengali date to check
+ * @param date - Bangla date to check
  * @param start - Start of range (inclusive)
  * @param end - End of range (inclusive)
  * @returns true if date is in range, false otherwise
@@ -4970,7 +4964,7 @@ declare function compareBengaliDates(date1: {
  * @example
  * Date within range:
  * ```typescript
- * isBengaliDateInRange(
+ * isBanglaDateInRange(
  *   { year: 1431, month: 1, day: 15 },
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 20 }
@@ -4980,7 +4974,7 @@ declare function compareBengaliDates(date1: {
  * @example
  * Date on boundaries:
  * ```typescript
- * isBengaliDateInRange(
+ * isBanglaDateInRange(
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 20 }
@@ -4990,14 +4984,14 @@ declare function compareBengaliDates(date1: {
  * @example
  * Date outside range:
  * ```typescript
- * isBengaliDateInRange(
+ * isBanglaDateInRange(
  *   { year: 1431, month: 2, day: 1 },
  *   { year: 1431, month: 1, day: 10 },
  *   { year: 1431, month: 1, day: 20 }
  * ); // false
  * ```
  */
-declare function isBengaliDateInRange(date: {
+declare function isBanglaDateInRange(date: {
     year: number;
     month: number;
     day: number;
@@ -5011,106 +5005,106 @@ declare function isBengaliDateInRange(date: {
     day: number;
 }): boolean;
 /**
- * Gets the first day of a Bengali month.
+ * Gets the first day of a Bangla month.
  *
- * @param month - Bengali month (1-12)
- * @param year - Bengali year
- * @returns Bengali date object for the first day of the month
+ * @param month - Bangla month (1-12)
+ * @param year - Bangla year
+ * @returns Bangla date object for the first day of the month
  *
  * @example
  * ```typescript
- * getFirstDayOfBengaliMonth(1, 1431);
+ * getFirstDayOfBanglaMonth(1, 1431);
  * // { year: 1431, month: 1, day: 1 }
  *
- * getFirstDayOfBengaliMonth(6, 1431);
+ * getFirstDayOfBanglaMonth(6, 1431);
  * // { year: 1431, month: 6, day: 1 }
  * ```
  */
-declare function getFirstDayOfBengaliMonth(month: number, year: number): {
+declare function getFirstDayOfBanglaMonth(month: number, year: number): {
     year: number;
     month: number;
     day: number;
 };
 /**
- * Gets the last day of a Bengali month.
+ * Gets the last day of a Bangla month.
  *
- * @param month - Bengali month (1-12)
- * @param year - Bengali year
- * @returns Bengali date object for the last day of the month
+ * @param month - Bangla month (1-12)
+ * @param year - Bangla year
+ * @returns Bangla date object for the last day of the month
  *
  * @example
  * Months with 31 days:
  * ```typescript
- * getLastDayOfBengaliMonth(1, 1431);
+ * getLastDayOfBanglaMonth(1, 1431);
  * // { year: 1431, month: 1, day: 31 } (Boishakh)
  * ```
  *
  * @example
  * Months with 30 days:
  * ```typescript
- * getLastDayOfBengaliMonth(6, 1431);
+ * getLastDayOfBanglaMonth(6, 1431);
  * // { year: 1431, month: 6, day: 30 } (Ashwin)
  * ```
  *
  * @example
  * Falgun with leap year:
  * ```typescript
- * getLastDayOfBengaliMonth(11, 1427);
- * // { year: 1427, month: 11, day: 30 } (leap year)
+ * getLastDayOfBanglaMonth(11, 1426);
+ * // { year: 1426, month: 11, day: 31 } (leap year)
  *
- * getLastDayOfBengaliMonth(11, 1428);
- * // { year: 1428, month: 11, day: 29 } (non-leap year)
+ * getLastDayOfBanglaMonth(11, 1427);
+ * // { year: 1427, month: 11, day: 30 } (non-leap year)
  * ```
  */
-declare function getLastDayOfBengaliMonth(month: number, year: number): {
+declare function getLastDayOfBanglaMonth(month: number, year: number): {
     year: number;
     month: number;
     day: number;
 };
 /**
- * Checks if a Bengali year is a leap year.
+ * Checks if a Bangla year is a leap year.
  *
- * Bengali leap years correspond to Gregorian leap years.
- * The Bengali calendar adjusts Falgun (month 11) from 29 to 30 days in leap years.
+ * Bangla leap years correspond to Gregorian leap years.
+ * The Bangla calendar adjusts Falgun (month 11) from 29 to 30 days in leap years.
  *
- * @param year - Bengali year
+ * @param year - Bangla year
  * @returns true if leap year, false otherwise
  *
  * @example
  * Leap years:
  * ```typescript
- * isBengaliLeapYear(1427); // true (corresponds to 2020, a leap year)
- * isBengaliLeapYear(1420); // true (corresponds to 2013... wait, let me recalculate)
+ * isBanglaLeapYear(1427); // true (corresponds to 2020, a leap year)
+ * isBanglaLeapYear(1420); // true (corresponds to 2013... wait, let me recalculate)
  * ```
  *
  * @example
  * Non-leap years:
  * ```typescript
- * isBengaliLeapYear(1428); // false (corresponds to 2021)
- * isBengaliLeapYear(1429); // false (corresponds to 2022)
+ * isBanglaLeapYear(1428); // false (corresponds to 2021)
+ * isBanglaLeapYear(1429); // false (corresponds to 2022)
  * ```
  */
-declare function isBengaliLeapYear(year: number): boolean;
+declare function isBanglaLeapYear(year: number): boolean;
 /**
- * Formats a Bengali date as a string with Bengali digits.
+ * Formats a Bangla date as a string with Bangla digits.
  *
- * This is a convenience wrapper around getBengaliDate.
+ * This is a convenience wrapper around getBanglaDate.
  *
- * @param bengaliDate - Bengali date object
+ * @param bengaliDate - Bangla date object
  * @param options - Formatting options
- * @returns Formatted Bengali date string
+ * @returns Formatted Bangla date string
  *
  * @example
  * Basic formatting:
  * ```typescript
- * formatBengaliDate({ year: 1431, month: 1, day: 15 });
+ * formatBanglaDate({ year: 1431, month: 1, day: 15 });
  * // "১৫ বৈশাখ ১৪৩১"
  * ```
  *
  * @example
  * Without year:
  * ```typescript
- * formatBengaliDate(
+ * formatBanglaDate(
  *   { year: 1431, month: 1, day: 15 },
  *   { includeYear: false }
  * );
@@ -5120,14 +5114,14 @@ declare function isBengaliLeapYear(year: number): boolean;
  * @example
  * With weekday:
  * ```typescript
- * formatBengaliDate(
+ * formatBanglaDate(
  *   { year: 1431, month: 1, day: 1 },
  *   { includeWeekday: true }
  * );
  * // "রবিবার ১ বৈশাখ ১৪৩১" (if 1 Boishakh 1431 is a Sunday)
  * ```
  */
-declare function formatBengaliDate(bengaliDate: {
+declare function formatBanglaDate(bengaliDate: {
     year: number;
     month: number;
     day: number;
@@ -5136,26 +5130,26 @@ declare function formatBengaliDate(bengaliDate: {
     includeWeekday?: boolean;
 }): string;
 /**
- * Gets the current date in Bengali calendar.
+ * Gets the current date in Bangla calendar.
  *
- * @returns Current Bengali date object
+ * @returns Current Bangla date object
  *
  * @example
  * ```typescript
- * const today = getCurrentBengaliDate();
+ * const today = getCurrentBanglaDate();
  * // { year: 1431, month: 9, day: 24 } (example for 2025-01-07)
  * ```
  */
-declare function getCurrentBengaliDate(): {
+declare function getCurrentBanglaDate(): {
     year: number;
     month: number;
     day: number;
 };
 /**
- * Batch converts an array of Gregorian dates to Bengali dates.
+ * Batch converts an array of Gregorian dates to Bangla dates.
  *
  * @param dates - Array of Gregorian Date objects
- * @returns Array of Bengali date objects
+ * @returns Array of Bangla date objects
  *
  * @example
  * ```typescript
@@ -5164,7 +5158,7 @@ declare function getCurrentBengaliDate(): {
  *   new Date(2024, 3, 15),
  *   new Date(2024, 3, 16)
  * ];
- * const bengaliDates = batchToBengali(dates);
+ * const bengaliDates = batchToBangla(dates);
  * // [
  * //   { year: 1431, month: 1, day: 1 },
  * //   { year: 1431, month: 1, day: 2 },
@@ -5172,108 +5166,58 @@ declare function getCurrentBengaliDate(): {
  * // ]
  * ```
  */
-declare function batchToBengali(dates: Date[]): Array<{
+declare function batchToBangla(dates: Date[]): Array<{
     year: number;
     month: number;
     day: number;
 }>;
 /**
- * Gets the month lengths for a given Bengali year.
+ * Gets the month lengths for a given Bangla year.
  */
-declare function getBengaliMonthLengths(bengaliYear: number): number[];
+declare function getBanglaMonthLengths(bengaliYear: number): number[];
 
 /**
  * Formats a Bangladeshi phone number with various formatting options.
  *
- * This function takes a Bangladeshi phone number in any valid format and
- * returns it formatted according to the specified options. It supports
- * different formatting styles, country code inclusion, and Bangla digit conversion.
- *
- * **Format Options:**
- * - `spaced` (default): 017 1234 5678
- * - `dashed`: 017-1234-5678
- * - `compact`: 01712345678
+ * Defaults to Bangla digits with dashed format for a natural Bangla experience.
  *
  * @param phoneNumber - Phone number to format (with or without country code)
  * @param options - Formatting options
  * @param options.includeCountryCode - Add +880 country code (default: false)
- * @param options.useBanglaDigits - Convert digits to Bangla numerals (default: false)
- * @param options.format - Format style: 'spaced', 'dashed', or 'compact' (default: 'spaced')
+ * @param options.useBanglaDigits - Convert digits to Bangla numerals (default: true)
+ * @param options.style - Format style: 'dashed', 'spaced', or 'compact' (default: 'dashed')
  * @returns Formatted phone number
  * @throws {Error} If phone number has invalid length
  *
  * @example
- * Basic formatting (default spaced format):
- * ```typescript
- * formatPhone('01712345678');
- * // '017 1234 5678'
- *
- * formatPhone('+8801712345678');
- * // '017 1234 5678'
- *
- * formatPhone('017 1234 5678');
- * // '017 1234 5678'
- * ```
- *
- * @example
- * Different format styles:
+ * Default (Bangla digits, dashed):
  * ```typescript
- * formatPhone('01712345678', { format: 'dashed' });
- * // '017-1234-5678'
- *
- * formatPhone('01712345678', { format: 'compact' });
- * // '01712345678'
- *
- * formatPhone('01712345678', { format: 'spaced' });
- * // '017 1234 5678'
+ * formatPhone('01712345678');    // '০১৭১-২৩৪৫৬৭৮'
  * ```
  *
  * @example
- * With country code:
+ * Spaced format:
  * ```typescript
- * formatPhone('01712345678', { includeCountryCode: true });
- * // '+880 017 1234 5678'
- *
- * formatPhone('01712345678', {
- *   includeCountryCode: true,
- *   format: 'dashed'
- * });
- * // '+880 017-1234-5678'
+ * formatPhone('01712345678', { style: 'spaced' });  // '০১৭১ ২৩৪ ৫৬৭৮'
  * ```
  *
  * @example
- * With Bangla digits:
+ * Compact with country code:
  * ```typescript
- * formatPhone('01712345678', { useBanglaDigits: true });
- * // '০১৭ ১২৩৪ ৫৬৭৮'
- *
- * formatPhone('01712345678', {
- *   useBanglaDigits: true,
- *   format: 'dashed'
- * });
- * // '০১৭-১২৩৪-৫৬৭৮'
- *
- * formatPhone('01712345678', {
- *   useBanglaDigits: true,
- *   includeCountryCode: true
- * });
- * // '+৮৮০ ০১৭ ১২৩৪ ৫৬৭৮'
+ * formatPhone('01712345678', { style: 'compact', includeCountryCode: true });
+ * // '+৮৮০১৭১২৩৪৫৬৭৮'
  * ```
  *
  * @example
- * All options combined:
+ * English digits:
  * ```typescript
- * formatPhone('8801712345678', {
- *   includeCountryCode: true,
- *   useBanglaDigits: true,
- *   format: 'dashed'
- * });
- * // '+৮৮০ ০১৭-১২৩৪-৫৬৭৮'
+ * formatPhone('01712345678', { useBanglaDigits: false });  // '0171-2345678'
  * ```
  */
 declare function formatPhone(phoneNumber: string, options?: {
     includeCountryCode?: boolean;
     useBanglaDigits?: boolean;
+    style?: 'spaced' | 'dashed' | 'compact';
     format?: 'spaced' | 'dashed' | 'compact';
 }): string;
 
@@ -5427,6 +5371,22 @@ interface ParsedPhoneNumber {
  * ```
  */
 declare function getOperator(phoneNumber: string): OperatorInfo | null;
+/**
+ * Gets the mobile operator name as a string.
+ *
+ * This is a convenience wrapper around getOperator that returns just the name.
+ *
+ * @param phoneNumber - Bangladeshi phone number
+ * @returns Operator name string or null if invalid
+ *
+ * @example
+ * ```typescript
+ * getOperatorName('01712345678'); // 'Grameenphone'
+ * getOperatorName('01812345678'); // 'Robi'
+ * getOperatorName('invalid');     // null
+ * ```
+ */
+declare function getOperatorName(phoneNumber: string): string | null;
 /**
  * Parses a phone number into its components.
  *
@@ -5595,34 +5555,34 @@ declare function parseAndFormat(phoneNumber: string, options?: {
 }): string;
 
 /**
- * Validates if a string contains ONLY Bengali/Bangla characters and whitespace.
+ * Validates if a string contains ONLY Bangla/Bangla characters and whitespace.
  *
  * This function checks if the entire string consists exclusively of characters
- * from the Bengali Unicode range (U+0980 to U+09FF) and whitespace.
- * It returns false if any non-Bengali, non-whitespace character is present.
+ * from the Bangla Unicode range (U+0980 to U+09FF) and whitespace.
+ * It returns false if any non-Bangla, non-whitespace character is present.
  *
  * **Use Cases:**
- * - Form validation (ensuring pure Bengali input)
- * - Content filtering (verifying Bengali-only text)
+ * - Form validation (ensuring pure Bangla input)
+ * - Content filtering (verifying Bangla-only text)
  * - Data validation (checking text purity)
  *
  * **Allowed Characters:**
- * - Bengali consonants, vowels, diacritics
- * - Bengali digits (০-৯)
- * - Bengali punctuation
+ * - Bangla consonants, vowels, diacritics
+ * - Bangla digits (০-৯)
+ * - Bangla punctuation
  * - Whitespace (spaces, tabs, newlines)
  *
  * **Not Allowed:**
  * - English letters (a-z, A-Z)
  * - English digits (0-9)
- * - Special characters not in Bengali range
+ * - Special characters not in Bangla range
  * - Emojis or other Unicode characters
  *
  * @param text - String to validate
- * @returns true if string contains only Bengali characters and whitespace, false otherwise
+ * @returns true if string contains only Bangla characters and whitespace, false otherwise
  *
  * @example
- * Valid pure Bengali text:
+ * Valid pure Bangla text:
  * ```typescript
  * validateBangla('বাংলা'); // true
  * validateBangla('শুভ সকাল'); // true
@@ -5636,7 +5596,7 @@ declare function parseAndFormat(phoneNumber: string, options?: {
  * validateBangla('Hello বাংলা'); // false (contains English)
  * validateBangla('বাংলা 123'); // false (contains English digits)
  * validateBangla('Test'); // false (English only)
- * validateBangla('বাংলা!'); // false (contains non-Bengali punctuation)
+ * validateBangla('বাংলা!'); // false (contains non-Bangla punctuation)
  * ```
  *
  * @example
@@ -5656,23 +5616,23 @@ declare function parseAndFormat(phoneNumber: string, options?: {
  * @example
  * Form validation:
  * ```typescript
- * function validateBengaliName(name: string): boolean {
+ * function validateBanglaName(name: string): boolean {
  *   return validateBangla(name) && name.trim().length > 0;
  * }
  *
- * validateBengaliName('মাহমুদ'); // true
- * validateBengaliName('Mahmud'); // false
+ * validateBanglaName('মাহমুদ'); // true
+ * validateBanglaName('Mahmud'); // false
  * ```
  */
 declare function validateBangla(text: string): boolean;
 
 /**
- * Checks if a character is a Bengali digit.
+ * Checks if a character is a Bangla digit.
  *
- * Bengali digits range from ০ (0) to ৯ (9).
- * This function checks if the input string contains at least one Bengali digit.
+ * Bangla digits range from ০ (0) to ৯ (9).
+ * This function checks if the input string contains at least one Bangla digit.
  *
- * **Bengali Digits:**
+ * **Bangla Digits:**
  * - ০ (shunno) - 0
  * - ১ (ek) - 1
  * - ২ (dui) - 2
@@ -5685,10 +5645,10 @@ declare function validateBangla(text: string): boolean;
  * - ৯ (noy) - 9
  *
  * @param char - Character or string to check
- * @returns true if contains at least one Bengali digit, false otherwise
+ * @returns true if contains at least one Bangla digit, false otherwise
  *
  * @example
- * Single Bengali digits:
+ * Single Bangla digits:
  * ```typescript
  * isBanglaDigit('০'); // true
  * isBanglaDigit('৫'); // true
@@ -5696,7 +5656,7 @@ declare function validateBangla(text: string): boolean;
  * ```
  *
  * @example
- * Multiple Bengali digits:
+ * Multiple Bangla digits:
  * ```typescript
  * isBanglaDigit('১২৩'); // true
  * isBanglaDigit('৪৫৬'); // true
@@ -5728,21 +5688,21 @@ declare function validateBangla(text: string): boolean;
 declare function isBanglaDigit(char: string): boolean;
 
 /**
- * Checks if a string contains Bengali/Bangla characters.
+ * Checks if a string contains Bangla/Bangla characters.
  *
  * This function tests if the input string contains at least one character
- * from the Bengali Unicode range (U+0980 to U+09FF), which includes:
- * - Bengali consonants (ক খ গ ঘ ঙ চ ছ জ ঝ ঞ etc.)
- * - Bengali vowels (অ আ ই ঈ উ ঊ etc.)
- * - Bengali vowel diacritics (া ি ী ু ূ etc.)
- * - Bengali digits (০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯)
- * - Bengali punctuation and symbols
+ * from the Bangla Unicode range (U+0980 to U+09FF), which includes:
+ * - Bangla consonants (ক খ গ ঘ ঙ চ ছ জ ঝ ঞ etc.)
+ * - Bangla vowels (অ আ ই ঈ উ ঊ etc.)
+ * - Bangla vowel diacritics (া ি ী ু ূ etc.)
+ * - Bangla digits (০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯)
+ * - Bangla punctuation and symbols
  *
  * @param text - String to check
- * @returns true if contains at least one Bengali character, false otherwise
+ * @returns true if contains at least one Bangla character, false otherwise
  *
  * @example
- * Pure Bengali text:
+ * Pure Bangla text:
  * ```typescript
  * isBanglaText('বাংলা'); // true
  * isBanglaText('হ্যালো'); // true
@@ -5750,14 +5710,14 @@ declare function isBanglaDigit(char: string): boolean;
  * ```
  *
  * @example
- * Bengali digits:
+ * Bangla digits:
  * ```typescript
  * isBanglaText('১২৩'); // true
  * isBanglaText('৫০০'); // true
  * ```
  *
  * @example
- * Mixed Bengali and English:
+ * Mixed Bangla and English:
  * ```typescript
  * isBanglaText('Hello বাংলা'); // true
  * isBanglaText('Price: ১০০ টাকা'); // true
@@ -5783,63 +5743,63 @@ declare function isBanglaDigit(char: string): boolean;
 declare function isBanglaText(text: string): boolean;
 
 /**
- * General utility functions for Bengali/Bangla text operations.
+ * General utility functions for Bangla/Bangla text operations.
  *
- * This module provides helper functions for working with Bengali text,
- * including counting, detecting, sanitizing, and analyzing Bengali content.
+ * This module provides helper functions for working with Bangla text,
+ * including counting, detecting, sanitizing, and analyzing Bangla content.
  *
  * @module utils/utils
  */
 /**
- * Counts the number of Bengali characters in a string.
+ * Counts the number of Bangla characters in a string.
  *
- * This function counts characters from the Bengali Unicode range (U+0980 to U+09FF),
- * excluding whitespace and non-Bengali characters.
+ * This function counts characters from the Bangla Unicode range (U+0980 to U+09FF),
+ * excluding whitespace and non-Bangla characters.
  *
  * @param text - String to analyze
- * @returns Number of Bengali characters
+ * @returns Number of Bangla characters
  *
  * @example
- * Pure Bengali text:
+ * Pure Bangla text:
  * ```typescript
- * countBengaliCharacters('বাংলা'); // 5
- * countBengaliCharacters('হ্যালো'); // 6
+ * countBanglaCharacters('বাংলা'); // 5
+ * countBanglaCharacters('হ্যালো'); // 6
  * ```
  *
  * @example
  * Mixed content:
  * ```typescript
- * countBengaliCharacters('Hello বাংলা'); // 5
- * countBengaliCharacters('১২৩ টাকা'); // 6
+ * countBanglaCharacters('Hello বাংলা'); // 5
+ * countBanglaCharacters('১২৩ টাকা'); // 6
  * ```
  *
  * @example
  * With whitespace:
  * ```typescript
- * countBengaliCharacters('শুভ সকাল'); // 8 (spaces not counted)
+ * countBanglaCharacters('শুভ সকাল'); // 8 (spaces not counted)
  * ```
  */
-declare function countBengaliCharacters(text: string): number;
+declare function countBanglaCharacters(text: string): number;
 /**
- * Counts the number of Bengali digits in a string.
+ * Counts the number of Bangla digits in a string.
  *
- * Bengali digits: ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯
+ * Bangla digits: ০ ১ ২ ৩ ৪ ৫ ৬ ৭ ৮ ৯
  *
  * @param text - String to analyze
- * @returns Number of Bengali digits
+ * @returns Number of Bangla digits
  *
  * @example
  * ```typescript
- * countBengaliDigits('১২৩'); // 3
- * countBengaliDigits('মূল্য: ১০০ টাকা'); // 3
- * countBengaliDigits('Hello 123'); // 0 (English digits not counted)
+ * countBanglaDigits('১২৩'); // 3
+ * countBanglaDigits('মূল্য: ১০০ টাকা'); // 3
+ * countBanglaDigits('Hello 123'); // 0 (English digits not counted)
  * ```
  */
-declare function countBengaliDigits(text: string): number;
+declare function countBanglaDigits(text: string): number;
 /**
- * Checks if a string contains mixed Bengali and non-Bengali content.
+ * Checks if a string contains mixed Bangla and non-Bangla content.
  *
- * Returns true if the string has both Bengali characters and non-Bengali
+ * Returns true if the string has both Bangla characters and non-Bangla
  * alphanumeric characters.
  *
  * @param text - String to check
@@ -5856,147 +5816,147 @@ declare function countBengaliDigits(text: string): number;
  * @example
  * Pure content:
  * ```typescript
- * isMixedContent('বাংলা'); // false (pure Bengali)
+ * isMixedContent('বাংলা'); // false (pure Bangla)
  * isMixedContent('Hello'); // false (pure English)
- * isMixedContent('১২৩'); // false (Bengali digits only)
+ * isMixedContent('১২৩'); // false (Bangla digits only)
  * ```
  */
 declare function isMixedContent(text: string): boolean;
 /**
- * Extracts only Bengali characters from a string.
+ * Extracts only Bangla characters from a string.
  *
- * Removes all non-Bengali characters, keeping only characters
- * from the Bengali Unicode range (U+0980 to U+09FF).
+ * Removes all non-Bangla characters, keeping only characters
+ * from the Bangla Unicode range (U+0980 to U+09FF).
  *
  * @param text - String to extract from
  * @param preserveWhitespace - Whether to preserve whitespace (default: false)
- * @returns String containing only Bengali characters
+ * @returns String containing only Bangla characters
  *
  * @example
  * Extract from mixed content:
  * ```typescript
- * extractBengaliChars('Hello বাংলা World'); // 'বাংলা'
- * extractBengaliChars('Price: ১০০ taka'); // '১০০'
- * extractBengaliChars('123 বাংলা 456'); // 'বাংলা'
+ * extractBanglaChars('Hello বাংলা World'); // 'বাংলা'
+ * extractBanglaChars('Price: ১০০ taka'); // '১০০'
+ * extractBanglaChars('123 বাংলা 456'); // 'বাংলা'
  * ```
  *
  * @example
  * With whitespace preservation:
  * ```typescript
- * extractBengaliChars('Hello বাংলা ভাষা', true); // 'বাংলা ভাষা'
- * extractBengaliChars('Test ১২৩ টাকা', true); // '১২৩ টাকা'
+ * extractBanglaChars('Hello বাংলা ভাষা', true); // 'বাংলা ভাষা'
+ * extractBanglaChars('Test ১২৩ টাকা', true); // '১২৩ টাকা'
  * ```
  *
  * @example
- * Pure Bengali text:
+ * Pure Bangla text:
  * ```typescript
- * extractBengaliChars('বাংলা'); // 'বাংলা' (unchanged)
+ * extractBanglaChars('বাংলা'); // 'বাংলা' (unchanged)
  * ```
  */
-declare function extractBengaliChars(text: string, preserveWhitespace?: boolean): string;
+declare function extractBanglaChars(text: string, preserveWhitespace?: boolean): string;
 /**
- * Removes all Bengali characters from a string.
+ * Removes all Bangla characters from a string.
  *
- * Keeps only non-Bengali characters, removing everything from
- * the Bengali Unicode range.
+ * Keeps only non-Bangla characters, removing everything from
+ * the Bangla Unicode range.
  *
  * @param text - String to process
- * @returns String with Bengali characters removed
+ * @returns String with Bangla characters removed
  *
  * @example
  * ```typescript
- * removeBengaliChars('Hello বাংলা World'); // 'Hello  World'
- * removeBengaliChars('Price: ১০০ taka'); // 'Price:  taka'
- * removeBengaliChars('১২৩ টাকা'); // ' '
+ * removeBanglaChars('Hello বাংলা World'); // 'Hello  World'
+ * removeBanglaChars('Price: ১০০ taka'); // 'Price:  taka'
+ * removeBanglaChars('১২৩ টাকা'); // ' '
  * ```
  */
-declare function removeBengaliChars(text: string): string;
+declare function removeBanglaChars(text: string): string;
 /**
- * Gets the percentage of Bengali characters in a string.
+ * Gets the percentage of Bangla characters in a string.
  *
  * Calculates what percentage of the total non-whitespace characters
- * are Bengali characters.
+ * are Bangla characters.
  *
  * @param text - String to analyze
- * @returns Percentage (0-100) of Bengali characters
+ * @returns Percentage (0-100) of Bangla characters
  *
  * @example
  * ```typescript
- * getBengaliPercentage('বাংলা'); // 100
- * getBengaliPercentage('Hello'); // 0
- * getBengaliPercentage('Hello বাংলা'); // 50 (5 of 10 chars)
- * getBengaliPercentage(''); // 0
+ * getBanglaPercentage('বাংলা'); // 100
+ * getBanglaPercentage('Hello'); // 0
+ * getBanglaPercentage('Hello বাংলা'); // 50 (5 of 10 chars)
+ * getBanglaPercentage(''); // 0
  * ```
  */
-declare function getBengaliPercentage(text: string): number;
+declare function getBanglaPercentage(text: string): number;
 /**
- * Checks if text is primarily Bengali (more than 50% Bengali characters).
+ * Checks if text is primarily Bangla (more than 50% Bangla characters).
  *
  * @param text - String to check
- * @returns true if more than 50% is Bengali, false otherwise
+ * @returns true if more than 50% is Bangla, false otherwise
  *
  * @example
  * ```typescript
- * isPrimarilyBengali('বাংলা'); // true (100%)
- * isPrimarilyBengali('বাংলা ভাষা hello'); // true (>50%)
- * isPrimarilyBengali('Hello বাংলা world test'); // false (<50%)
- * isPrimarilyBengali('Hello'); // false (0%)
+ * isPrimarilyBangla('বাংলা'); // true (100%)
+ * isPrimarilyBangla('বাংলা ভাষা hello'); // true (>50%)
+ * isPrimarilyBangla('Hello বাংলা world test'); // false (<50%)
+ * isPrimarilyBangla('Hello'); // false (0%)
  * ```
  */
-declare function isPrimarilyBengali(text: string): boolean;
+declare function isPrimarilyBangla(text: string): boolean;
 /**
- * Sanitizes Bengali text by removing non-Bengali characters.
+ * Sanitizes Bangla text by removing non-Bangla characters.
  *
  * If fallback is provided, returns fallback when result would be empty.
  *
  * @param text - Text to sanitize
  * @param preserveWhitespace - Preserve whitespace (default: true)
  * @param fallback - Fallback value if result is empty (default: empty string)
- * @returns Sanitized Bengali text or fallback
+ * @returns Sanitized Bangla text or fallback
  *
  * @example
  * ```typescript
- * sanitizeBengaliText('Hello বাংলা World'); // 'বাংলা'
- * sanitizeBengaliText('Test 123 টাকা'); // 'টাকা'
- * sanitizeBengaliText('বাংলা ভাষা'); // 'বাংলা ভাষা'
+ * sanitizeBanglaText('Hello বাংলা World'); // 'বাংলা'
+ * sanitizeBanglaText('Test 123 টাকা'); // 'টাকা'
+ * sanitizeBanglaText('বাংলা ভাষা'); // 'বাংলা ভাষা'
  * ```
  *
  * @example
  * With fallback:
  * ```typescript
- * sanitizeBengaliText('Hello World', true, 'N/A'); // 'N/A'
- * sanitizeBengaliText('123', false, 'নেই'); // 'নেই'
+ * sanitizeBanglaText('Hello World', true, 'N/A'); // 'N/A'
+ * sanitizeBanglaText('123', false, 'নেই'); // 'নেই'
  * ```
  */
-declare function sanitizeBengaliText(text: string, preserveWhitespace?: boolean, fallback?: string): string;
+declare function sanitizeBanglaText(text: string, preserveWhitespace?: boolean, fallback?: string): string;
 /**
- * Checks if all digits in a string are Bengali digits.
+ * Checks if all digits in a string are Bangla digits.
  *
- * Returns true if string contains digits and all digits are Bengali.
+ * Returns true if string contains digits and all digits are Bangla.
  * Returns false if contains English digits or no digits at all.
  *
  * @param text - String to check
- * @returns true if all digits are Bengali, false otherwise
+ * @returns true if all digits are Bangla, false otherwise
  *
  * @example
- * All Bengali digits:
+ * All Bangla digits:
  * ```typescript
- * hasOnlyBengaliDigits('১২৩'); // true
- * hasOnlyBengaliDigits('মূল্য: ১০০'); // true
- * hasOnlyBengaliDigits('বাংলা'); // false (no digits)
+ * hasOnlyBanglaDigits('১২৩'); // true
+ * hasOnlyBanglaDigits('মূল্য: ১০০'); // true
+ * hasOnlyBanglaDigits('বাংলা'); // false (no digits)
  * ```
  *
  * @example
  * Mixed or English digits:
  * ```typescript
- * hasOnlyBengaliDigits('123'); // false (English digits)
- * hasOnlyBengaliDigits('১২3'); // false (mixed)
- * hasOnlyBengaliDigits('Price: 100'); // false
+ * hasOnlyBanglaDigits('123'); // false (English digits)
+ * hasOnlyBanglaDigits('১২3'); // false (mixed)
+ * hasOnlyBanglaDigits('Price: 100'); // false
  * ```
  */
-declare function hasOnlyBengaliDigits(text: string): boolean;
+declare function hasOnlyBanglaDigits(text: string): boolean;
 /**
- * Normalizes whitespace in Bengali text.
+ * Normalizes whitespace in Bangla text.
  *
  * Replaces multiple consecutive whitespaces with a single space
  * and trims leading/trailing whitespace.
@@ -6013,60 +5973,60 @@ declare function hasOnlyBengaliDigits(text: string): boolean;
  */
 declare function normalizeWhitespace(text: string): string;
 /**
- * Splits text into Bengali and non-Bengali parts.
+ * Splits text into Bangla and non-Bangla parts.
  *
- * Returns an object with separate strings for Bengali and non-Bengali content.
+ * Returns an object with separate strings for Bangla and non-Bangla content.
  *
  * @param text - Text to split
- * @returns Object with bengali and nonBengali strings
+ * @returns Object with bengali and nonBangla strings
  *
  * @example
  * ```typescript
- * splitBengaliContent('Hello বাংলা World');
- * // { bengali: 'বাংলা', nonBengali: 'Hello  World' }
+ * splitBanglaContent('Hello বাংলা World');
+ * // { bengali: 'বাংলা', nonBangla: 'Hello  World' }
  *
- * splitBengaliContent('Price: ১০০ taka');
- * // { bengali: '১০০', nonBengali: 'Price:  taka' }
+ * splitBanglaContent('Price: ১০০ taka');
+ * // { bengali: '১০০', nonBangla: 'Price:  taka' }
  * ```
  */
-declare function splitBengaliContent(text: string): {
+declare function splitBanglaContent(text: string): {
     bengali: string;
-    nonBengali: string;
+    nonBangla: string;
 };
 /**
- * Checks if a string contains any Bengali consonants.
+ * Checks if a string contains any Bangla consonants.
  *
- * Bengali consonants: ক খ গ ঘ ঙ চ ছ জ ঝ ঞ ট ঠ ড ঢ ণ ত থ দ ধ ন প ফ ব ভ ম য র ল শ ষ স হ ড় ঢ় য় ৎ
+ * Bangla consonants: ক খ গ ঘ ঙ চ ছ জ ঝ ঞ ট ঠ ড ঢ ণ ত থ দ ধ ন প ফ ব ভ ম য র ল শ ষ স হ ড় ঢ় য় ৎ
  *
  * @param text - Text to check
- * @returns true if contains Bengali consonants, false otherwise
+ * @returns true if contains Bangla consonants, false otherwise
  *
  * @example
  * ```typescript
- * hasBengaliConsonants('বাংলা'); // true
- * hasBengaliConsonants('আই'); // false (vowels only)
- * hasBengaliConsonants('১২৩'); // false (digits only)
- * hasBengaliConsonants('Hello'); // false
+ * hasBanglaConsonants('বাংলা'); // true
+ * hasBanglaConsonants('আই'); // false (vowels only)
+ * hasBanglaConsonants('১২৩'); // false (digits only)
+ * hasBanglaConsonants('Hello'); // false
  * ```
  */
-declare function hasBengaliConsonants(text: string): boolean;
+declare function hasBanglaConsonants(text: string): boolean;
 /**
- * Checks if a string contains any Bengali vowels (independent or diacritics).
+ * Checks if a string contains any Bangla vowels (independent or diacritics).
  *
- * Bengali vowels: অ আ ই ঈ উ ঊ ঋ ৠ ঌ ৡ এ ঐ ও ঔ
- * Bengali vowel diacritics: া ি ী ু ূ ৃ ৄ ে ৈ ো ৌ
+ * Bangla vowels: অ আ ই ঈ উ ঊ ঋ ৠ ঌ ৡ এ ঐ ও ঔ
+ * Bangla vowel diacritics: া ি ী ু ূ ৃ ৄ ে ৈ ো ৌ
  *
  * @param text - Text to check
- * @returns true if contains Bengali vowels, false otherwise
+ * @returns true if contains Bangla vowels, false otherwise
  *
  * @example
  * ```typescript
- * hasBengaliVowels('আম'); // true
- * hasBengaliVowels('বাংলা'); // true (has vowel diacritics)
- * hasBengaliVowels('ক'); // false (consonant only)
- * hasBengaliVowels('123'); // false
+ * hasBanglaVowels('আম'); // true
+ * hasBanglaVowels('বাংলা'); // true (has vowel diacritics)
+ * hasBanglaVowels('ক'); // false (consonant only)
+ * hasBanglaVowels('123'); // false
  * ```
  */
-declare function hasBengaliVowels(text: string): boolean;
+declare function hasBanglaVowels(text: string): boolean;
 
-export { BANGLA_DIGITS, BANGLA_MONTHS, BANGLA_SEASONS, BANGLA_WEEKDAYS, type BatchConversionResult, ENGLISH_DIGITS, type FormatNumberOptions, type OperatorInfo, type ParsedPhoneNumber, addCountryCode, addDays, addDaysToBengaliDate, addMinutesToTime, addTax, applyDiscount, batchFormatCurrency, batchFormatDates, batchFromBanglaNumber, batchParseDates, batchToBanglaMonth, batchToBanglaNumber, batchToBengali, batchToOrdinal, calculatePercentage, canParseBengaliDate, compareBengaliDates, compareCurrency, compareDates, compareMonths, compareOrdinals, compareTimes, convertToWordsAndDigits, countBengaliCharacters, countBengaliDigits, createOrdinalList, divideCurrency, extractBengaliChars, formatAndConvert, formatBengaliDate, formatCurrency, formatDate, formatNumber, formatOrdinal, formatPhone, formatTime, formatToday, formatWithUnits, fromBanglaMonth, fromBanglaNumber, fromBanglaWeekday, fromBengali, getAbsoluteAmount, getAllBanglaWeekdays, getAllMonths, getAllOperatorCodes, getAllOperators, getAllSeasons, getBengaliDate, getBengaliDateDifference, getBengaliMonthDays, getBengaliMonthLengths, getBengaliPercentage, getCurrentBengaliDate, getCurrentSeason, getCurrentTimeBangla, getDaysBetween, getDaysDifference, getFirstDayOfBengaliMonth, getLastDayOfBengaliMonth, getMonthFromIndex, getMonthIndex, getMonthMapping, getMonthName, getMonthRange, getNextBanglaWeekday, getNextMonth, getNextOrdinal, getNextSeason, getNextWeekday, getOperator, getOrdinalSequence, getOrdinalType, getPreviousBanglaWeekday, getPreviousMonth, getPreviousOrdinal, getPreviousSeason, getPreviousWeekday, getRanking, getSeason, getSeasonByIndex, getSeasonFromMonth, getSeasonIndex, getSeasonInfo, getSeasonMonths, getSpecialOrdinals, getTimePeriod, getWeekdayName, hasBengaliConsonants, hasBengaliDigits, hasBengaliMonth, hasBengaliVowels, hasCountryCode, hasOnlyBengaliDigits, hasSeconds, hasSpecialOrdinal, hasTakaSymbol, hasTakaWord, isBanglaCurrency, isBanglaDigit, isBanglaOrdinal, isBanglaText, isBanglaWeekend, isBengaliDateInRange, isBengaliLeapYear, isCurrencyInRange, isDateInRange, isFuture, isInSpecialOrdinalRange, isMixedContent, isMonthInRange, isMonthInSeason, isNegativeAmount, isNumberInRange, isPast, isPositiveAmount, isPrimarilyBengali, isSameDay, isSameNumber, isSameSeason, isTimeInRange, isToday, isValidBanglaMonth, isValidBanglaNumber, isValidBanglaWeekday, isValidBengaliDate, isValidBengaliDateString, isValidBengaliDay, isValidBengaliMonth, isValidBengaliYear, isValidCurrency, isValidDate, isValidDateForSeason, isValidDateForWeekday, isValidMonth, isValidMonthNumber, isValidNumber, isValidNumberForOrdinal, isValidNumberForWords, isValidOperatorCode, isValidOrdinal, isValidPhoneFormat, isValidSeasonName, isValidTimeInput, isValidTimeString, isValidWeekdayNumber, isWeekend, isZeroAmount, multiplyCurrency, negateAmount, normalizePhoneNumber, normalizeWhitespace, parseAndConvertToBangla, parseAndConvertToMonth, parseAndConvertToOrdinal, parseAndFormat, parseAndFormatCurrency, parseCurrency, parseDate, parsePhoneNumber, parseTime, parseWeekdayInput, relativeDay, relativeTime, removeBengaliChars, removeCountryCode, roundCurrency, safeFormatCurrency, safeFormatDate, safeFormatPhone, safeFormatTime, safeFromBanglaMonth, safeFromBanglaNumber, safeFromBanglaWeekday, safeFromBengali, safeGetSeason, safeGetSeasonFromMonth, safeParseCurrency, safeParseDate, safeRelativeTime, safeToBanglaMonth, safeToBanglaNumber, safeToBanglaWeekday, safeToBengali, safeToOrdinal, sanitizeBanglaMonth, sanitizeBengaliDate, sanitizeBengaliText, sanitizeCurrencyInput, sanitizeDate, sanitizeMonthNumber, sanitizeNumberInput, sanitizeOrdinalInput, sanitizePhoneNumber, sanitizeTimeInput, sanitizeWeekdayInput, secondsToTime, splitAmount, splitBengaliContent, subtractCurrency, sumCurrency, timeDifferenceMinutes, timeToSeconds, toBanglaMonth, toBanglaNumber, toBanglaWeekday, toBengali, toOrdinal, toWords, truncateDecimals, validateBangla, validatePhone };
+export { BANGLA_DIGITS, BANGLA_MONTHS, BANGLA_SEASONS, BANGLA_WEEKDAYS, ENGLISH_DIGITS, OPERATOR_INFO, type OperatorInfo, type ParsedPhoneNumber, VALID_OPERATOR_CODES, addCountryCode, addCurrency, addDays, addDaysToBanglaDate, addMinutesToTime, addTax, applyDiscount, batchFormatCurrency, batchFormatDates, batchFromBanglaNumber, batchParseDates, batchToBangla, batchToBanglaMonth, batchToBanglaNumber, batchToOrdinal, calculateDiscount, calculatePercentage, calculateTax, canParseBanglaDate, ceilCurrency, compareBanglaDates, compareCurrency, compareDates, compareMonths, compareOrdinals, compareTimes, convertToWordsAndDigits, countBanglaCharacters, countBanglaDigits, createOrdinalList, divideCurrency, extractBanglaChars, floorCurrency, formatAndConvert, formatBanglaDate, formatCurrency, formatDate, formatNumber, formatOrdinal, formatPhone, formatTime, formatToday, formatWithUnits, fromBanglaCalendar, fromBanglaMonth, fromBanglaNumber, fromBanglaWeekday, getAbsoluteAmount, getAllBanglaWeekdays, getAllMonths, getAllOperatorCodes, getAllOperators, getAllSeasons, getBanglaDate, getBanglaDateDifference, getBanglaMonthDays, getBanglaMonthLengths, getBanglaPercentage, getCurrentBanglaDate, getCurrentSeason, getCurrentTimeBangla, getDaysBetween, getDaysDifference, getFirstDayOfBanglaMonth, getLastDayOfBanglaMonth, getMonthFromIndex, getMonthIndex, getMonthMapping, getMonthName, getMonthRange, getNextBanglaWeekday, getNextMonth, getNextOrdinal, getNextSeason, getNextWeekday, getOperator, getOperatorName, getOrdinalSequence, getOrdinalType, getPreviousBanglaWeekday, getPreviousMonth, getPreviousOrdinal, getPreviousSeason, getPreviousWeekday, getRanking, getSeason, getSeasonByIndex, getSeasonFromMonth, getSeasonIndex, getSeasonInfo, getSeasonMonths, getSpecialOrdinals, getTimePeriod, getWeekdayName, hasBanglaConsonants, hasBanglaDigits, hasBanglaMonth, hasBanglaVowels, hasCountryCode, hasOnlyBanglaDigits, hasSeconds, hasSpecialOrdinal, hasTakaSymbol, hasTakaWord, isBanglaCurrency, isBanglaDateInRange, isBanglaDigit, isBanglaLeapYear, isBanglaOrdinal, isBanglaText, isBanglaWeekend, isCurrencyEqual, isCurrencyInRange, isDateInRange, isFuture, isGreaterThan, isInSpecialOrdinalRange, isLessThan, isMixedContent, isMonthInRange, isMonthInSeason, isNegativeAmount, isNumberInRange, isPast, isPositiveAmount, isPrimarilyBangla, isSameDay, isSameNumber, isSameSeason, isTimeInRange, isToday, isValidBanglaDate, isValidBanglaDateString, isValidBanglaDay, isValidBanglaMonth, isValidBanglaMonthNumber, isValidBanglaNumber, isValidBanglaWeekday, isValidBanglaYear, isValidCurrency, isValidDate, isValidDateForSeason, isValidDateForWeekday, isValidMonth, isValidMonthNumber, isValidNumber, isValidNumberForOrdinal, isValidNumberForWords, isValidOperatorCode, isValidOrdinal, isValidPhoneFormat, isValidSeasonName, isValidTimeInput, isValidTimeString, isValidWeekdayNumber, isWeekend, isZeroAmount, multiplyCurrency, negateAmount, normalizePhoneNumber, normalizeWhitespace, parseAndConvertToBangla, parseAndConvertToMonth, parseAndConvertToOrdinal, parseAndFormat, parseAndFormatCurrency, parseCurrency, parseDate, parsePhoneNumber, parseTime, parseWeekdayInput, relativeDay, relativeTime, removeBanglaChars, removeCountryCode, roundCurrency, safeFormatCurrency, safeFormatDate, safeFormatPhone, safeFormatTime, safeFromBangla, safeFromBanglaMonth, safeFromBanglaNumber, safeFromBanglaWeekday, safeGetSeason, safeGetSeasonFromMonth, safeParseCurrency, safeParseDate, safeRelativeTime, safeToBangla, safeToBanglaMonth, safeToBanglaNumber, safeToBanglaWeekday, safeToOrdinal, sanitizeBanglaDate, sanitizeBanglaMonth, sanitizeBanglaText, sanitizeCurrencyInput, sanitizeDate, sanitizeMonthNumber, sanitizeNumberInput, sanitizeOrdinalInput, sanitizePhoneNumber, sanitizeTimeInput, sanitizeWeekdayInput, secondsToTime, splitAmount, splitBanglaContent, subtractCurrency, sumCurrency, timeDifferenceMinutes, timeToSeconds, toBanglaCalendar, toBanglaMonth, toBanglaNumber, toBanglaWeekday, toOrdinal, toWords, truncateDecimals, validateBangla, validatePhone };