@nice2dev/i18n 1.0.5 → 1.0.6

package/dist/index.d.ts

@@ -13,6 +13,28 @@
  */
 
 import { default as default_2 } from 'react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+/**
+ * Apply accented characters to text.
+ */
+export declare function addAccents(text: string, extended?: boolean): string;
+
+/**
+ * Add bidi markers for RTL testing.
+ */
+export declare function addBidiMarkers(text: string, rtl?: boolean): string;
+
+/**
+ * Add brackets around text to identify translatable strings.
+ */
+export declare function addBrackets(text: string, prefix?: string, suffix?: string): string;
+
+/**
+ * Analyze a translation dictionary for potential i18n issues.
+ */
+export declare function analyzeDictionary(sourceDictionary: Record<string, string>, targetDictionary?: Record<string, string>): I18nAnalysisResult;
 
 /**
  * Check common RTL issues in styles.
@@ -20,6 +42,104 @@ import { default as default_2 } from 'react';
  */
 export declare function analyzeStylesForRTL(styles: Record<string, string | number>): string[];
 
+export declare interface CacheEntry {
+    data: TranslationDictionary;
+    loadedAt: number;
+    expiresAt: number;
+}
+
+export declare const CALENDAR_INFO: Record<CalendarSystem, CalendarInfo>;
+
+export declare interface CalendarDate {
+    /** Calendar system used */
+    calendar: CalendarSystem;
+    /** Year (era-relative for some calendars) */
+    year: number;
+    /** Month (1-12 for most, varies for lunar) */
+    month: number;
+    /** Day of month */
+    day: number;
+    /** Era name (if applicable) */
+    era?: string;
+    /** Original Gregorian date */
+    gregorianDate: Date;
+}
+
+export declare interface CalendarFormatter {
+    /** Format a date in the selected calendar */
+    format: (date: Date) => string;
+    /** Format date with era */
+    formatWithEra: (date: Date) => string;
+    /** Get month name */
+    getMonthName: (date: Date) => string;
+    /** Get all month names for the calendar */
+    getMonthNames: () => string[];
+    /** Get weekday name */
+    getWeekdayName: (date: Date) => string;
+    /** Get all weekday names */
+    getWeekdayNames: () => string[];
+    /** Parse calendar date into components */
+    parseParts: (date: Date) => CalendarDate;
+    /** Get era name (if applicable) */
+    getEraName: (date: Date) => string | undefined;
+}
+
+export declare interface CalendarFormatterOptions {
+    /** Date format style */
+    dateStyle?: 'short' | 'medium' | 'long' | 'full';
+    /** Include era in output */
+    showEra?: boolean;
+    /** Include weekday in output */
+    showWeekday?: boolean;
+}
+
+export declare interface CalendarInfo {
+    /** Calendar system identifier */
+    id: CalendarSystem;
+    /** Display name in the specified language */
+    displayName: string;
+    /** Number of months in a year (average for lunar calendars) */
+    monthsInYear: number;
+    /** Whether the calendar uses eras */
+    hasEra: boolean;
+    /** Whether it's a lunar calendar */
+    isLunar: boolean;
+    /** Associated languages/regions */
+    associatedLanguages: NiceSupportedLang[];
+}
+
+/**
+ * Supported calendar systems.
+ * Uses Intl.DateTimeFormat calendar types.
+ */
+export declare type CalendarSystem = 'gregory' | 'islamic' | 'islamic-umalqura' | 'islamic-tbla' | 'islamic-civil' | 'hebrew' | 'buddhist' | 'japanese' | 'persian' | 'chinese' | 'coptic' | 'ethiopic' | 'indian' | 'roc';
+
+/**
+ * Chinese celestial stems (天干).
+ */
+export declare const CELESTIAL_STEMS: string[];
+
+/**
+ * Chinese zodiac animals.
+ */
+export declare const CHINESE_ZODIAC: string[];
+
+/**
+ * Check if a string contains non-ASCII characters.
+ * Useful for detecting if text has been properly internationalized.
+ */
+export declare function containsNonAscii(text: string): boolean;
+
+/**
+ * Convert a date from one timezone to another.
+ */
+export declare function convertTimezone(date: Date, fromTimezone: string, toTimezone: string): Date;
+
+/**
+ * Create a calendar formatter for a specific calendar system.
+ */
+export declare function createCalendarFormatter(lang: NiceSupportedLang, calendar?: CalendarSystem, options?: CalendarFormatterOptions): CalendarFormatter;
+
 /**
  * Create a locale-aware currency formatter.
  */
@@ -30,11 +150,26 @@ export declare function createCurrencyFormatter(lang: NiceSupportedLang, currenc
  */
 export declare function createDateFormatter(lang: NiceSupportedLang, style?: DateFormatStyle): NiceDateFormatter;
 
+export declare function createDynamicLoader(config: LoaderConfig): DynamicLoader;
+
+/**
+ * Create a loader that fetches from URL.
+ */
+export declare function createFetchLoader(baseUrl: string, options?: Partial<LoaderConfig>): DynamicLoader;
+
 /**
  * Create a translator function that supports ICU MessageFormat.
  */
 export declare function createICUTranslator(dict: Record<string, string>, lang?: NiceSupportedLang): (key: string, defaultValue: string, values?: Record<string, string | number | Date>) => string;
 
+/**
+ * Create a loader that uses dynamic imports.
+ * Assumes translations are in same package.
+ */
+export declare function createImportLoader(importFn: (lang: NiceSupportedLang, namespace?: string) => Promise<{
+    default: TranslationDictionary;
+}>, options?: Partial<LoaderConfig>): DynamicLoader;
+
 /**
  * Create a locale-aware number formatter.
  */
@@ -45,14 +180,95 @@ export declare function createNumberFormatter(lang: NiceSupportedLang): NiceNumb
  */
 export declare function createTimeFormatter(lang: NiceSupportedLang, style?: DateFormatStyle): NiceTimeFormatter;
 
+/**
+ * Create a timezone-aware formatter.
+ */
+export declare function createTimezoneFormatter(lang: NiceSupportedLang, timezone: string, options?: TimezoneFormatterOptions): TimezoneFormatter;
+
 /** Get a translation function without React context (for non-component code). */
 export declare function createTranslator(lang?: NiceSupportedLang, overrides?: Record<string, string>): NiceTranslateFn;
 
 export declare type DateFormatStyle = 'short' | 'medium' | 'long' | 'full';
 
+export declare const DEFAULT_CALENDAR: Record<NiceSupportedLang, CalendarSystem>;
+
+/**
+ * Detect browser language and auto-load.
+ */
+export declare function detectAndLoad(loader: DynamicLoader, options?: {
+    fallback?: NiceSupportedLang;
+    preferredLanguages?: NiceSupportedLang[];
+}): Promise<NiceSupportedLang>;
+
 /** Get user's preferred language from browser. */
 export declare function detectBrowserLanguage(): NiceSupportedLang;
 
+/**
+ * Check if a string contains hard-coded text (potential i18n issue).
+ * Returns true if the string has printable ASCII but no translation markers.
+ */
+export declare function detectHardcodedText(text: string): boolean;
+
+/**
+ * Detect the user's timezone from browser/system settings.
+ */
+export declare function detectTimezone(): string;
+
+export declare interface DynamicI18nContextValue {
+    loader: DynamicLoader;
+    translations: TranslationDictionary;
+    isLoading: boolean;
+    error: Error | null;
+    setLanguage: (lang: NiceSupportedLang) => Promise<void>;
+    currentLanguage: NiceSupportedLang;
+    loadedLanguages: NiceSupportedLang[];
+}
+
+/**
+ * Provider for dynamic i18n loading in React apps.
+ */
+export declare function DynamicI18nProvider({ children, loader, initialLanguage, namespace, }: DynamicI18nProviderProps): JSX_2.Element;
+
+export declare interface DynamicI18nProviderProps {
+    children: ReactNode;
+    loader: DynamicLoader;
+    initialLanguage?: NiceSupportedLang;
+    namespace?: string;
+}
+
+export declare interface DynamicLoader {
+    /** Load translations for a language */
+    loadLanguage: (lang: NiceSupportedLang, namespace?: string) => Promise<TranslationDictionary | null>;
+    /** Load translations for multiple languages */
+    loadLanguages: (langs: NiceSupportedLang[]) => Promise<void>;
+    /** Preload languages based on config */
+    preloadLanguages: () => Promise<void>;
+    /** Get loaded translations */
+    getTranslations: (lang: NiceSupportedLang, namespace?: string) => TranslationDictionary | null;
+    /** Check if language is loaded */
+    isLoaded: (lang: NiceSupportedLang, namespace?: string) => boolean;
+    /** Check if language is loading */
+    isLoading: (lang: NiceSupportedLang) => boolean;
+    /** Get all loaded languages */
+    getLoadedLanguages: () => NiceSupportedLang[];
+    /** Clear cache for a language or all */
+    clearCache: (lang?: NiceSupportedLang) => void;
+    /** Get loader state */
+    getState: () => LoaderState;
+    /** Set current language (auto-loads if needed) */
+    setLanguage: (lang: NiceSupportedLang) => Promise<void>;
+    /** Get current language */
+    getCurrentLanguage: () => NiceSupportedLang;
+    /** Subscribe to state changes */
+    subscribe: (callback: (state: LoaderState) => void) => () => void;
+}
+
+/**
+ * Expand text to simulate longer translations.
+ * Languages like German, Finnish can be 30-50% longer than English.
+ */
+export declare function expandText(text: string, factor?: number, useVowelDoubling?: boolean): string;
+
 /**
  * Find fuzzy matches in existing translations for reuse.
  * Compares the English value to find similar existing translations.
@@ -106,6 +322,11 @@ export declare function formatICU(template: string, values?: Record<string, stri
  */
 export declare function formatMessage(template: string, values?: Record<string, string | number>): string;
 
+/**
+ * Convert a UTC date to local timezone.
+ */
+export declare function fromUTC(date: Date, toTimezone?: string): Date;
+
 /**
  * Generate a coverage report in markdown format.
  */
@@ -116,11 +337,41 @@ export declare function generateCoverageReport(): string;
  */
 export declare function generateTranslationCode(lang: NiceSupportedLang, translations: TranslationResult[]): string;
 
+/**
+ * Get all available timezones with their info.
+ */
+export declare function getAllTimezones(lang?: NiceSupportedLang, referenceDate?: Date): TimezoneInfo[];
+
 /**
  * Get translation statistics for all languages.
  */
 export declare function getAllTranslationStats(): TranslationStats[];
 
+/**
+ * Get all available calendar systems.
+ */
+export declare function getAvailableCalendars(): CalendarSystem[];
+
+/**
+ * Get calendar info with localized display name.
+ */
+export declare function getCalendarInfo(calendar: CalendarSystem, lang?: NiceSupportedLang): CalendarInfo;
+
+/**
+ * Get Chinese celestial stem for a year.
+ */
+export declare function getCelestialStem(year: number): string;
+
+/**
+ * Get Chinese zodiac animal for a year.
+ */
+export declare function getChineseZodiac(year: number): string;
+
+/**
+ * Get current date in a specific calendar system.
+ */
+export declare function getCurrentCalendarDate(calendar: CalendarSystem, lang?: NiceSupportedLang): CalendarDate;
+
 /**
  * Get the current document direction.
  */
@@ -134,6 +385,21 @@ export declare function getGlossaryForLanguage(lang: NiceSupportedLang): Array<{
     translation: string;
 }>;
 
+/**
+ * Get number of days in a Hijri month.
+ */
+export declare function getHijriMonthDays(year: number, month: number): number;
+
+/**
+ * Get the Japanese era for a given date.
+ */
+export declare function getJapaneseEra(date: Date): JapaneseEra | null;
+
+/**
+ * Get the Japanese year (era-relative) for a given date.
+ */
+export declare function getJapaneseYear(date: Date): number | null;
+
 /**
  * Get the BCP 47 locale tag for a NiceSupportedLang code.
  */
@@ -150,6 +416,11 @@ export declare function getLogicalProperty(physical: string): string;
  */
 export declare function getMissingTranslations(lang: NiceSupportedLang): MissingTranslation[];
 
+/**
+ * Get the next DST transition date for a timezone.
+ */
+export declare function getNextDSTTransition(timezone: string, fromDate?: Date): Date | null;
+
 /**
  * Get ordinal category for a number in a given language.
  * e.g., English: 1st, 2nd, 3rd, 4th...
@@ -162,6 +433,16 @@ export declare function getOrdinalCategory(n: number, lang: NiceSupportedLang):
  */
 export declare function getPluralCategory(n: number, lang: NiceSupportedLang): PluralCategory;
 
+/**
+ * Get preset options for common pseudo-localization modes.
+ */
+export declare function getPseudoLocalizationPreset(mode: PseudoLocalizationMode): PseudoLocalizationOptions;
+
+/**
+ * Get recommended calendars for a language.
+ */
+export declare function getRecommendedCalendars(lang: NiceSupportedLang): CalendarSystem[];
+
 /**
  * Generate CSS custom property values for RTL support.
  */
@@ -177,6 +458,16 @@ export declare function getSourceKeys(): string[];
  */
 export declare function getTextDirection(lang: string): 'ltr' | 'rtl';
 
+/**
+ * Get detailed information about a timezone.
+ */
+export declare function getTimezoneInfo(timezone: string, lang?: NiceSupportedLang, referenceDate?: Date): TimezoneInfo;
+
+/**
+ * Get timezones grouped by region.
+ */
+export declare function getTimezonesGrouped(lang?: NiceSupportedLang, referenceDate?: Date): Record<string, TimezoneInfo[]>;
+
 /**
  * Get translation statistics for a language.
  */
@@ -188,11 +479,72 @@ export declare interface GlossaryEntry {
     context?: string;
 }
 
+/**
+ * Hebrew month names.
+ */
+export declare const HEBREW_MONTHS: string[];
+
+/**
+ * Hebrew month names in leap year (includes Adar I and Adar II).
+ */
+export declare const HEBREW_MONTHS_LEAP: string[];
+
+export declare interface HebrewDate {
+    year: number;
+    month: number;
+    day: number;
+}
+
+/**
+ * Islamic month names (Arabic).
+ */
+export declare const HIJRI_MONTHS: string[];
+
+export declare interface HijriDate {
+    year: number;
+    month: number;
+    day: number;
+}
+
+/**
+ * Analyze a dictionary for i18n issues.
+ */
+export declare interface I18nAnalysisResult {
+    totalKeys: number;
+    hardcodedStrings: string[];
+    emptyValues: string[];
+    placeholderMismatches: Array<{
+        key: string;
+        placeholders: string[];
+    }>;
+    potentialIssues: number;
+}
+
 export declare interface ICUFormatOptions {
     lang?: NiceSupportedLang;
     locale?: string;
 }
 
+/**
+ * Check if DST is active for a timezone at a given date.
+ */
+export declare function isDSTActive(timezone: string, date?: Date): boolean;
+
+/**
+ * Check if a Hebrew year is a leap year.
+ */
+export declare function isHebrewLeapYear(year: number): boolean;
+
+/**
+ * Check if a Hijri year is a leap year.
+ */
+export declare function isHijriLeapYear(year: number): boolean;
+
+/**
+ * Check if a Persian year is a leap year.
+ */
+export declare function isPersianLeapYear(year: number): boolean;
+
 /**
  * Check if a language uses RTL text direction.
  */
@@ -201,6 +553,54 @@ export declare function isRTLLanguage(lang: string): boolean;
 /** Check if a language is supported. */
 export declare function isSupported(lang: string): lang is NiceSupportedLang;
 
+/**
+ * Check if a timezone identifier is valid.
+ */
+export declare function isValidTimezone(timezone: string): boolean;
+
+/**
+ * Modern Japanese eras.
+ */
+export declare const JAPANESE_ERAS: JapaneseEra[];
+
+export declare interface JapaneseEra {
+    name: string;
+    kanji: string;
+    startDate: Date;
+}
+
+export declare interface LoaderConfig {
+    /** Function to load translation file for a language */
+    loadFn: (lang: NiceSupportedLang, namespace?: string) => Promise<TranslationDictionary>;
+    /** Fallback language if requested language fails */
+    fallbackLang?: NiceSupportedLang;
+    /** Cache TTL in milliseconds (0 = no expiry) */
+    cacheTtl?: number;
+    /** Languages to preload on init */
+    preloadLanguages?: NiceSupportedLang[];
+    /** Namespaces to split translations into */
+    namespaces?: string[];
+    /** Default namespace */
+    defaultNamespace?: string;
+    /** Callback when loading starts */
+    onLoadStart?: (lang: NiceSupportedLang, namespace?: string) => void;
+    /** Callback when loading completes */
+    onLoadComplete?: (lang: NiceSupportedLang, namespace?: string) => void;
+    /** Callback when loading fails */
+    onLoadError?: (lang: NiceSupportedLang, error: Error, namespace?: string) => void;
+}
+
+export declare interface LoaderState {
+    /** Currently loaded languages */
+    loadedLanguages: Set<NiceSupportedLang>;
+    /** Languages currently being loaded */
+    loadingLanguages: Set<NiceSupportedLang>;
+    /** Failed languages with error info */
+    failedLanguages: Map<NiceSupportedLang, Error>;
+    /** Current active language */
+    currentLanguage: NiceSupportedLang;
+}
+
 /**
  * Look up a term in the glossary for a given language.
  * Returns the approved translation or undefined.
@@ -293,6 +693,11 @@ export declare function ordinal(n: number, forms: Partial<Record<OrdinalCategory
 
 export declare type OrdinalCategory = 'one' | 'two' | 'few' | 'other';
 
+/**
+ * Persian month names.
+ */
+export declare const PERSIAN_MONTHS: string[];
+
 /**
  * Type-safe plural helper.
  * Returns the appropriate form based on count.
@@ -303,6 +708,117 @@ export declare function plural(count: number, forms: Partial<Record<PluralCatego
 
 export declare type PluralCategory = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
 
+export declare type PreloadStrategy = 'immediate' | 'idle' | 'visible' | 'interaction';
+
+/**
+ * Preload languages based on strategy.
+ */
+export declare function preloadWithStrategy(loader: DynamicLoader, languages: NiceSupportedLang[], strategy: PreloadStrategy): void;
+
+export declare const PSEUDO_PRESETS: {
+    /** Minimal: brackets only */
+    readonly MINIMAL: {
+        readonly addBrackets: true;
+        readonly addAccents: false;
+        readonly expansionFactor: 0;
+    };
+    /** Accented: brackets + accents */
+    readonly ACCENTED: PseudoLocalizationOptions;
+    /** Expanded: brackets + 30% expansion */
+    readonly EXPANDED: PseudoLocalizationOptions;
+    /** Bidi: brackets + RTL markers */
+    readonly BIDI: PseudoLocalizationOptions;
+    /** Full: brackets + accents + expansion */
+    readonly FULL: PseudoLocalizationOptions;
+    /** Finnish: 40% expansion (Finnish is very long) */
+    readonly FINNISH: {
+        readonly addBrackets: true;
+        readonly addAccents: true;
+        readonly expansionFactor: 0.4;
+    };
+    /** German: 35% expansion */
+    readonly GERMAN: {
+        readonly addBrackets: true;
+        readonly addAccents: true;
+        readonly expansionFactor: 0.35;
+    };
+    /** CJK: Short expansion, no accents (CJK often shorter) */
+    readonly CJK: {
+        readonly addBrackets: true;
+        readonly addAccents: false;
+        readonly expansionFactor: -0.1;
+    };
+};
+
+export declare interface PseudoLocalizationContextValue {
+    enabled: boolean;
+    mode: PseudoLocalizationMode;
+    options: PseudoLocalizationOptions;
+    toggle: () => void;
+    setMode: (mode: PseudoLocalizationMode) => void;
+    transform: (text: string) => string;
+}
+
+export declare type PseudoLocalizationMode = 'accented' | 'bidi' | 'expansion' | 'full';
+
+export declare interface PseudoLocalizationOptions {
+    /** Wrap text in brackets to identify translatable strings */
+    addBrackets?: boolean;
+    /** Add padding to simulate longer translations (common: 30-50%) */
+    expansionFactor?: number;
+    /** Replace characters with accented versions */
+    addAccents?: boolean;
+    /** Add RTL/LTR markers for bidi testing */
+    addBidiMarkers?: boolean;
+    /** Use vowel-doubling for expansion instead of padding */
+    useVowelDoubling?: boolean;
+    /** Preserve ICU placeholders like {name} */
+    preservePlaceholders?: boolean;
+    /** Preserve HTML tags */
+    preserveHtml?: boolean;
+    /** Custom prefix (instead of '[') */
+    prefix?: string;
+    /** Custom suffix (instead of ']') */
+    suffix?: string;
+}
+
+/**
+ * Provider for pseudo-localization in React apps.
+ * Useful for development/testing.
+ */
+export declare function PseudoLocalizationProvider({ children, initialEnabled, initialMode, }: PseudoLocalizationProviderProps): JSX_2.Element;
+
+export declare interface PseudoLocalizationProviderProps {
+    children: ReactNode;
+    initialEnabled?: boolean;
+    initialMode?: PseudoLocalizationMode;
+}
+
+/**
+ * Apply pseudo-localization transformations to text.
+ *
+ * @example
+ * // Basic usage
+ * pseudoLocalize('Hello World');
+ * // Returns: '[Ĥëľľő Ŵőřľð~~~]'
+ *
+ * @example
+ * // With ICU placeholders preserved
+ * pseudoLocalize('Hello {name}', { preservePlaceholders: true });
+ * // Returns: '[Ĥëľľő {name}~~~]'
+ *
+ * @example
+ * // Expansion only (no accents)
+ * pseudoLocalize('Hello', { addAccents: false, expansionFactor: 0.5 });
+ * // Returns: '[Hello~~]'
+ */
+export declare function pseudoLocalize(text: string, options?: PseudoLocalizationOptions): string;
+
+/**
+ * Pseudo-localize an entire translation dictionary.
+ */
+export declare function pseudoLocalizeDictionary(dictionary: Record<string, string>, options?: PseudoLocalizationOptions): Record<string, string>;
+
 /**
  * CSS custom properties for RTL-aware components.
  * Use these as fallbacks in CSS-in-JS or CSS modules.
@@ -377,6 +893,68 @@ export declare function select<T extends string>(value: T, forms: Partial<Record
  */
 export declare function setDocumentDirection(lang: string): void;
 
+export declare const TIMEZONE_GROUPS: {
+    readonly UTC: readonly ["UTC", "Etc/UTC", "Etc/GMT"];
+    readonly NorthAmerica: readonly ["America/New_York", "America/Chicago", "America/Denver", "America/Los_Angeles", "America/Toronto", "America/Vancouver", "America/Mexico_City"];
+    readonly SouthAmerica: readonly ["America/Sao_Paulo", "America/Buenos_Aires", "America/Lima", "America/Bogota", "America/Santiago"];
+    readonly Europe: readonly ["Europe/London", "Europe/Paris", "Europe/Berlin", "Europe/Rome", "Europe/Madrid", "Europe/Amsterdam", "Europe/Warsaw", "Europe/Moscow", "Europe/Kiev", "Europe/Stockholm", "Europe/Prague", "Europe/Budapest", "Europe/Bucharest"];
+    readonly Asia: readonly ["Asia/Tokyo", "Asia/Shanghai", "Asia/Hong_Kong", "Asia/Singapore", "Asia/Seoul", "Asia/Kolkata", "Asia/Dubai", "Asia/Riyadh", "Asia/Tehran", "Asia/Bangkok", "Asia/Jakarta"];
+    readonly Africa: readonly ["Africa/Cairo", "Africa/Lagos", "Africa/Johannesburg", "Africa/Nairobi", "Africa/Casablanca"];
+    readonly Oceania: readonly ["Australia/Sydney", "Australia/Melbourne", "Australia/Perth", "Pacific/Auckland", "Pacific/Fiji"];
+};
+
+export declare interface TimezoneFormatter {
+    /** Format date with timezone */
+    format: (date: Date) => string;
+    /** Format date with explicit timezone name */
+    formatWithZone: (date: Date) => string;
+    /** Get timezone offset for a date */
+    getOffset: (date: Date) => string;
+    /** Get timezone abbreviation for a date */
+    getAbbreviation: (date: Date) => string;
+}
+
+export declare interface TimezoneFormatterOptions {
+    /** Include timezone name in output */
+    includeName?: boolean;
+    /** Use short or long timezone name */
+    nameStyle?: 'short' | 'long';
+    /** Date format style */
+    dateStyle?: 'short' | 'medium' | 'long' | 'full';
+    /** Time format style */
+    timeStyle?: 'short' | 'medium' | 'long' | 'full';
+}
+
+export declare interface TimezoneInfo {
+    /** IANA timezone identifier (e.g., 'America/New_York') */
+    id: string;
+    /** Display name in the specified language */
+    displayName: string;
+    /** Short display name (e.g., 'EST', 'CET') */
+    shortName: string;
+    /** UTC offset in minutes */
+    offsetMinutes: number;
+    /** UTC offset as string (e.g., '+05:30') */
+    offsetString: string;
+    /** Whether DST is currently active */
+    isDST: boolean;
+}
+
+/**
+ * Convert a Gregorian date to a specific calendar system.
+ * Returns the date components in the target calendar.
+ */
+export declare function toCalendar(date: Date, calendar: CalendarSystem, lang?: NiceSupportedLang): CalendarDate;
+
+/**
+ * Convert a date to UTC.
+ */
+export declare function toUTC(date: Date, fromTimezone?: string): Date;
+
+export declare type TranslationDictionary = Record<string, string>;
+
+export declare type TranslationNamespace = Record<string, TranslationDictionary>;
+
 export declare interface TranslationResult {
     key: string;
     original: string;
@@ -391,6 +969,38 @@ export declare interface TranslationStats {
     coverage: number;
 }
 
+/**
+ * React hook for calendar formatting.
+ */
+export declare function useCalendar(lang: NiceSupportedLang, calendar?: CalendarSystem, options?: CalendarFormatterOptions): {
+    calendar: CalendarSystem;
+    info: CalendarInfo;
+    current: CalendarDate;
+    format: (date: Date) => string;
+    formatWithEra: (date: Date) => string;
+    getMonthName: (date: Date) => string;
+    getMonthNames: () => string[];
+    getWeekdayName: (date: Date) => string;
+    getWeekdayNames: () => string[];
+    parseParts: (date: Date) => CalendarDate;
+    getEraName: (date: Date) => string | undefined;
+    toCalendar: (date: Date) => CalendarDate;
+};
+
+/**
+ * Hook to use dynamic i18n.
+ */
+export declare function useDynamicI18n(): DynamicI18nContextValue;
+
+/**
+ * Hook to get a translation function with dynamic loading.
+ */
+export declare function useDynamicTranslation(namespace?: string): {
+    t: (key: string, params?: Record<string, string | number>) => string;
+    isLoading: boolean;
+    currentLanguage: "en" | "pl" | "de" | "fr" | "es" | "it" | "pt" | "nl" | "sv" | "no" | "da" | "fi" | "cs" | "sk" | "hu" | "ro" | "bg" | "uk" | "ja" | "ko" | "zh" | "ar";
+};
+
 /**
  * Hook that returns true if current layout is RTL.
  */
@@ -421,11 +1031,30 @@ export declare function useNiceTranslation(): {
     t: NiceTranslateFn;
 };
 
+/**
+ * Hook to use pseudo-localization.
+ */
+export declare function usePseudoLocalization(): PseudoLocalizationContextValue;
+
 /**
  * Hook to access RTL context and helpers.
  */
 export declare function useRTL(): RTLContextValue;
 
+/**
+ * React hook for timezone-aware formatting.
+ */
+export declare function useTimezone(lang: NiceSupportedLang, timezone?: string, options?: TimezoneFormatterOptions): {
+    timezone: string;
+    info: TimezoneInfo;
+    format: (date: Date) => string;
+    formatWithZone: (date: Date) => string;
+    getOffset: (date: Date) => string;
+    getAbbreviation: (date: Date) => string;
+    toUTC: (date: Date) => Date;
+    fromUTC: (date: Date) => Date;
+};
+
 /**
  * Validate translations against the glossary.
  * Returns entries where the translation doesn't match the glossary.