@lokascript/i18n 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,947 @@
+import { ai as I18nConfig, aj as TranslationOptions, ak as TranslationResult, al as Dictionary, am as ValidationResult$1, an as Token } from './transformer-Ckask-yw.js';
+export { D as AdpositionType, au as DICTIONARY_CATEGORIES, ao as DictionaryCategory, E as ENGLISH_COMMANDS, d as ENGLISH_KEYWORDS, H as GrammarRule, ac as GrammarTransformer, G as GrammaticalMarker, K as KeywordProvider, a as KeywordProviderOptions, Q as LANGUAGE_FAMILY_DEFAULTS, F as LanguageProfile, L as LocaleManager, ar as LocaleMetadata, M as MorphologyType, N as ParsedElement, J as ParsedStatement, P as PatternMatcher, I as PatternTransform, S as SemanticRole, at as TokenType, as as TranslationContext, U as UNIVERSAL_ENGLISH_KEYWORDS, O as UNIVERSAL_PATTERNS, ap as ValidationError, aq as ValidationWarning, W as WordOrder, n as arDictionary, m as arKeywords, a3 as arabicProfile, a2 as chineseProfile, b as createEnglishProvider, c as createKeywordProvider, l as deDictionary, k as deKeywords, C as detectBrowserLocale, $ as englishProfile, f as esDictionary, e as esKeywords, ay as findInDictionary, ax as forEachCategory, i as frDictionary, h as frKeywords, aw as getDictionaryCategory, Z as getProfile, _ as getSupportedLocales, ah as grammarExamples, u as idDictionary, s as idKeywords, a9 as indonesianProfile, T as insertMarkers, av as isDictionaryCategory, g as jaDictionary, j as jaKeywords, a0 as japaneseProfile, p as koDictionary, o as koKeywords, a1 as koreanProfile, ad as parseStatement, Y as profiles, B as ptDictionary, A as ptKeywords, w as quDictionary, v as quKeywords, aa as quechuaProfile, R as reorderRoles, a5 as spanishProfile, y as swDictionary, x as swKeywords, ab as swahiliProfile, af as toEnglish, ae as toLocale, r as trDictionary, t as trKeywords, X as transformStatement, ag as translate, az as translateFromEnglish, a4 as turkishProfile, q as zhDictionary, z as zhKeywords } from './transformer-Ckask-yw.js';
+import { Plugin } from 'vite';
+import { z } from 'zod';
+
+declare class HyperscriptTranslator {
+    private config;
+    private dictionaries;
+    private reverseDictionaries;
+    constructor(config: I18nConfig);
+    translate(text: string, options: TranslationOptions): string;
+    translateWithDetails(text: string, options: TranslationOptions): TranslationResult;
+    private translateTokens;
+    private findTranslation;
+    private isTranslatableToken;
+    private reconstructText;
+    detectLanguage(text: string): string;
+    addDictionary(locale: string, dictionary: Dictionary): void;
+    getDictionary(locale: string): Dictionary | undefined;
+    private getReverseDictionary;
+    getSupportedLocales(): string[];
+    validateDictionary(locale: string): ValidationResult$1;
+    isRTL(locale: string): boolean;
+    getCompletions(context: {
+        text: string;
+        position: number;
+        locale: string;
+    }): string[];
+}
+
+/**
+ * Dictionary Index
+ *
+ * Exports dictionaries for all supported languages.
+ *
+ * Strategy: Dictionaries are derived from semantic profiles where possible,
+ * with fallbacks to manual definitions for categories not in profiles
+ * (events, temporal, some values, attributes).
+ *
+ * The semantic package's language profiles are the single source of truth
+ * for command/modifier/logical keyword translations.
+ *
+ * TRANSITION NOTE: Currently using full legacy overrides to preserve
+ * backward compatibility. Once profiles and dictionaries are synchronized,
+ * the legacy overrides can be reduced to only non-profile categories.
+ */
+
+/**
+ * English dictionary - uses legacy values for full compatibility.
+ */
+declare const en: Dictionary;
+/**
+ * Spanish dictionary - legacy overrides for compatibility.
+ */
+declare const es: Dictionary;
+/**
+ * Japanese dictionary - legacy overrides for compatibility.
+ */
+declare const ja: Dictionary;
+/**
+ * Korean dictionary - legacy overrides for compatibility.
+ */
+declare const ko: Dictionary;
+/**
+ * Chinese dictionary - legacy overrides for compatibility.
+ */
+declare const zh: Dictionary;
+/**
+ * French dictionary - legacy overrides for compatibility.
+ */
+declare const fr: Dictionary;
+/**
+ * German dictionary - legacy overrides for compatibility.
+ */
+declare const de: Dictionary;
+/**
+ * Arabic dictionary - legacy overrides for compatibility.
+ */
+declare const ar: Dictionary;
+/**
+ * Turkish dictionary - legacy overrides for compatibility.
+ */
+declare const tr: Dictionary;
+/**
+ * Indonesian dictionary - legacy overrides for compatibility.
+ */
+declare const id: Dictionary;
+/**
+ * Portuguese dictionary - legacy overrides for compatibility.
+ */
+declare const pt: Dictionary;
+/**
+ * Quechua dictionary - legacy overrides for compatibility.
+ */
+declare const qu: Dictionary;
+/**
+ * Swahili dictionary - legacy overrides for compatibility.
+ */
+declare const sw: Dictionary;
+/**
+ * All available dictionaries indexed by locale code.
+ */
+declare const dictionaries: Record<string, Dictionary>;
+/**
+ * Get all supported locale codes.
+ */
+declare const supportedLocales: string[];
+/**
+ * Check if a locale is supported.
+ */
+declare const isLocaleSupported: (locale: string) => boolean;
+/**
+ * Get dictionary with fallback to another locale.
+ */
+declare const getDictionary: (locale: string, fallback?: string) => Dictionary | null;
+
+/**
+ * Detect the language of hyperscript text
+ */
+declare function detectLocale(text: string, supportedLocales: string[]): string;
+/**
+ * Get user's preferred locales from browser
+ */
+declare function getBrowserLocales(): string[];
+/**
+ * Check if a locale uses RTL writing
+ */
+declare function isRTL(locale: string): boolean;
+
+/**
+ * Tokenizer Adapter
+ *
+ * Bridges the semantic package's sophisticated tokenizers to i18n's
+ * dictionary-based token categorization system.
+ *
+ * The semantic tokenizers handle:
+ * - Language-specific word boundaries
+ * - CSS selectors, URLs, string literals
+ * - Grammatical particles (を, に, من)
+ * - Morphological normalization
+ *
+ * This adapter converts semantic tokens to i18n tokens by:
+ * 1. Using semantic's tokenize() for sophisticated tokenization
+ * 2. Mapping TokenKind to TokenType via dictionary lookup for keywords
+ * 3. Preserving position information for round-trip support
+ */
+
+/**
+ * Tokenize input using semantic package's sophisticated tokenizers,
+ * converting to i18n-compatible tokens.
+ *
+ * Falls back to basic tokenization if:
+ * - Semantic package not loaded yet
+ * - Language not supported by semantic
+ * - Any error occurs
+ *
+ * For best performance, call initSemanticTokenizer() at app startup.
+ */
+declare function tokenize(text: string, locale: string): Token[];
+
+declare function validate(dictionary: Dictionary, locale: string): ValidationResult$1;
+
+interface HyperscriptI18nViteOptions {
+    sourceLocale?: string;
+    targetLocale?: string;
+    preserveOriginal?: boolean;
+    attributes?: string[];
+    include?: RegExp | string[];
+    exclude?: RegExp | string[];
+}
+declare function hyperscriptI18nVitePlugin(options?: HyperscriptI18nViteOptions): Plugin;
+
+interface Compiler {
+    hooks: any;
+    webpack: any;
+}
+interface WebpackPluginInstance {
+    apply(compiler: Compiler): void;
+}
+interface HyperscriptI18nWebpackOptions {
+    sourceLocale?: string;
+    targetLocale?: string;
+    preserveOriginal?: boolean;
+    attributes?: string[];
+    test?: RegExp;
+}
+declare class HyperscriptI18nWebpackPlugin implements WebpackPluginInstance {
+    private options;
+    private translator;
+    constructor(options?: HyperscriptI18nWebpackOptions);
+    apply(compiler: Compiler): void;
+    private processAsset;
+    private processHtml;
+}
+
+/**
+ * SSR integration for i18n support
+ */
+interface SSRLocaleContext {
+    locale: string;
+    direction: 'ltr' | 'rtl';
+    preferredLocales: string[];
+    userAgent?: string;
+    acceptLanguage?: string;
+}
+interface SSRLocaleOptions {
+    detectFromHeaders?: boolean;
+    detectFromUrl?: boolean;
+    fallbackLocale?: string;
+    supportedLocales?: string[];
+    urlPattern?: RegExp;
+}
+declare class SSRLocaleManager {
+    private translator;
+    private options;
+    constructor(translator: HyperscriptTranslator, options?: SSRLocaleOptions);
+    /**
+     * Extract locale from SSR request
+     */
+    extractLocale(request: {
+        url?: string;
+        headers?: Record<string, string>;
+        userAgent?: string;
+    }): SSRLocaleContext;
+    /**
+     * Generate HTML lang and dir attributes
+     */
+    generateHtmlAttributes(context: SSRLocaleContext): string;
+    /**
+     * Generate meta tags for SEO
+     */
+    generateMetaTags(context: SSRLocaleContext, alternateUrls?: Record<string, string>): string[];
+    /**
+     * Translate hyperscript code for SSR
+     */
+    translateForSSR(hyperscriptCode: string, targetLocale: string, options?: Partial<Omit<TranslationOptions, 'to'>>): string;
+    /**
+     * Generate client-side hydration data
+     */
+    generateHydrationData(context: SSRLocaleContext): object;
+    private extractLocaleFromUrl;
+    private parseAcceptLanguage;
+}
+/**
+ * Express middleware for SSR i18n
+ */
+declare function createExpressI18nMiddleware(translator: HyperscriptTranslator, options?: SSRLocaleOptions): (req: any, _res: any, next: any) => void;
+/**
+ * Next.js API for SSR i18n
+ */
+declare function withI18n(handler: any, translator: HyperscriptTranslator, options?: SSRLocaleOptions): (req: any, res: any) => Promise<any>;
+
+/**
+ * Pluralization rules for different languages
+ */
+type PluralRule = (n: number) => 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+/**
+ * Pluralization rules based on Unicode CLDR
+ */
+declare const pluralRules: Record<string, PluralRule>;
+/**
+ * Plural forms for hyperscript keywords
+ */
+interface PluralForms {
+    zero?: string;
+    one?: string;
+    two?: string;
+    few?: string;
+    many?: string;
+    other: string;
+}
+/**
+ * Get the appropriate plural form for a locale and count
+ */
+declare function getPlural(locale: string, count: number, forms: PluralForms): string;
+/**
+ * Plural-aware translation for time expressions
+ */
+declare const pluralTimeExpressions: Record<string, Record<string, PluralForms>>;
+/**
+ * Enhanced translator with pluralization support
+ */
+declare class PluralAwareTranslator {
+    /**
+     * Translate time expressions with proper pluralization
+     */
+    static translateTimeExpression(value: number, unit: string, locale: string): string;
+    /**
+     * Parse and translate plural-aware hyperscript time expressions
+     */
+    static translateHyperscriptTime(text: string, locale: string): string;
+    /**
+     * Get ordinal numbers (1st, 2nd, 3rd) in different languages
+     */
+    static getOrdinal(n: number, locale: string): string;
+}
+
+/**
+ * Locale-aware formatting utilities for i18n
+ */
+interface NumberFormatOptions {
+    style?: 'decimal' | 'currency' | 'percent';
+    currency?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    useGrouping?: boolean;
+}
+interface DateFormatOptions {
+    dateStyle?: 'full' | 'long' | 'medium' | 'short';
+    timeStyle?: 'full' | 'long' | 'medium' | 'short';
+    year?: 'numeric' | '2-digit';
+    month?: 'numeric' | '2-digit' | 'long' | 'short' | 'narrow';
+    day?: 'numeric' | '2-digit';
+    hour?: 'numeric' | '2-digit';
+    minute?: 'numeric' | '2-digit';
+    second?: 'numeric' | '2-digit';
+    timeZone?: string;
+}
+interface RelativeTimeFormatOptions {
+    style?: 'long' | 'short' | 'narrow';
+    numeric?: 'always' | 'auto';
+}
+/**
+ * Format numbers according to locale
+ */
+declare class NumberFormatter {
+    private locale;
+    private defaultOptions;
+    constructor(locale: string, defaultOptions?: NumberFormatOptions);
+    format(value: number, options?: NumberFormatOptions): string;
+    formatCurrency(value: number, currency: string, options?: Omit<NumberFormatOptions, 'style' | 'currency'>): string;
+    formatPercent(value: number, options?: Omit<NumberFormatOptions, 'style'>): string;
+    private fallbackFormat;
+}
+/**
+ * Format dates according to locale
+ */
+declare class DateFormatter {
+    private locale;
+    private defaultOptions;
+    constructor(locale: string, defaultOptions?: DateFormatOptions);
+    format(date: Date | string | number, options?: DateFormatOptions): string;
+    formatRelative(date: Date | string | number, options?: RelativeTimeFormatOptions): string;
+    private fallbackFormat;
+    private fallbackRelativeFormat;
+}
+/**
+ * Locale-aware formatting manager
+ */
+declare class LocaleFormatter {
+    private locale;
+    private numberFormatter;
+    private dateFormatter;
+    constructor(locale: string);
+    formatNumber(value: number, options?: NumberFormatOptions): string;
+    formatCurrency(value: number, currency: string, options?: Omit<NumberFormatOptions, 'style' | 'currency'>): string;
+    formatPercent(value: number, options?: Omit<NumberFormatOptions, 'style'>): string;
+    formatDate(date: Date | string | number, options?: DateFormatOptions): string;
+    formatRelativeTime(date: Date | string | number, options?: RelativeTimeFormatOptions): string;
+    formatHyperscriptValue(value: any, type?: string): string;
+    formatList(items: string[], options?: {
+        style?: 'long' | 'short' | 'narrow';
+        type?: 'conjunction' | 'disjunction' | 'unit';
+    }): string;
+    formatUnit(value: number, unit: string, options?: {
+        style?: 'long' | 'short' | 'narrow';
+    }): string;
+    setLocale(locale: string): void;
+    getLocale(): string;
+}
+declare function getFormatter(locale: string): LocaleFormatter;
+declare function formatForLocale(locale: string, value: any, type?: string): string;
+
+/**
+ * Runtime i18n manager for client-side locale switching
+ */
+interface RuntimeI18nOptions extends I18nConfig {
+    autoDetect?: boolean;
+    storageKey?: string;
+    urlParam?: string;
+    cookieName?: string;
+    updateURL?: boolean;
+    updateTitle?: boolean;
+    updateLang?: boolean;
+    updateDir?: boolean;
+}
+declare class RuntimeI18nManager {
+    private translator;
+    private options;
+    private currentLocale;
+    private observers;
+    private initialized;
+    constructor(options?: Partial<RuntimeI18nOptions>);
+    /**
+     * Initialize the runtime i18n system
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set the current locale
+     */
+    setLocale(locale: string, updateStorage?: boolean): Promise<void>;
+    /**
+     * Get the current locale
+     */
+    getLocale(): string;
+    /**
+     * Get supported locales
+     */
+    getSupportedLocales(): string[];
+    /**
+     * Check if a locale is RTL
+     */
+    isRTL(locale?: string): boolean;
+    /**
+     * Translate a hyperscript string
+     */
+    translate(text: string, options?: Partial<TranslationOptions>): string;
+    /**
+     * Format a value according to current locale
+     */
+    format(value: any, type?: string): string;
+    /**
+     * Add dictionary for a locale
+     */
+    addDictionary(locale: string, dictionary: Dictionary): void;
+    /**
+     * Subscribe to locale changes
+     */
+    onLocaleChange(callback: (locale: string) => void): () => void;
+    /**
+     * Create a locale switcher element
+     */
+    createLocaleSwitcher(options?: {
+        type?: 'dropdown' | 'buttons';
+        className?: string;
+        showNativeNames?: boolean;
+    }): HTMLElement;
+    /**
+     * Detect initial locale from various sources
+     */
+    private detectInitialLocale;
+    /**
+     * Save locale to storage
+     */
+    private saveLocaleToStorage;
+    /**
+     * Update URL with current locale
+     */
+    private updateURL;
+    /**
+     * Update document attributes
+     */
+    private updateDocumentAttributes;
+    /**
+     * Translate the entire page
+     */
+    private translatePage;
+    /**
+     * Set up event listeners
+     */
+    private setupEventListeners;
+    /**
+     * Notify observers of locale change
+     */
+    private notifyObservers;
+    /**
+     * Get locale display name
+     */
+    private getLocaleDisplayName;
+    /**
+     * Cookie utilities
+     */
+    private getCookie;
+    private setCookie;
+}
+/**
+ * Global runtime instance
+ */
+declare let runtimeI18n: RuntimeI18nManager | null;
+/**
+ * Initialize global runtime i18n
+ */
+declare function initializeI18n(options?: RuntimeI18nOptions): RuntimeI18nManager;
+/**
+ * Get global runtime i18n instance
+ */
+declare function getI18n(): RuntimeI18nManager;
+
+/**
+ * Enhanced I18n Implementation
+ * Type-safe internationalization following enhanced pattern
+ */
+
+/**
+ * Validation result for i18n operations
+ */
+interface ValidationResult {
+    isValid: boolean;
+    errors: Array<{
+        type: string;
+        message: string;
+        path?: string;
+    }>;
+    suggestions?: string[];
+}
+/**
+ * Evaluation result wrapper
+ */
+interface EvaluationResult<T = unknown> {
+    success: boolean;
+    value?: T;
+    type?: string;
+    errors?: Array<{
+        type: string;
+        message: string;
+    }>;
+    suggestions?: string[];
+}
+/**
+ * Context metadata for enhanced pattern
+ */
+interface ContextMetadata {
+    contextId?: string;
+    timestamp?: number;
+    category: string;
+    capabilities?: string[];
+    state?: string;
+    complexity?: string;
+    sideEffects?: string[];
+    dependencies?: string[];
+    returnTypes?: string[];
+    relatedContexts?: string[];
+    examples?: Array<{
+        input: string;
+        description: string;
+        expectedOutput: string;
+    }>;
+    frameworkDependencies?: string[];
+    environmentRequirements?: {
+        browser?: boolean;
+        server?: boolean;
+        nodejs?: boolean;
+    };
+    performance?: {
+        averageTime?: number;
+        complexity?: string;
+    };
+}
+/**
+ * LLM documentation interface for AI-friendly descriptions
+ */
+interface LLMDocumentation {
+    summary: string;
+    description?: string;
+    examples?: Array<string | {
+        title: string;
+        code: string;
+        explanation: string;
+        output: string;
+    }>;
+    category?: string;
+    parameters?: Array<{
+        name: string;
+        type: string;
+        description: string;
+        required?: boolean;
+        default?: string;
+        optional?: boolean;
+        examples?: string[];
+    }>;
+    returns?: {
+        type: string;
+        description: string;
+        examples?: string[];
+    };
+    tips?: string[];
+    commonMistakes?: string[];
+    seeAlso?: string[];
+    tags?: string[];
+}
+/**
+ * Evaluation type enumeration
+ */
+type EvaluationType = 'sync' | 'async' | 'streaming' | 'Context';
+declare const EnhancedI18nInputSchema: z.ZodObject<{
+    /** Locale configuration */
+    locale: z.ZodString;
+    fallbackLocale: z.ZodOptional<z.ZodString>;
+    /** Dictionary data for translations */
+    dictionaries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        commands: z.ZodRecord<z.ZodString, z.ZodString>;
+        modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+        events: z.ZodRecord<z.ZodString, z.ZodString>;
+        logical: z.ZodRecord<z.ZodString, z.ZodString>;
+        temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+        values: z.ZodRecord<z.ZodString, z.ZodString>;
+        attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodRecord<z.ZodString, z.ZodString>, z.objectOutputType<{
+        commands: z.ZodRecord<z.ZodString, z.ZodString>;
+        modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+        events: z.ZodRecord<z.ZodString, z.ZodString>;
+        logical: z.ZodRecord<z.ZodString, z.ZodString>;
+        temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+        values: z.ZodRecord<z.ZodString, z.ZodString>;
+        attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">, z.objectInputType<{
+        commands: z.ZodRecord<z.ZodString, z.ZodString>;
+        modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+        events: z.ZodRecord<z.ZodString, z.ZodString>;
+        logical: z.ZodRecord<z.ZodString, z.ZodString>;
+        temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+        values: z.ZodRecord<z.ZodString, z.ZodString>;
+        attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">>>>;
+    /** Translation options */
+    options: z.ZodOptional<z.ZodObject<{
+        detectLocale: z.ZodDefault<z.ZodBoolean>;
+        rtlLocales: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        preserveOriginalAttribute: z.ZodOptional<z.ZodString>;
+        validate: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        detectLocale: boolean;
+        rtlLocales: string[];
+        validate: boolean;
+        preserveOriginalAttribute?: string | undefined;
+    }, {
+        detectLocale?: boolean | undefined;
+        rtlLocales?: string[] | undefined;
+        preserveOriginalAttribute?: string | undefined;
+        validate?: boolean | undefined;
+    }>>;
+    /** Context variables for translation */
+    variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Environment and debug settings */
+    environment: z.ZodDefault<z.ZodEnum<["frontend", "backend", "universal"]>>;
+    debug: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    locale: string;
+    environment: "frontend" | "backend" | "universal";
+    debug: boolean;
+    fallbackLocale?: string | undefined;
+    dictionaries?: Record<string, z.objectOutputType<{
+        commands: z.ZodRecord<z.ZodString, z.ZodString>;
+        modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+        events: z.ZodRecord<z.ZodString, z.ZodString>;
+        logical: z.ZodRecord<z.ZodString, z.ZodString>;
+        temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+        values: z.ZodRecord<z.ZodString, z.ZodString>;
+        attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">> | undefined;
+    options?: {
+        detectLocale: boolean;
+        rtlLocales: string[];
+        validate: boolean;
+        preserveOriginalAttribute?: string | undefined;
+    } | undefined;
+    variables?: Record<string, unknown> | undefined;
+}, {
+    locale: string;
+    fallbackLocale?: string | undefined;
+    dictionaries?: Record<string, z.objectInputType<{
+        commands: z.ZodRecord<z.ZodString, z.ZodString>;
+        modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+        events: z.ZodRecord<z.ZodString, z.ZodString>;
+        logical: z.ZodRecord<z.ZodString, z.ZodString>;
+        temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+        values: z.ZodRecord<z.ZodString, z.ZodString>;
+        attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">> | undefined;
+    options?: {
+        detectLocale?: boolean | undefined;
+        rtlLocales?: string[] | undefined;
+        preserveOriginalAttribute?: string | undefined;
+        validate?: boolean | undefined;
+    } | undefined;
+    variables?: Record<string, unknown> | undefined;
+    environment?: "frontend" | "backend" | "universal" | undefined;
+    debug?: boolean | undefined;
+}>;
+declare const EnhancedI18nOutputSchema: z.ZodObject<{
+    /** Context identifier */
+    contextId: z.ZodString;
+    timestamp: z.ZodNumber;
+    category: z.ZodLiteral<"Universal">;
+    capabilities: z.ZodArray<z.ZodString, "many">;
+    state: z.ZodEnum<["ready", "loading", "error"]>;
+    /** I18n specific capabilities */
+    translate: z.ZodAny;
+    translateHyperscript: z.ZodAny;
+    setLocale: z.ZodAny;
+    getLocale: z.ZodAny;
+    validateTranslation: z.ZodAny;
+    /** Locale management */
+    locale: z.ZodObject<{
+        current: z.ZodString;
+        fallback: z.ZodOptional<z.ZodString>;
+        direction: z.ZodEnum<["ltr", "rtl"]>;
+        available: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        direction: "ltr" | "rtl";
+        current: string;
+        available: string[];
+        fallback?: string | undefined;
+    }, {
+        direction: "ltr" | "rtl";
+        current: string;
+        available: string[];
+        fallback?: string | undefined;
+    }>;
+    /** Dictionary access */
+    dictionary: z.ZodObject<{
+        get: z.ZodAny;
+        set: z.ZodAny;
+        has: z.ZodAny;
+        keys: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        set?: any;
+        get?: any;
+        has?: any;
+        keys?: any;
+    }, {
+        set?: any;
+        get?: any;
+        has?: any;
+        keys?: any;
+    }>;
+    /** Formatting utilities */
+    format: z.ZodObject<{
+        number: z.ZodAny;
+        date: z.ZodAny;
+        currency: z.ZodAny;
+        relative: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+        number?: any;
+        currency?: any;
+        relative?: any;
+        date?: any;
+    }, {
+        number?: any;
+        currency?: any;
+        relative?: any;
+        date?: any;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    locale: {
+        direction: "ltr" | "rtl";
+        current: string;
+        available: string[];
+        fallback?: string | undefined;
+    };
+    category: "Universal";
+    dictionary: {
+        set?: any;
+        get?: any;
+        has?: any;
+        keys?: any;
+    };
+    contextId: string;
+    timestamp: number;
+    capabilities: string[];
+    state: "error" | "ready" | "loading";
+    format: {
+        number?: any;
+        currency?: any;
+        relative?: any;
+        date?: any;
+    };
+    translate?: any;
+    translateHyperscript?: any;
+    setLocale?: any;
+    getLocale?: any;
+    validateTranslation?: any;
+}, {
+    locale: {
+        direction: "ltr" | "rtl";
+        current: string;
+        available: string[];
+        fallback?: string | undefined;
+    };
+    category: "Universal";
+    dictionary: {
+        set?: any;
+        get?: any;
+        has?: any;
+        keys?: any;
+    };
+    contextId: string;
+    timestamp: number;
+    capabilities: string[];
+    state: "error" | "ready" | "loading";
+    format: {
+        number?: any;
+        currency?: any;
+        relative?: any;
+        date?: any;
+    };
+    translate?: any;
+    translateHyperscript?: any;
+    setLocale?: any;
+    getLocale?: any;
+    validateTranslation?: any;
+}>;
+type EnhancedI18nInput = z.infer<typeof EnhancedI18nInputSchema>;
+type EnhancedI18nOutput = z.infer<typeof EnhancedI18nOutputSchema>;
+declare class TypedI18nContextImplementation {
+    readonly name = "i18nContext";
+    readonly category: "Universal";
+    readonly description = "Type-safe internationalization context with enhanced validation and LLM integration";
+    readonly inputSchema: z.ZodObject<{
+        /** Locale configuration */
+        locale: z.ZodString;
+        fallbackLocale: z.ZodOptional<z.ZodString>;
+        /** Dictionary data for translations */
+        dictionaries: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            commands: z.ZodRecord<z.ZodString, z.ZodString>;
+            modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+            events: z.ZodRecord<z.ZodString, z.ZodString>;
+            logical: z.ZodRecord<z.ZodString, z.ZodString>;
+            temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+            values: z.ZodRecord<z.ZodString, z.ZodString>;
+            attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodRecord<z.ZodString, z.ZodString>, z.objectOutputType<{
+            commands: z.ZodRecord<z.ZodString, z.ZodString>;
+            modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+            events: z.ZodRecord<z.ZodString, z.ZodString>;
+            logical: z.ZodRecord<z.ZodString, z.ZodString>;
+            temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+            values: z.ZodRecord<z.ZodString, z.ZodString>;
+            attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">, z.objectInputType<{
+            commands: z.ZodRecord<z.ZodString, z.ZodString>;
+            modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+            events: z.ZodRecord<z.ZodString, z.ZodString>;
+            logical: z.ZodRecord<z.ZodString, z.ZodString>;
+            temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+            values: z.ZodRecord<z.ZodString, z.ZodString>;
+            attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">>>>;
+        /** Translation options */
+        options: z.ZodOptional<z.ZodObject<{
+            detectLocale: z.ZodDefault<z.ZodBoolean>;
+            rtlLocales: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+            preserveOriginalAttribute: z.ZodOptional<z.ZodString>;
+            validate: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            detectLocale: boolean;
+            rtlLocales: string[];
+            validate: boolean;
+            preserveOriginalAttribute?: string | undefined;
+        }, {
+            detectLocale?: boolean | undefined;
+            rtlLocales?: string[] | undefined;
+            preserveOriginalAttribute?: string | undefined;
+            validate?: boolean | undefined;
+        }>>;
+        /** Context variables for translation */
+        variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Environment and debug settings */
+        environment: z.ZodDefault<z.ZodEnum<["frontend", "backend", "universal"]>>;
+        debug: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        locale: string;
+        environment: "frontend" | "backend" | "universal";
+        debug: boolean;
+        fallbackLocale?: string | undefined;
+        dictionaries?: Record<string, z.objectOutputType<{
+            commands: z.ZodRecord<z.ZodString, z.ZodString>;
+            modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+            events: z.ZodRecord<z.ZodString, z.ZodString>;
+            logical: z.ZodRecord<z.ZodString, z.ZodString>;
+            temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+            values: z.ZodRecord<z.ZodString, z.ZodString>;
+            attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">> | undefined;
+        options?: {
+            detectLocale: boolean;
+            rtlLocales: string[];
+            validate: boolean;
+            preserveOriginalAttribute?: string | undefined;
+        } | undefined;
+        variables?: Record<string, unknown> | undefined;
+    }, {
+        locale: string;
+        fallbackLocale?: string | undefined;
+        dictionaries?: Record<string, z.objectInputType<{
+            commands: z.ZodRecord<z.ZodString, z.ZodString>;
+            modifiers: z.ZodRecord<z.ZodString, z.ZodString>;
+            events: z.ZodRecord<z.ZodString, z.ZodString>;
+            logical: z.ZodRecord<z.ZodString, z.ZodString>;
+            temporal: z.ZodRecord<z.ZodString, z.ZodString>;
+            values: z.ZodRecord<z.ZodString, z.ZodString>;
+            attributes: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.ZodRecord<z.ZodString, z.ZodString>, "strip">> | undefined;
+        options?: {
+            detectLocale?: boolean | undefined;
+            rtlLocales?: string[] | undefined;
+            preserveOriginalAttribute?: string | undefined;
+            validate?: boolean | undefined;
+        } | undefined;
+        variables?: Record<string, unknown> | undefined;
+        environment?: "frontend" | "backend" | "universal" | undefined;
+        debug?: boolean | undefined;
+    }>;
+    readonly outputType: EvaluationType;
+    private evaluationHistory;
+    readonly metadata: ContextMetadata;
+    readonly documentation: LLMDocumentation;
+    initialize(input: EnhancedI18nInput): Promise<EvaluationResult<EnhancedI18nOutput>>;
+    validate(input: unknown): ValidationResult;
+    private initializeLocale;
+    private loadDictionaries;
+    private createTranslateFunction;
+    private createHyperscriptTranslator;
+    private createLocaleChanger;
+    private createValidationFunction;
+    private getDictionaryValue;
+    private setDictionaryValue;
+    private hasDictionaryValue;
+    private getDictionaryKeys;
+    private createNumberFormatter;
+    private createDateFormatter;
+    private createCurrencyFormatter;
+    private createRelativeTimeFormatter;
+    private trackPerformance;
+    getPerformanceMetrics(): {
+        totalInitializations: number;
+        successRate: number;
+        averageDuration: number;
+        lastEvaluationTime: number;
+        evaluationHistory: {
+            input: EnhancedI18nInput;
+            output: EnhancedI18nOutput | undefined;
+            success: boolean;
+            duration: number;
+            timestamp: number;
+        }[];
+    };
+}
+declare function createI18nContext(): TypedI18nContextImplementation;
+declare function createEnhancedI18n(locale: string, options?: Partial<EnhancedI18nInput>): Promise<EvaluationResult<EnhancedI18nOutput>>;
+declare const enhancedI18nImplementation: TypedI18nContextImplementation;
+
+declare const defaultTranslator: HyperscriptTranslator;
+
+declare const defaultRuntime: RuntimeI18nManager;
+
+export { type DateFormatOptions, DateFormatter, Dictionary, type EnhancedI18nInput, EnhancedI18nInputSchema, type EnhancedI18nOutput, EnhancedI18nOutputSchema, HyperscriptI18nWebpackPlugin, HyperscriptTranslator, I18nConfig, LocaleFormatter, type NumberFormatOptions, NumberFormatter, PluralAwareTranslator, type PluralForms, type PluralRule, type RelativeTimeFormatOptions, RuntimeI18nManager, type RuntimeI18nOptions, type SSRLocaleContext, SSRLocaleManager, type SSRLocaleOptions, Token, TranslationOptions, TranslationResult, TypedI18nContextImplementation, ValidationResult$1 as ValidationResult, ar, createEnhancedI18n, createExpressI18nMiddleware, createI18nContext, de, defaultRuntime, defaultTranslator, detectLocale, dictionaries, en, enhancedI18nImplementation, es, formatForLocale, fr, getBrowserLocales, getDictionary, getFormatter, getI18n, getPlural, hyperscriptI18nVitePlugin, id, initializeI18n, isLocaleSupported, isRTL, ja, ko, pluralRules, pluralTimeExpressions, pt, qu, runtimeI18n, supportedLocales, sw, tokenize, tr, validate, withI18n, zh };