i18n-llm-translate/type.d.ts

Automatically translates namespace-based JSON translation files across multiple languages from any source language

import { TranslateLogger } from "./logger";
import { EstimateEngineInitializeResult, EstimatePriceResult, EstimateUsage } from "./engines/estimate/type";
export type TranslateOptionsNamesMappingLanguagesCallback = (languageCode: string, options: TranslateOptions) => string;
/**
 * Parameters: {language}
 * Default value: {language}
 */
export type TranslateOptionsNamesMappingLanguagesBasicConfig = {
    base?: string;
    targets?: string;
};
export type TranslateOptionsNamesMappingLanguages = TranslateOptionsNamesMappingLanguagesCallback | TranslateOptionsNamesMappingLanguagesBasicConfig;
export interface TranslateOptionsNamesMapping {
    languages?: TranslateOptionsNamesMappingLanguages;
    /**
     * Default: .translations-cache
     */
    jsonCache?: string;
}
export interface TranslateOptions {
    languagesDirectoryPath: string;
    baseLanguageCode: string;
    targetLanguageCodes: string[];
    namesMapping?: TranslateOptionsNamesMapping;
    applicationContextEntries: string[];
    /**
     * Default: 3
     */
    maxRetriesOnEngineValidationError?: number;
    /**
     * Default: llm-only
     */
    retryOnEngineValidationErrorFor?: 'all' | 'llm-only' | 'none';
    cleanup?: boolean;
    debug?: boolean;
    verbose?: boolean;
    logger?: TranslateLogger;
    /**
     * When true, translate() logs BreakSilentError.originalError with logger.error.
     */
    verboseEngineErrors?: boolean;
}
export interface TranslateEngineTranslateResult {
    [key: string]: Record<string, any>;
}
export interface TranslateEngine {
    name: string;
    type: 'llm' | 'ml' | 'other';
    canBeTrustedWithVariablesTranslation: boolean;
    translate(translations: Record<string, any>, options: TranslateOptions): Promise<TranslateEngineTranslateResult>;
    translateMissed(missingTranslations: TranslateNamespaceMissingTranslations, options: TranslateOptions): Promise<TranslateEngineTranslateResult>;
    initializeEstimate?(options: TranslateOptions): Promise<EstimateEngineInitializeResult>;
    estimatePrice?(usage: EstimateUsage): string | EstimatePriceResult | undefined;
    getUsage?(): EstimateUsage;
}
export interface TranslationsByLanguage {
    [languageCode: string]: Record<string, any>;
}
export interface TranslateNamespaceMissingTranslations {
    /**
     * Only these which are missed in target languages
     */
    baseLanguageTranslations: Record<string, any>;
    targetLanguageTranslationsKeys: TranslationsByLanguage;
}
export interface TranslateNamespace {
    jsonFileName: string;
    baseLanguageTranslations: Record<string, any>;
    targetLanguages: {
        dirty: boolean;
        languageCode: string;
        translations: Record<string, any>;
    }[];
    write(): Promise<void>;
    getMissingTranslations(): TranslateNamespaceMissingTranslations | undefined;
}