@translated/lara/lib/translator.d.ts

Official Lara SDK for JavaScript and Node.js

import { AudioTranslator } from "./audioTranslator";
import type { AccessKey, AuthToken } from "./credentials";
import { Documents } from "./documents";
import { Glossaries } from "./glossaries";
import { ImageTranslator } from "./imageTranslator";
import { Memories } from "./memories";
import { type LaraClient } from "./net/lara";
import { Styleguides } from "./styleguides";
export type TranslatorOptions = {
    serverUrl?: string;
    connectionTimeoutMs?: number;
    keepAlive?: boolean;
    sessionId?: string;
};
export interface NGMemoryMatch {
    memory: string;
    tuid?: string;
    language: [string, string];
    sentence: string;
    translation: string;
    score: number;
}
export interface NGGlossaryMatch {
    glossary: string;
    language: [string, string];
    term: string;
    translation: string;
}
export interface ProfanityDetectResult {
    maskedText: string;
    profanities: {
        text: string;
        startCharIndex: number;
        endCharIndex: number;
        score: number;
    }[];
    error?: string;
}
export interface ProfanitiesResult {
    target: ProfanityDetectResult | ProfanityDetectResult[];
    source?: ProfanityDetectResult | ProfanityDetectResult[];
}
export interface TextBlock {
    readonly text: string;
    readonly translatable?: boolean;
}
export type StyleguideChange = {
    id?: string;
    originalTranslation: string;
    refinedTranslation: string;
    explanation: string;
};
export type StyleguideResults<T extends string | string[] | TextBlock[]> = {
    originalTranslation: T;
    changes: StyleguideChange[];
};
export type ImageContext = {
    /** HTTPS URL or base64 data URL containing a PNG, JPEG or WebP image. */
    url: string;
};
export type IntelligenceFailure = {
    applied: false;
    error: {
        statusCode: number;
        message: string;
    };
};
export type ReferenceRetrievalFailure = {
    applied: false | "partial";
    error: IntelligenceFailure["error"];
};
export type ReasoningWarning = {
    code: "image_context_unavailable";
    message: string;
};
export type ReasoningFeedback = (IntelligenceFailure | {
    applied: true;
}) & {
    warnings?: ReasoningWarning[];
};
export interface TextResult<T extends string | string[] | TextBlock[]> {
    readonly contentType: string;
    readonly sourceLanguage: string;
    readonly translation: T;
    readonly adaptedTo?: string[];
    readonly glossaries?: string[];
    readonly adaptedToMatches?: NGMemoryMatch[] | NGMemoryMatch[][];
    readonly glossariesMatches?: NGGlossaryMatch[] | NGGlossaryMatch[][];
    readonly profanities?: ProfanitiesResult;
    readonly styleguideResults?: StyleguideResults<T>;
    readonly warnings?: {
        /** Reasoning failed or completed without the requested image context. */
        reasoning?: ReasoningFeedback;
        references?: ReferenceRetrievalFailure;
        prosa?: IntelligenceFailure;
    };
}
export type ReasoningEffort = "low" | "medium" | "high";
export type TranslateOptions = {
    sourceHint?: string;
    adaptTo?: string[];
    instructions?: string[];
    glossaries?: string[];
    contentType?: string;
    /** @deprecated This parameter is deprecated. */
    multiline?: boolean;
    timeoutInMillis?: number;
    priority?: "normal" | "background";
    useCache?: boolean | "overwrite";
    cacheTTLSeconds?: number;
    noTrace?: boolean;
    verbose?: boolean;
    headers?: Record<string, string>;
    style?: TranslationStyle;
    reasoning?: boolean;
    /** Requires reasoning: true. Omit to use the server default. */
    reasoningEffort?: ReasoningEffort;
    /**
     * Visual context for text translation: one image, supplied as an object or array.
     * Requires reasoning: true when non-empty. Inline images are limited
     * to 5 MiB of decoded data. Omit or pass [] for text-only translation.
     */
    imageContext?: ImageContext | ImageContext[];
    metadata?: string | Record<string, unknown>;
    profanitiesDetect?: ProfanitiesDetect;
    profanitiesHandling?: ProfanitiesHandling;
    styleguideId?: string;
    styleguideReasoning?: boolean;
    styleguideExplanationLanguage?: string;
};
export type TranslationStyle = "faithful" | "fluid" | "creative";
export type ProfanitiesDetect = "target" | "source_target";
export type ProfanitiesHandling = "hide" | "avoid" | "detect";
export interface QualityEstimationResult {
    score: number;
}
export interface DetectResult {
    language: string;
    contentType: string;
    predictions: {
        language: string;
        confidence: number;
    }[];
}
export declare class Translator {
    protected readonly client: LaraClient;
    readonly memories: Memories;
    readonly documents: Documents;
    readonly glossaries: Glossaries;
    readonly styleguides: Styleguides;
    readonly audio: AudioTranslator;
    readonly images: ImageTranslator;
    constructor(auth: AccessKey | AuthToken, options?: TranslatorOptions);
    get version(): string;
    getLanguages(): Promise<string[]>;
    translate<T extends string | string[] | TextBlock[]>(text: T, source: string | null, target: string, options?: TranslateOptions, callback?: (partialResult: TextResult<T>) => void): Promise<TextResult<T>>;
    detect(text: string | string[], hint?: string, passlist?: string[]): Promise<DetectResult>;
    detectProfanities(text: string, language: string, contentType: string): Promise<ProfanityDetectResult>;
    qualityEstimation(source: string, target: string, sentence: string | string[], translation: string | string[]): Promise<QualityEstimationResult | QualityEstimationResult[]>;
    static getLoginUrl(serverUrl?: string): Promise<string>;
}