@translated/lara 1.6.5 → 2.0.0-beta.0

package/README.md

@@ -1,7 +1,365 @@
-# Lara Node.js Library
+# Lara Node.js SDK
+
+[![Node Version](https://img.shields.io/badge/node-12+-blue.svg)](https://nodejs.org)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
 
 This SDK empowers you to build your own branded translation AI leveraging our translation fine-tuned language model. 
 
 All major translation features are accessible, making it easy to integrate and customize for your needs. 
 
-Lara’s SDK full documentation is available at https://developers.laratranslate.com/
+## 🌍 **Features:**
+- **Text Translation**: Single strings, multiple strings, and complex text blocks
+- **Document Translation**: Word, PDF, and other document formats with status monitoring
+- **Translation Memory**: Store and reuse translations for consistency
+- **Glossaries**: Enforce terminology standards across translations
+- **Language Detection**: Automatic source language identification
+- **Advanced Options**: Translation instructions and more
+
+## 📚 Documentation
+
+Lara's SDK full documentation is available at [https://developers.laratranslate.com/](https://developers.laratranslate.com/)
+
+## 🚀 Quick Start
+
+### Installation
+
+```bash
+npm install @translated/lara
+```
+
+### Basic Usage
+
+```javascript
+const { Credentials, Translator } = require('@translated/lara');
+
+// Set your credentials using environment variables (recommended)
+const credentials = new Credentials(
+    process.env.LARA_ACCESS_KEY_ID,
+    process.env.LARA_ACCESS_KEY_SECRET
+);
+
+// Create translator instance
+const lara = new Translator(credentials);
+
+// Simple text translation
+async function translateText() {
+    try {
+        const result = await lara.translate("Hello, world!", "en-US", "fr-FR");
+        console.log("Translation: " + result.translation);
+        // Output: Translation: Bonjour, le monde !
+    } catch (error) {
+        console.error("Translation error:", error.message);
+    }
+}
+
+translateText();
+```
+
+## 📖 Examples
+
+The `examples/` directory contains comprehensive examples for all SDK features.
+
+**All examples use environment variables for credentials, so set them first:**
+```bash
+export LARA_ACCESS_KEY_ID="your-access-key-id"
+export LARA_ACCESS_KEY_SECRET="your-access-key-secret"
+```
+
+### Text Translation
+- **[text_translation.js](examples/text_translation.js)** - Complete text translation examples
+  - Single string translation
+  - Multiple strings translation  
+  - Translation with instructions
+  - TextBlocks translation (mixed translatable/non-translatable content)
+  - Auto-detect source language
+  - Advanced translation options
+  - Get available languages
+
+```bash
+cd examples
+node text_translation.js
+```
+
+### Document Translation
+- **[document_translation.js](examples/document_translation.js)** - Document translation examples
+  - Basic document translation
+  - Advanced options with memories and glossaries
+  - Step-by-step translation with status monitoring
+
+```bash
+cd examples
+node document_translation.js
+```
+
+### Translation Memory Management
+- **[memories_management.js](examples/memories_management.js)** - Memory management examples
+  - Create, list, update, delete memories
+  - Add individual translations
+  - Multiple memory operations
+  - TMX file import with progress monitoring
+  - Translation deletion
+  - Translation with TUID and context
+
+```bash
+cd examples
+node memories_management.js
+```
+
+### Glossary Management
+- **[glossaries_management.js](examples/glossaries_management.js)** - Glossary management examples
+  - Create, list, update, delete glossaries
+  - CSV import with status monitoring
+  - Glossary export
+  - Glossary terms count
+  - Import status checking
+
+```bash
+cd examples
+node glossaries_management.js
+```
+
+## 🔧 API Reference
+
+### Core Components
+
+### 🔐 Authentication
+
+The SDK supports authentication via access key and secret:
+
+```javascript
+const credentials = new Credentials("your-access-key-id", "your-access-key-secret");
+const lara = new Translator(credentials);
+```
+
+**Environment Variables (Recommended):**
+```bash
+export LARA_ACCESS_KEY_ID="your-access-key-id"
+export LARA_ACCESS_KEY_SECRET="your-access-key-secret"
+```
+
+```javascript
+const credentials = new Credentials(
+    process.env.LARA_ACCESS_KEY_ID,
+    process.env.LARA_ACCESS_KEY_SECRET
+);
+```
+
+
+### 🌍 Translator
+
+```javascript
+// Create translator with credentials
+const lara = new Translator(credentials);
+```
+
+#### Text Translation
+
+```javascript
+// Basic translation
+const result = await lara.translate("Hello", "en-US", "fr-FR");
+
+// Multiple strings
+const result = await lara.translate(["Hello", "World"], "en-US", "fr-FR");
+
+// TextBlocks (mixed translatable/non-translatable content)
+const textBlocks = [
+    { text: "Translatable text", translatable: true },
+    { text: "<br>", translatable: false },  // Non-translatable HTML
+    { text: "More translatable text", translatable: true }
+];
+const result = await lara.translate(textBlocks, "en-US", "fr-FR");
+
+// With advanced options
+const options = {
+    instructions: ["Formal tone"],
+    adaptTo: ["mem_1A2b3C4d5E6f7G8h9I0jKl"],  // Replace with actual memory IDs
+    glossaries: ["gls_1A2b3C4d5E6f7G8h9I0jKl"],  // Replace with actual glossary IDs
+    style: "fluid",
+    timeoutInMillis: 10000
+};
+
+const result = await lara.translate("Hello", "en-US", "fr-FR", options);
+```
+
+### 📖 Document Translation
+#### Simple document translation
+
+```javascript
+const fs = require('fs');
+
+const fileStream = fs.createReadStream("/path/to/your/document.txt");  // Replace with actual file path
+const translatedContent = await lara.documents.translate(fileStream, "document.txt", "en-US", "fr-FR");
+
+// With options
+const options = {
+    adaptTo: ["mem_1A2b3C4d5E6f7G8h9I0jKl"],  // Replace with actual memory IDs
+    glossaries: ["gls_1A2b3C4d5E6f7G8h9I0jKl"],  // Replace with actual glossary IDs
+    style: "fluid"
+};
+
+const translatedContent = await lara.documents.translate(fileStream, "document.txt", "en-US", "fr-FR", options);
+```
+### Document translation with status monitoring
+#### Document upload
+```javascript
+//Optional: upload options
+const uploadOptions = {
+    adaptTo: ["mem_1A2b3C4d5E6f7G8h9I0jKl"],  // Replace with actual memory IDs
+    glossaries: ["gls_1A2b3C4d5E6f7G8h9I0jKl"]  // Replace with actual glossary IDs
+};
+
+const document = await lara.documents.upload(fileStream, "document.txt", "en-US", "fr-FR", uploadOptions);
+```
+#### Document translation status monitoring
+```javascript
+const status = await lara.documents.status(document.id);
+```
+#### Download translated document
+```javascript
+const translatedContent = await lara.documents.download(document.id);
+```
+
+### 🧠 Memory Management
+
+```javascript
+// Create memory
+const memory = await lara.memories.create("MyMemory");
+
+// Create memory with external ID (MyMemory integration)
+const memory = await lara.memories.create("Memory from MyMemory", "aabb1122");  // Replace with actual external ID
+
+// Important: To update/overwrite a translation unit you must provide a tuid. Calls without a tuid always create a new unit and will not update existing entries.
+// Add translation to single memory
+const memoryImport = await lara.memories.addTranslation("mem_1A2b3C4d5E6f7G8h9I0jKl", "en-US", "fr-FR", "Hello", "Bonjour", "greeting_001");
+
+// Add translation to multiple memories
+const memoryImport = await lara.memories.addTranslation(["mem_1A2b3C4d5E6f7G8h9I0jKl", "mem_2XyZ9AbC8dEf7GhI6jKlMn"], "en-US", "fr-FR", "Hello", "Bonjour", "greeting_002");
+
+// Add with context
+const memoryImport = await lara.memories.addTranslation(
+    "mem_1A2b3C4d5E6f7G8h9I0jKl", "en-US", "fr-FR", "Hello", "Bonjour", "tuid", 
+    "sentenceBefore", "sentenceAfter"
+);
+
+// TMX import from file
+const tmxFileStream = fs.createReadStream("/path/to/your/memory.tmx");  // Replace with actual TMX file path
+const memoryImport = await lara.memories.importTmx("mem_1A2b3C4d5E6f7G8h9I0jKl", tmxFileStream);
+
+// Delete translation
+// Important: if you omit tuid, all entries that match the provided fields will be removed
+const deleteJob = await lara.memories.deleteTranslation(
+        "mem_1A2b3C4d5E6f7G8h9I0jKl", "en-US", "fr-FR", "Hello", "Bonjour", tuid="greeting_001"
+);
+
+// Wait for import completion
+const completedImport = await lara.memories.waitForImport(memoryImport, undefined, 300000); // 5 minutes
+```
+
+### 📚 Glossary Management
+
+```javascript
+// Create glossary
+const glossary = await lara.glossaries.create("MyGlossary");
+
+// Import CSV from file
+const csvFileStream = fs.createReadStream("/path/to/your/glossary.csv");  // Replace with actual CSV file path
+const glossaryImport = await lara.glossaries.importCsv("gls_1A2b3C4d5E6f7G8h9I0jKl", csvFileStream);
+
+// Check import status
+const importStatus = await lara.glossaries.getImportStatus("gls_1A2b3C4d5E6f7G8h9I0jKl");
+
+// Wait for import completion
+const completedImport = await lara.glossaries.waitForImport(glossaryImport, undefined, 300000); // 5 minutes
+
+// Export glossary
+const csvData = await lara.glossaries.export("gls_1A2b3C4d5E6f7G8h9I0jKl", "csv/table-uni", "en-US");
+
+// Get glossary terms count
+const counts = await lara.glossaries.counts("gls_1A2b3C4d5E6f7G8h9I0jKl");
+```
+
+### Translation Options
+
+```javascript
+const TranslateOptions = {
+    adaptTo: ["mem_1A2b3C4d5E6f7G8h9I0jKl"],              // Memory IDs to adapt to
+    glossaries: ["gls_1A2b3C4d5E6f7G8h9I0jKl"],           // Glossary IDs to use
+    instructions: ["instruction"],                        // Translation instructions
+    style: "fluid",                                       // Translation style (fluid, faithful, creative)
+    contentType: "text/plain",                            // Content type (text/plain, text/html, etc.)
+    multiline: true,                                      // Enable multiline translation
+    timeoutInMillis: 10000,                               // Request timeout in milliseconds
+    sourceHint: "en",                                     // Hint for source language detection
+    noTrace: false,                                       // Disable request tracing
+    verbose: false,                                       // Enable verbose response
+};
+```
+
+### Language Codes
+
+The SDK supports full language codes (e.g., `en-US`, `fr-FR`, `es-ES`) as well as simple codes (e.g., `en`, `fr`, `es`):
+
+```javascript
+// Full language codes (recommended)
+const result = await lara.translate("Hello", "en-US", "fr-FR");
+
+// Simple language codes
+const result = await lara.translate("Hello", "en", "fr");
+```
+
+### 🌐 Supported Languages
+
+The SDK supports all languages available in the Lara API. Use the `getLanguages()` method to get the current list:
+
+```javascript
+const languages = await lara.getLanguages();
+console.log("Supported languages: " + languages.join(', '));
+```
+
+## ⚙️ Configuration
+
+### Error Handling
+
+The SDK provides detailed error information:
+
+```javascript
+try {
+    const result = await lara.translate("Hello", "en-US", "fr-FR");
+    console.log("Translation: " + result.translation);
+} catch (error) {
+    if (error.constructor.name === 'LaraApiError') {
+        console.error("API Error [" + error.statusCode + "]: " + error.message);
+        console.error("Error type: " + error.type);
+    } else {
+        console.error("SDK Error: " + error.message);
+    }
+}
+```
+
+## 📋 Requirements
+
+- Node.js 12 or higher
+- npm or yarn
+- Valid Lara API credentials
+
+## 🧪 Testing
+
+Run the examples to test your setup:
+
+```bash
+# All examples use environment variables for credentials, so set them first:
+export LARA_ACCESS_KEY_ID="your-access-key-id"
+export LARA_ACCESS_KEY_SECRET="your-access-key-secret"
+```
+
+```bash
+# Run basic text translation example
+cd examples
+node text_translation.js
+```
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+Happy translating! 🌍✨

package/lib/Documents.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from 'axios';
+import { Document, DocumentDownloadOptions, DocumentTranslateOptions, DocumentUploadOptions, UploadableFile } from './models';
+export default class Documents {
+    private readonly client;
+    private readonly pollingInterval;
+    private readonly maxWaitTime;
+    constructor(client: AxiosInstance);
+    upload(file: UploadableFile, filenane: string, source: string | null, target: string, options?: DocumentUploadOptions): Promise<Document>;
+    status(id: string): Promise<Document>;
+    download(id: string, options?: DocumentDownloadOptions): Promise<Blob | Buffer>;
+    translate(file: UploadableFile, filenane: string, source: string | null, target: string, options?: DocumentTranslateOptions): Promise<Blob | Buffer>;
+}

package/lib/Documents.js

@@ -0,0 +1,71 @@
+import axios from 'axios';
+import { DocumentStatus, } from './models';
+import toFormData from './utils/formdata';
+import toSnakeCase from './utils/toSnakeCase';
+import sleep from './utils/sleep';
+import { LaraApiError, TimeoutError } from './utils/errors';
+export default class Documents {
+    constructor(client) {
+        this.pollingInterval = 2000;
+        this.maxWaitTime = 1000 * 60 * 15; // 15 minutes
+        this.client = client;
+    }
+    async upload(file, filenane, source, target, options) {
+        const { data: s3UploadUrlData } = await this.client.get(`/v2/documents/upload-url?filename=${encodeURIComponent(filenane)}`);
+        const { url, fields } = s3UploadUrlData;
+        const [formData, headers] = toFormData({
+            file,
+            ...fields,
+        });
+        await axios.post(url, formData, { headers });
+        const noTraceHeader = (options === null || options === void 0 ? void 0 : options.noTrace) ? { 'X-Lara-No-Trace': 'true' } : undefined;
+        const { data } = await this.client.post(`/v2/documents`, {
+            source,
+            target,
+            s3key: fields.key,
+            adapt_to: options === null || options === void 0 ? void 0 : options.adaptTo,
+            glossaries: options === null || options === void 0 ? void 0 : options.glossaries,
+            style: options === null || options === void 0 ? void 0 : options.style,
+            password: options === null || options === void 0 ? void 0 : options.password,
+            extraction_params: (options === null || options === void 0 ? void 0 : options.extractionParams) ? toSnakeCase(options.extractionParams) : undefined,
+        }, noTraceHeader ? { headers: noTraceHeader } : undefined);
+        return data;
+    }
+    async status(id) {
+        const { data } = await this.client.get(`/v2/documents/${id}`);
+        return data;
+    }
+    async download(id, options) {
+        const { data } = await this.client.get(`/v2/documents/${id}/download-url`, {
+            data: {
+                output_format: options === null || options === void 0 ? void 0 : options.outputFormat,
+            },
+        });
+        const { data: downloadedData } = await axios.get(data.url);
+        return downloadedData;
+    }
+    async translate(file, filenane, source, target, options) {
+        const uploadOptions = {
+            adaptTo: options === null || options === void 0 ? void 0 : options.adaptTo,
+            glossaries: options === null || options === void 0 ? void 0 : options.glossaries,
+            noTrace: options === null || options === void 0 ? void 0 : options.noTrace,
+            style: options === null || options === void 0 ? void 0 : options.style,
+            password: options === null || options === void 0 ? void 0 : options.password,
+            extractionParams: options === null || options === void 0 ? void 0 : options.extractionParams,
+        };
+        const { id } = await this.upload(file, filenane, source, target, uploadOptions);
+        const downloadOptions = {
+            outputFormat: options === null || options === void 0 ? void 0 : options.outputFormat,
+        };
+        const start = Date.now();
+        while (Date.now() - start < this.maxWaitTime) {
+            await sleep(this.pollingInterval);
+            const { status, errorReason } = await this.status(id);
+            if (status === DocumentStatus.TRANSLATED)
+                return await this.download(id, downloadOptions);
+            if (status === DocumentStatus.ERROR)
+                throw new LaraApiError(500, 'DocumentError', errorReason);
+        }
+        throw new TimeoutError();
+    }
+}

package/lib/Glossaries.d.ts

@@ -0,0 +1,17 @@
+import { AxiosInstance } from 'axios';
+import { Glossary, GlossaryCounts, GlossaryImport, UploadableFile } from './models';
+export default class Glossaries {
+    private readonly client;
+    private readonly pollingInterval;
+    constructor(client: AxiosInstance);
+    list(): Promise<Glossary[]>;
+    create(name: string): Promise<Glossary>;
+    get(id: string): Promise<Glossary>;
+    delete(id: string): Promise<Glossary>;
+    update(id: string, name: string): Promise<Glossary>;
+    importCsv(id: string, csv: UploadableFile, gzip?: boolean): Promise<GlossaryImport>;
+    getImportStatus(id: string): Promise<GlossaryImport>;
+    waitForImport(gImport: GlossaryImport, updateCallback?: (mImport: GlossaryImport) => void, maxWaitTime?: number): Promise<GlossaryImport>;
+    counts(id: string): Promise<GlossaryCounts>;
+    export(id: string, contentType: 'csv/table-uni', source?: string): Promise<string>;
+}

package/lib/Glossaries.js

@@ -0,0 +1,68 @@
+import { TimeoutError } from './utils/errors';
+import toFormData from './utils/formdata';
+import sleep from './utils/sleep';
+export default class Glossaries {
+    constructor(client) {
+        this.pollingInterval = 2000;
+        this.client = client;
+    }
+    async list() {
+        const { data } = await this.client.get('/v2/glossaries');
+        return data;
+    }
+    async create(name) {
+        const { data } = await this.client.post('/v2/glossaries', {
+            name,
+        });
+        return data;
+    }
+    async get(id) {
+        const { data } = await this.client.get(`/v2/glossaries/${id}`);
+        return data;
+    }
+    async delete(id) {
+        const { data } = await this.client.delete(`/v2/glossaries/${id}`);
+        return data;
+    }
+    async update(id, name) {
+        const { data } = await this.client.put(`/v2/glossaries/${id}`, { name });
+        return data;
+    }
+    async importCsv(id, csv, gzip = false) {
+        const [formData, headers] = toFormData({
+            csv,
+            compression: gzip ? 'gzip' : undefined,
+        });
+        const { data } = await this.client.post(`/v2/glossaries/${id}/import`, formData, { headers });
+        return data;
+    }
+    async getImportStatus(id) {
+        const { data } = await this.client.get(`/v2/glossaries/imports/${id}`);
+        return data;
+    }
+    async waitForImport(gImport, updateCallback, maxWaitTime) {
+        const start = Date.now();
+        while (gImport.progress < 1.0) {
+            if (maxWaitTime && Date.now() - start > maxWaitTime)
+                throw new TimeoutError();
+            await sleep(this.pollingInterval);
+            gImport = await this.getImportStatus(gImport.id);
+            updateCallback && updateCallback(gImport);
+        }
+        return gImport;
+    }
+    async counts(id) {
+        const { data } = await this.client.get(`/v2/glossaries/${id}/countes`);
+        return data;
+    }
+    // FIXME: this method should return a Blob or Buffer
+    async export(id, contentType, source) {
+        const { data } = await this.client.get(`/v2/glossaries/${id}/export`, {
+            data: {
+                content_type: contentType,
+                source: !!source ? source : undefined,
+            },
+        });
+        return data;
+    }
+}

package/lib/Memories.d.ts

@@ -0,0 +1,18 @@
+import { AxiosInstance } from 'axios';
+import { Memory, MemoryImport, UploadableFile } from './models';
+export default class Memories {
+    private readonly client;
+    private readonly pollingInterval;
+    constructor(client: AxiosInstance);
+    list(): Promise<Memory[]>;
+    create(name: string, externalId?: string): Promise<Memory>;
+    get(id: string): Promise<Memory>;
+    delete(id: string): Promise<Memory>;
+    update(id: string, name: string): Promise<Memory>;
+    addTranslation(id: string | string[], source: string, target: string, sentence: string, translation: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: string, headers?: Record<string, any>): Promise<MemoryImport>;
+    deleteTranslation(id: string | string[], source: string, target: string, sentence?: string, translation?: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: string): Promise<MemoryImport>;
+    importTmx(id: string, tmx: UploadableFile, gzip?: boolean): Promise<MemoryImport>;
+    getImportStatus(id: string): Promise<MemoryImport>;
+    waitForImport(mImport: MemoryImport, updateCallback?: (mImport: MemoryImport) => void, maxWaitTime?: number): Promise<MemoryImport>;
+    connect<T extends string | string[]>(ids: T): Promise<T extends string ? Memory : Memory[]>;
+}

package/lib/Memories.js

@@ -0,0 +1,95 @@
+import { TimeoutError } from './utils/errors';
+import toFormData from './utils/formdata';
+import sleep from './utils/sleep';
+export default class Memories {
+    constructor(client) {
+        this.pollingInterval = 2000;
+        this.client = client;
+    }
+    async list() {
+        const { data } = await this.client.get('/v2/memories');
+        return data;
+    }
+    async create(name, externalId) {
+        const { data } = await this.client.post('/v2/memories', {
+            name,
+            external_id: externalId,
+        });
+        return data;
+    }
+    async get(id) {
+        const { data } = await this.client.get(`/v2/memories/${id}`);
+        return data;
+    }
+    async delete(id) {
+        const { data } = await this.client.delete(`/v2/memories/${id}`);
+        return data;
+    }
+    async update(id, name) {
+        const { data } = await this.client.put(`/v2/memories/${id}`, { name });
+        return data;
+    }
+    async addTranslation(id, source, target, sentence, translation, tuid, sentenceBefore, sentenceAfter, headers) {
+        const url = Array.isArray(id) ? '/v2/memories/content' : `/v2/memories/${id}/content`;
+        const { data } = await this.client.put(url, {
+            ids: Array.isArray(id) ? id : undefined,
+            source,
+            target,
+            sentence,
+            translation,
+            tuid,
+            sentence_before: sentenceBefore,
+            sentence_after: sentenceAfter,
+        }, {
+            headers,
+        });
+        return data;
+    }
+    async deleteTranslation(id, source, target, sentence, translation, tuid, sentenceBefore, sentenceAfter) {
+        const url = Array.isArray(id) ? '/v2/memories/content' : `/v2/memories/${id}/content`;
+        const { data } = await this.client.delete(url, {
+            data: {
+                ids: Array.isArray(id) ? id : undefined,
+                source,
+                target,
+                sentence,
+                translation,
+                tuid,
+                sentence_before: sentenceBefore,
+                sentence_after: sentenceAfter,
+            },
+        });
+        return data;
+    }
+    async importTmx(id, tmx, gzip = false) {
+        const [formData, headers] = toFormData({
+            tmx,
+            compression: gzip ? 'gzip' : undefined,
+        });
+        const { data } = await this.client.post(`/v2/memories/${id}/import`, formData, {
+            headers,
+        });
+        return data;
+    }
+    async getImportStatus(id) {
+        const { data } = await this.client.get(`/v2/memories/imports/${id}`);
+        return data;
+    }
+    async waitForImport(mImport, updateCallback, maxWaitTime) {
+        const start = Date.now();
+        while (mImport.progress < 1.0) {
+            if (maxWaitTime && Date.now() - start > maxWaitTime)
+                throw new TimeoutError();
+            await sleep(this.pollingInterval);
+            mImport = await this.getImportStatus(mImport.id);
+            updateCallback && updateCallback(mImport);
+        }
+        return mImport;
+    }
+    async connect(ids) {
+        const { data } = await this.client.post('/v2/memories/connect', {
+            ids: Array.isArray(ids) ? ids : [ids],
+        });
+        return (Array.isArray(ids) ? data : data[0]);
+    }
+}

package/lib/Translator.d.ts

@@ -0,0 +1,24 @@
+import { AccessKey, Credentials, AuthToken, TranslatorOptions, TextBlock, TranslateOptions, TextResult } from './models';
+import Memories from './Memories';
+import Glossaries from './Glossaries';
+import Documents from './Documents';
+export declare class Translator {
+    private readonly accessKey?;
+    private readonly credentials?;
+    private authToken?;
+    readonly memories: Memories;
+    readonly glossaries: Glossaries;
+    readonly documents: Documents;
+    private token?;
+    private refreshToken?;
+    private readonly options?;
+    private readonly client;
+    constructor(accessKey?: AccessKey, credentials?: Credentials, authToken?: AuthToken, options?: TranslatorOptions);
+    private authenticate;
+    translate<T extends string | string[] | TextBlock[]>(text: T, source: string | null, target: string, options?: TranslateOptions): Promise<TextResult<T>>;
+    getLanguages(): Promise<string[]>;
+    static getLoginUrl(serverUrl?: string): Promise<string>;
+    static byAccessKey(id: string, secret: string, options?: TranslatorOptions): Translator;
+    static byCredentials(email: string, password: string, options?: TranslatorOptions): Translator;
+    static byAuthToken(token: string, refresh_token: string, options?: TranslatorOptions): Translator;
+}