"use strict";
/**
 * Enhanced i18n (Internationalization) Generator
 *
 * Generates comprehensive internationalization configuration including:
 * - Multi-locale support with fallback strategies
 * - Translation file management
 * - Date/number/currency formatting
 * - Integration with translation management providers (Lokalise, Crowdin, Phrase)
 * - Frontend and backend i18n utilities
 * - Type-safe translation keys
 */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.EnhancedI18nGenerator = void 0;
const path = __importStar(require("path"));
class EnhancedI18nGenerator {
    id = 'enhanced-i18n';
    name = 'Enhanced i18n Generator';
    description = 'Generates comprehensive internationalization configuration from enhanced schema';
    generate(context) {
        const { workflow, outputDirectory } = context;
        const files = [];
        if (!workflow.i18n) {
            return { files: [] };
        }
        const i18n = workflow.i18n;
        // Find frontend and backend components
        const frontendComponent = Object.entries(workflow.stack).find(([_, c]) => c.type === 'frontend');
        const backendComponent = Object.entries(workflow.stack).find(([_, c]) => c.type === 'backend');
        // Generate frontend i18n configuration
        if (frontendComponent) {
            const [componentName] = frontendComponent;
            files.push(...this.generateFrontendI18n(componentName, i18n, outputDirectory));
        }
        // Generate backend i18n configuration
        if (backendComponent) {
            const [componentName] = backendComponent;
            files.push(...this.generateBackendI18n(componentName, i18n, outputDirectory));
        }
        // Generate translation files
        files.push(...this.generateTranslationFiles(i18n, outputDirectory, frontendComponent?.[0]));
        // Generate translation management sync (if provider specified)
        if (i18n.translation_management?.provider) {
            files.push(this.generateTranslationSync(i18n, outputDirectory, backendComponent?.[0]));
        }
        return { files };
    }
    generateFrontendI18n(componentName, i18n, outputDirectory) {
        const files = [];
        // Generate i18n configuration
        files.push({
            path: path.join(outputDirectory, componentName, 'src/config/i18n.ts'),
            content: this.generateFrontendConfig(i18n),
        });
        // Generate translation hook
        files.push({
            path: path.join(outputDirectory, componentName, 'src/hooks/useTranslation.ts'),
            content: this.generateTranslationHook(i18n),
        });
        // Generate locale switcher component
        files.push({
            path: path.join(outputDirectory, componentName, 'src/components/LocaleSwitcher.tsx'),
            content: this.generateLocaleSwitcher(i18n),
        });
        // Generate formatting utilities
        files.push({
            path: path.join(outputDirectory, componentName, 'src/utils/formatting.ts'),
            content: this.generateFormattingUtils(i18n),
        });
        // Generate type-safe translation keys
        files.push({
            path: path.join(outputDirectory, componentName, 'src/types/translations.ts'),
            content: this.generateTranslationTypes(i18n),
        });
        return files;
    }
    generateBackendI18n(componentName, i18n, outputDirectory) {
        const files = [];
        // Generate backend i18n configuration
        files.push({
            path: path.join(outputDirectory, componentName, 'src/config/i18n.ts'),
            content: this.generateBackendConfig(i18n),
        });
        // Generate locale detection middleware
        files.push({
            path: path.join(outputDirectory, componentName, 'src/middleware/locale-detection.ts'),
            content: this.generateLocaleDetectionMiddleware(i18n),
        });
        // Generate translation utilities
        files.push({
            path: path.join(outputDirectory, componentName, 'src/utils/translations.ts'),
            content: this.generateBackendTranslationUtils(i18n),
        });
        return files;
    }
    generateTranslationFiles(i18n, outputDirectory, frontendComponent) {
        const files = [];
        const translationsDir = frontendComponent
            ? path.join(outputDirectory, frontendComponent, 'public/locales')
            : path.join(outputDirectory, 'locales');
        // Generate translation files for each locale
        for (const locale of i18n.supported_locales) {
            files.push({
                path: path.join(translationsDir, locale, 'common.json'),
                content: this.generateCommonTranslations(locale, i18n.default_locale),
            });
            files.push({
                path: path.join(translationsDir, locale, 'errors.json'),
                content: this.generateErrorTranslations(locale, i18n.default_locale),
            });
            files.push({
                path: path.join(translationsDir, locale, 'validation.json'),
                content: this.generateValidationTranslations(locale, i18n.default_locale),
            });
        }
        return files;
    }
    generateTranslationSync(i18n, outputDirectory, backendComponent) {
        const baseDir = backendComponent
            ? path.join(outputDirectory, backendComponent)
            : outputDirectory;
        return {
            path: path.join(baseDir, 'scripts/sync-translations.ts'),
            content: this.generateSyncScript(i18n),
        };
    }
    generateFrontendConfig(i18n) {
        const fallbackStrategy = i18n.fallback_strategy || 'default';
        return `/**
 * Frontend i18n Configuration
 * Generated by Bangstack
 */

import i18next from 'i18next';
import { initReactI18next } from 'react-i18next';
import LanguageDetector from 'i18next-browser-languagedetector';
import Backend from 'i18next-http-backend';

export const defaultLocale = '${i18n.default_locale}';
export const supportedLocales = ${JSON.stringify(i18n.supported_locales, null, 2)};

export const i18nConfig = {
  fallbackLng: ${fallbackStrategy === 'cascade' ? `supportedLocales` : `'${i18n.default_locale}'`},
  supportedLngs: supportedLocales,
  defaultNS: 'common',
  ns: ['common', 'errors', 'validation'],

  interpolation: {
    escapeValue: false, // React already escapes
  },

  backend: {
    loadPath: '/locales/{{lng}}/{{ns}}.json',
  },

  detection: {
    order: ['querystring', 'cookie', 'localStorage', 'navigator', 'htmlTag'],
    caches: ['localStorage', 'cookie'],
    lookupQuerystring: 'lang',
    lookupCookie: 'i18next',
    lookupLocalStorage: 'i18nextLng',
  },

  react: {
    useSuspense: true,
  },
};

// Initialize i18next
i18next
  .use(Backend)
  .use(LanguageDetector)
  .use(initReactI18next)
  .init(i18nConfig);

export default i18next;
`;
    }
    generateTranslationHook(i18n) {
        return `/**
 * Type-safe translation hook
 * Generated by Bangstack
 */

import { useTranslation as useI18nextTranslation } from 'react-i18next';
import { TranslationKeys } from '../types/translations';

export function useTranslation(namespace: string = 'common') {
  const { t, i18n } = useI18nextTranslation(namespace);

  return {
    t: (key: TranslationKeys, params?: Record<string, any>) => t(key, params),
    locale: i18n.language,
    changeLocale: (locale: string) => i18n.changeLanguage(locale),
    supportedLocales: ${JSON.stringify(i18n.supported_locales)},
    defaultLocale: '${i18n.default_locale}',
  };
}

export function useFormattedDate() {
  const { locale } = useTranslation();

  return {
    formatDate: (date: Date | string, options?: Intl.DateTimeFormatOptions) => {
      const dateObj = typeof date === 'string' ? new Date(date) : date;
      ${this.generateDateFormatting(i18n)}
    },
    formatRelative: (date: Date | string) => {
      const dateObj = typeof date === 'string' ? new Date(date) : date;
      const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
      const diff = dateObj.getTime() - Date.now();
      const days = Math.round(diff / (1000 * 60 * 60 * 24));

      if (Math.abs(days) < 1) {
        const hours = Math.round(diff / (1000 * 60 * 60));
        return rtf.format(hours, 'hour');
      }

      return rtf.format(days, 'day');
    },
  };
}

export function useFormattedNumber() {
  const { locale } = useTranslation();

  return {
    formatNumber: (value: number, options?: Intl.NumberFormatOptions) => {
      ${this.generateNumberFormatting(i18n)}
    },
    formatCurrency: (value: number, currency: string = 'USD') => {
      ${this.generateCurrencyFormatting(i18n)}
    },
    formatPercent: (value: number) => {
      return new Intl.NumberFormat(locale, {
        style: 'percent',
        minimumFractionDigits: 0,
        maximumFractionDigits: 2,
      }).format(value);
    },
  };
}
`;
    }
    generateDateFormatting(i18n) {
        if (i18n.formatting?.dates === 'iso') {
            return `return dateObj.toISOString().split('T')[0];`;
        }
        return `return new Intl.DateTimeFormat(locale, options).format(dateObj);`;
    }
    generateNumberFormatting(i18n) {
        if (i18n.formatting?.numbers === 'standard') {
            return `return value.toString();`;
        }
        return `return new Intl.NumberFormat(locale, options).format(value);`;
    }
    generateCurrencyFormatting(i18n) {
        if (i18n.formatting?.currency === 'usd') {
            return `return new Intl.NumberFormat('en-US', { style: 'currency', currency: 'USD' }).format(value);`;
        }
        return `return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(value);`;
    }
    generateLocaleSwitcher(i18n) {
        return `/**
 * Locale Switcher Component
 * Generated by Bangstack
 */

import React from 'react';
import { useTranslation } from '../hooks/useTranslation';

export interface LocaleSwitcherProps {
  className?: string;
}

const localeNames: Record<string, string> = {
${i18n.supported_locales.map(locale => `  '${locale}': '${this.getLocaleName(locale)}',`).join('\n')}
};

export const LocaleSwitcher: React.FC<LocaleSwitcherProps> = ({ className }) => {
  const { locale, changeLocale, supportedLocales } = useTranslation();

  return (
    <div className={className}>
      <label htmlFor="locale-select">Language:</label>
      <select
        id="locale-select"
        value={locale}
        onChange={(e) => changeLocale(e.target.value)}
        aria-label="Select language"
      >
        {supportedLocales.map((loc) => (
          <option key={loc} value={loc}>
            {localeNames[loc] || loc}
          </option>
        ))}
      </select>
    </div>
  );
};
`;
    }
    generateFormattingUtils(i18n) {
        return `/**
 * Formatting Utilities
 * Generated by Bangstack
 */

/**
 * Format date according to locale
 */
export function formatDate(
  date: Date | string,
  locale: string = '${i18n.default_locale}',
  options?: Intl.DateTimeFormatOptions
): string {
  const dateObj = typeof date === 'string' ? new Date(date) : date;
  ${this.generateDateFormatting(i18n)}
}

/**
 * Format number according to locale
 */
export function formatNumber(
  value: number,
  locale: string = '${i18n.default_locale}',
  options?: Intl.NumberFormatOptions
): string {
  ${this.generateNumberFormatting(i18n)}
}

/**
 * Format currency according to locale
 */
export function formatCurrency(
  value: number,
  currency: string = 'USD',
  locale: string = '${i18n.default_locale}'
): string {
  ${this.generateCurrencyFormatting(i18n)}
}

/**
 * Format file size
 */
export function formatFileSize(bytes: number, locale: string = '${i18n.default_locale}'): string {
  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
  let size = bytes;
  let unitIndex = 0;

  while (size >= 1024 && unitIndex < units.length - 1) {
    size /= 1024;
    unitIndex++;
  }

  return \`\${formatNumber(size, locale, { maximumFractionDigits: 2 })} \${units[unitIndex]}\`;
}
`;
    }
    generateTranslationTypes(_i18n) {
        return `/**
 * Type-safe translation keys
 * Generated by Bangstack
 */

// Common translation keys
export type CommonTranslationKeys =
  | 'welcome'
  | 'loading'
  | 'error'
  | 'success'
  | 'cancel'
  | 'save'
  | 'delete'
  | 'edit'
  | 'close';

// Error translation keys
export type ErrorTranslationKeys =
  | 'general_error'
  | 'network_error'
  | 'not_found'
  | 'unauthorized'
  | 'forbidden';

// Validation translation keys
export type ValidationTranslationKeys =
  | 'required'
  | 'invalid_email'
  | 'invalid_format'
  | 'too_short'
  | 'too_long';

export type TranslationKeys =
  | CommonTranslationKeys
  | ErrorTranslationKeys
  | ValidationTranslationKeys
  | string;
`;
    }
    generateBackendConfig(i18n) {
        return `/**
 * Backend i18n Configuration
 * Generated by Bangstack
 */

import i18next from 'i18next';
import Backend from 'i18next-fs-backend';
import { join } from 'path';

export const defaultLocale = '${i18n.default_locale}';
export const supportedLocales = ${JSON.stringify(i18n.supported_locales, null, 2)};

i18next.use(Backend).init({
  lng: defaultLocale,
  fallbackLng: '${i18n.default_locale}',
  supportedLngs: supportedLocales,
  preload: supportedLocales,

  ns: ['common', 'errors', 'validation'],
  defaultNS: 'common',

  backend: {
    loadPath: join(__dirname, '../../locales/{{lng}}/{{ns}}.json'),
  },

  interpolation: {
    escapeValue: false,
  },
});

export default i18next;
`;
    }
    generateLocaleDetectionMiddleware(i18n) {
        return `/**
 * Locale Detection Middleware
 * Generated by Bangstack
 */

import { Request, Response, NextFunction } from 'express';

const supportedLocales = ${JSON.stringify(i18n.supported_locales)};
const defaultLocale = '${i18n.default_locale}';

export function localeDetection(req: Request, res: Response, next: NextFunction) {
  // Try to detect locale from various sources
  let locale = defaultLocale;

  // 1. Query parameter (highest priority)
  if (req.query.lang && typeof req.query.lang === 'string') {
    locale = req.query.lang;
  }
  // 2. Cookie
  else if (req.cookies?.locale) {
    locale = req.cookies.locale;
  }
  // 3. Accept-Language header
  else if (req.headers['accept-language']) {
    const acceptedLanguages = req.headers['accept-language']
      .split(',')
      .map(lang => lang.split(';')[0].trim());

    locale = acceptedLanguages.find(lang => supportedLocales.includes(lang)) || defaultLocale;
  }

  // Validate locale
  if (!supportedLocales.includes(locale)) {
    locale = defaultLocale;
  }

  // Attach locale to request
  (req as any).locale = locale;

  // Set locale cookie
  res.cookie('locale', locale, {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'lax',
    maxAge: 365 * 24 * 60 * 60 * 1000, // 1 year
  });

  next();
}
`;
    }
    generateBackendTranslationUtils(i18n) {
        return `/**
 * Backend Translation Utilities
 * Generated by Bangstack
 */

import i18next from '../config/i18n';

export function translate(key: string, locale?: string, params?: Record<string, any>): string {
  const lng = locale || '${i18n.default_locale}';
  return i18next.t(key, { lng, ...params });
}

export function translateError(errorKey: string, locale?: string): string {
  return translate(\`errors:\${errorKey}\`, locale);
}

export function translateValidation(validationKey: string, locale?: string, params?: Record<string, any>): string {
  return translate(\`validation:\${validationKey}\`, locale, params);
}

/**
 * Translate email templates
 */
export function translateEmail(
  templateKey: string,
  locale: string,
  params: Record<string, any>
): { subject: string; body: string } {
  return {
    subject: translate(\`emails:\${templateKey}.subject\`, locale, params),
    body: translate(\`emails:\${templateKey}.body\`, locale, params),
  };
}
`;
    }
    generateCommonTranslations(locale, defaultLocale) {
        const isDefault = locale === defaultLocale;
        if (isDefault) {
            return JSON.stringify({
                welcome: 'Welcome',
                loading: 'Loading...',
                error: 'Error',
                success: 'Success',
                cancel: 'Cancel',
                save: 'Save',
                delete: 'Delete',
                edit: 'Edit',
                close: 'Close',
                submit: 'Submit',
                back: 'Back',
                next: 'Next',
                previous: 'Previous',
                search: 'Search',
                filter: 'Filter',
                sort: 'Sort',
            }, null, 2);
        }
        // For non-default locales, provide placeholder structure
        return JSON.stringify({
            welcome: `[${locale}] Welcome`,
            loading: `[${locale}] Loading...`,
            error: `[${locale}] Error`,
            success: `[${locale}] Success`,
            cancel: `[${locale}] Cancel`,
            save: `[${locale}] Save`,
            delete: `[${locale}] Delete`,
            edit: `[${locale}] Edit`,
            close: `[${locale}] Close`,
            submit: `[${locale}] Submit`,
            back: `[${locale}] Back`,
            next: `[${locale}] Next`,
            previous: `[${locale}] Previous`,
            search: `[${locale}] Search`,
            filter: `[${locale}] Filter`,
            sort: `[${locale}] Sort`,
        }, null, 2);
    }
    generateErrorTranslations(locale, defaultLocale) {
        const isDefault = locale === defaultLocale;
        if (isDefault) {
            return JSON.stringify({
                general_error: 'An error occurred. Please try again.',
                network_error: 'Network error. Please check your connection.',
                not_found: 'Resource not found.',
                unauthorized: 'You are not authorized to perform this action.',
                forbidden: 'Access forbidden.',
                server_error: 'Internal server error.',
                timeout: 'Request timed out.',
            }, null, 2);
        }
        return JSON.stringify({
            general_error: `[${locale}] An error occurred. Please try again.`,
            network_error: `[${locale}] Network error. Please check your connection.`,
            not_found: `[${locale}] Resource not found.`,
            unauthorized: `[${locale}] You are not authorized to perform this action.`,
            forbidden: `[${locale}] Access forbidden.`,
            server_error: `[${locale}] Internal server error.`,
            timeout: `[${locale}] Request timed out.`,
        }, null, 2);
    }
    generateValidationTranslations(locale, defaultLocale) {
        const isDefault = locale === defaultLocale;
        if (isDefault) {
            return JSON.stringify({
                required: 'This field is required.',
                invalid_email: 'Please enter a valid email address.',
                invalid_format: 'Invalid format.',
                too_short: 'Value is too short.',
                too_long: 'Value is too long.',
                min_length: 'Minimum length is {{min}} characters.',
                max_length: 'Maximum length is {{max}} characters.',
                must_match: 'Fields must match.',
            }, null, 2);
        }
        return JSON.stringify({
            required: `[${locale}] This field is required.`,
            invalid_email: `[${locale}] Please enter a valid email address.`,
            invalid_format: `[${locale}] Invalid format.`,
            too_short: `[${locale}] Value is too short.`,
            too_long: `[${locale}] Value is too long.`,
            min_length: `[${locale}] Minimum length is {{min}} characters.`,
            max_length: `[${locale}] Maximum length is {{max}} characters.`,
            must_match: `[${locale}] Fields must match.`,
        }, null, 2);
    }
    generateSyncScript(i18n) {
        const provider = i18n.translation_management?.provider || 'lokalise';
        return `/**
 * Translation Sync Script
 * Syncs translations with ${provider}
 * Generated by Bangstack
 */

${this.generateProviderImports(provider)}

const PROJECT_ID = process.env.${provider.toUpperCase()}_PROJECT_ID;
const API_KEY = process.env.${provider.toUpperCase()}_API_KEY;

${this.generateSyncFunction(provider, i18n)}

// Run sync if executed directly
if (require.main === module) {
  syncTranslations()
    .then(() => {
      console.log('✅ Translations synced successfully');
      process.exit(0);
    })
    .catch((error) => {
      console.error('❌ Translation sync failed:', error);
      process.exit(1);
    });
}
`;
    }
    generateProviderImports(provider) {
        switch (provider) {
            case 'lokalise':
                return `import { LokaliseApi } from '@lokalise/node-api';
import * as fs from 'fs';
import * as path from 'path';`;
            case 'crowdin':
                return `import crowdin from '@crowdin/crowdin-api-client';
import * as fs from 'fs';
import * as path from 'path';`;
            case 'phrase':
                return `import * as fs from 'fs';
import * as path from 'path';
import fetch from 'node-fetch';`;
            default:
                return `import * as fs from 'fs';
import * as path from 'path';`;
        }
    }
    generateSyncFunction(provider, i18n) {
        switch (provider) {
            case 'lokalise':
                return `async function syncTranslations() {
  const lokalise = new LokaliseApi({ apiKey: API_KEY! });
  const localesDir = path.join(__dirname, '../public/locales');

  for (const locale of ${JSON.stringify(i18n.supported_locales)}) {
    console.log(\`Downloading translations for \${locale}...\`);

    const { files } = await lokalise.files().download(PROJECT_ID!, {
      format: 'json',
      original_filenames: false,
      filter_langs: [locale],
    });

    // Save translation files
    const localeDir = path.join(localesDir, locale);
    if (!fs.existsSync(localeDir)) {
      fs.mkdirSync(localeDir, { recursive: true });
    }

    // Process downloaded files
    for (const file of files) {
      const filename = file.filename;
      const content = file.content;
      fs.writeFileSync(path.join(localeDir, filename), content);
      console.log(\`  ✓ \${filename}\`);
    }
  }
}`;
            case 'crowdin':
                return `async function syncTranslations() {
  const { translationsApi } = new crowdin.default({
    token: API_KEY!,
  });

  const localesDir = path.join(__dirname, '../public/locales');

  for (const locale of ${JSON.stringify(i18n.supported_locales)}) {
    console.log(\`Downloading translations for \${locale}...\`);

    const downloadLink = await translationsApi.buildProjectTranslation(
      parseInt(PROJECT_ID!),
      { targetLanguageId: locale }
    );

    // Download and extract translations
    const response = await fetch(downloadLink.data.url);
    const content = await response.text();

    const localeDir = path.join(localesDir, locale);
    if (!fs.existsSync(localeDir)) {
      fs.mkdirSync(localeDir, { recursive: true });
    }

    fs.writeFileSync(path.join(localeDir, 'common.json'), content);
    console.log(\`  ✓ common.json\`);
  }
}`;
            case 'phrase':
                return `async function syncTranslations() {
  const baseUrl = 'https://api.phrase.com/v2';
  const headers = {
    'Authorization': \`token \${API_KEY}\`,
    'Content-Type': 'application/json',
  };

  const localesDir = path.join(__dirname, '../public/locales');

  for (const locale of ${JSON.stringify(i18n.supported_locales)}) {
    console.log(\`Downloading translations for \${locale}...\`);

    const response = await fetch(
      \`\${baseUrl}/projects/\${PROJECT_ID}/locales/\${locale}/download\`,
      { headers }
    );

    const content = await response.json();

    const localeDir = path.join(localesDir, locale);
    if (!fs.existsSync(localeDir)) {
      fs.mkdirSync(localeDir, { recursive: true });
    }

    fs.writeFileSync(
      path.join(localeDir, 'common.json'),
      JSON.stringify(content, null, 2)
    );
    console.log(\`  ✓ common.json\`);
  }
}`;
            default:
                return `async function syncTranslations() {
  console.log('Custom translation sync not implemented');
  // Implement custom sync logic here
}`;
        }
    }
    getLocaleName(locale) {
        const localeNames = {
            'en': 'English',
            'en-US': 'English (US)',
            'en-GB': 'English (UK)',
            'es': 'Español',
            'es-MX': 'Español (México)',
            'fr': 'Français',
            'de': 'Deutsch',
            'it': 'Italiano',
            'pt': 'Português',
            'pt-BR': 'Português (Brasil)',
            'ja': '日本語',
            'ko': '한국어',
            'zh': '中文',
            'zh-CN': '中文 (简体)',
            'zh-TW': '中文 (繁體)',
            'ar': 'العربية',
            'ru': 'Русский',
            'hi': 'हिन्दी',
        };
        return localeNames[locale] || locale;
    }
}
exports.EnhancedI18nGenerator = EnhancedI18nGenerator;
//# sourceMappingURL=enhanced-i18n-generator.js.map