@translated/lara 1.6.7 → 1.8.0-beta.0

package/README.md

@@ -181,6 +181,32 @@ const options = {
 const result = await lara.translate("Hello", "en-US", "fr-FR", options);
 ```
 
+#### Language Detection
+
+Use detect() to automatically identify the language of one or multiple texts.
+
+```javascript
+// Single string detection
+const single = await lara.detect("Bonjour tout le monde");
+console.log(single.language); // fr
+
+// Multiple strings detection
+const multiple = await lara.detect(["Hello world", "How are you?"]);
+console.log(multiple.languages); // "en"
+```
+
+You can provide a hint (expected source language) and a passlist (restrict candidates) to improve accuracy.
+
+```javascript
+// Detection with hint and passlist
+const detected = await lara.detect(
+  "Es un día soleado",
+  "es",                      // hint (optional)
+  ["es", "pt", "fr"]         // passlist (optional)
+);
+console.log(detected.language); // es
+```
+
 ### 📖 Document Translation
 #### Simple document translation
 

package/lib/credentials.d.ts

@@ -1,5 +1,37 @@
-export declare class Credentials {
-    readonly accessKeyId: string;
-    readonly accessKeySecret: string;
-    constructor(accessKeyId: string, accessKeySecret: string);
+/**
+ * Represents an access key for authenticating with the Lara API.
+ */
+export declare class AccessKey {
+    /** The access key ID. */
+    readonly id: string;
+    /** The access key secret. */
+    readonly secret: string;
+    /**
+     * Creates a new AccessKey instance.
+     * @param id - The access key ID.
+     * @param secret - The access key secret.
+     */
+    constructor(id: string, secret: string);
+}
+/**
+ * @deprecated Use AccessKey instead.
+ */
+export declare class Credentials extends AccessKey {
+    get accessKeyId(): string;
+    get accessKeySecret(): string;
+}
+/**
+ * Represents an authentication token for authenticating with the Lara API.
+ */
+export declare class AuthToken {
+    /** The authentication token. */
+    readonly token: string;
+    /** The refresh token used to obtain a new authentication token. */
+    readonly refreshToken: string;
+    /**
+     * Creates a new AuthToken instance.
+     * @param token - The authentication token.
+     * @param refreshToken - The refresh token.
+     */
+    constructor(token: string, refreshToken: string);
 }

package/lib/credentials.js

@@ -1,10 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Credentials = void 0;
-class Credentials {
-    constructor(accessKeyId, accessKeySecret) {
-        this.accessKeyId = accessKeyId;
-        this.accessKeySecret = accessKeySecret;
+exports.AuthToken = exports.Credentials = exports.AccessKey = void 0;
+/**
+ * Represents an access key for authenticating with the Lara API.
+ */
+class AccessKey {
+    /**
+     * Creates a new AccessKey instance.
+     * @param id - The access key ID.
+     * @param secret - The access key secret.
+     */
+    constructor(id, secret) {
+        this.id = id;
+        this.secret = secret;
+    }
+}
+exports.AccessKey = AccessKey;
+/**
+ * @deprecated Use AccessKey instead.
+ */
+class Credentials extends AccessKey {
+    get accessKeyId() {
+        return this.id;
+    }
+    get accessKeySecret() {
+        return this.secret;
     }
 }
 exports.Credentials = Credentials;
+/**
+ * Represents an authentication token for authenticating with the Lara API.
+ */
+class AuthToken {
+    /**
+     * Creates a new AuthToken instance.
+     * @param token - The authentication token.
+     * @param refreshToken - The refresh token.
+     */
+    constructor(token, refreshToken) {
+        this.token = token;
+        this.refreshToken = refreshToken;
+    }
+}
+exports.AuthToken = AuthToken;

package/lib/crypto/browser-crypto.d.ts

@@ -3,9 +3,6 @@ import type { PortableCrypto } from "./portable-crypto";
 export declare class BrowserCrypto implements PortableCrypto {
     private readonly subtle;
     constructor();
-    /**
-     * MD5 in browser is not supported, so we use SHA-256 instead and return the first 16 bytes
-     */
-    digest(data: string): Promise<string>;
+    digestBase64(data: string): Promise<string>;
     hmac(key: string, data: string): Promise<string>;
 }

package/lib/crypto/browser-crypto.js

@@ -6,13 +6,10 @@ class BrowserCrypto {
     constructor() {
         this.subtle = window.crypto.subtle;
     }
-    /**
-     * MD5 in browser is not supported, so we use SHA-256 instead and return the first 16 bytes
-     */
-    async digest(data) {
+    async digestBase64(data) {
         const encoder = new TextEncoder();
         const buffer = (await this.subtle.digest("sha-256", encoder.encode(data))).slice(0, 16);
-        return [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+        return btoa(String.fromCharCode(...new Uint8Array(buffer)));
     }
     async hmac(key, data) {
         const encoder = new TextEncoder();

package/lib/crypto/index.browser.d.ts

@@ -0,0 +1,3 @@
+import type { PortableCrypto } from "./portable-crypto";
+export { PortableCrypto } from "./portable-crypto";
+export default function instance(): PortableCrypto;

package/lib/crypto/index.browser.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = instance;
+const browser_crypto_1 = require("./browser-crypto");
+let _instance;
+function instance() {
+    if (_instance === undefined) {
+        _instance = new browser_crypto_1.BrowserCrypto();
+    }
+    return _instance;
+}

package/lib/crypto/index.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = instance;
-const browser_crypto_1 = require("./browser-crypto");
 const node_crypto_1 = require("./node-crypto");
 let _instance;
 function instance() {
     if (_instance === undefined) {
-        if (typeof window !== "undefined")
-            _instance = new browser_crypto_1.BrowserCrypto();
-        else
-            _instance = new node_crypto_1.NodeCrypto();
+        _instance = new node_crypto_1.NodeCrypto();
     }
     return _instance;
 }

package/lib/crypto/node-crypto.d.ts

@@ -1,6 +1,6 @@
 import type { PortableCrypto } from "./portable-crypto";
 /** @internal */
 export declare class NodeCrypto implements PortableCrypto {
-    digest(data: string): Promise<string>;
+    digestBase64(data: string): Promise<string>;
     hmac(key: string, data: string): Promise<string>;
 }

package/lib/crypto/node-crypto.js

@@ -37,11 +37,11 @@ exports.NodeCrypto = void 0;
 const crypto = __importStar(require("node:crypto"));
 /** @internal */
 class NodeCrypto {
-    digest(data) {
+    digestBase64(data) {
         return new Promise((resolve) => {
             const hash = crypto.createHash("md5");
-            hash.update(data);
-            resolve(hash.digest("hex"));
+            hash.update(data, "utf8");
+            resolve(hash.digest("base64"));
         });
     }
     hmac(key, data) {

package/lib/crypto/portable-crypto.d.ts

@@ -1,5 +1,5 @@
 /** @internal */
 export interface PortableCrypto {
-    digest(data: string): Promise<string>;
+    digestBase64(data: string): Promise<string>;
     hmac(key: string, data: string): Promise<string>;
 }

package/lib/documents.d.ts

@@ -0,0 +1,61 @@
+import type { LaraClient } from "./net/lara";
+import type { MultiPartFile } from "./net/lara/client";
+import type { LaraStream } from "./net/s3/laraStream";
+import type { TranslationStyle } from "./translator";
+export type S3UploadFields = {
+    acl: string;
+    bucket: string;
+    key: string;
+};
+export declare enum DocumentStatus {
+    INITIALIZED = "initialized",// just been created
+    ANALYZING = "analyzing",// being analyzed for language detection and chars count
+    PAUSED = "paused",// paused after analysis, needs user confirm
+    READY = "ready",// ready to be translated
+    TRANSLATING = "translating",
+    TRANSLATED = "translated",
+    ERROR = "error"
+}
+export interface DocxExtractionParams {
+    extractComments?: boolean;
+    acceptRevisions?: boolean;
+}
+export type DocumentOptions = {
+    adaptTo?: string[];
+    glossaries?: string[];
+    noTrace?: boolean;
+    style?: TranslationStyle;
+};
+export type DocumentDownloadOptions = {
+    outputFormat?: string;
+};
+export type DocumentUploadOptions = DocumentOptions & {
+    password?: string;
+    extractionParams?: DocxExtractionParams;
+    contentLength?: number;
+};
+export interface Document {
+    readonly id: string;
+    readonly status: DocumentStatus;
+    readonly source?: string;
+    readonly target: string;
+    readonly filename: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly options?: DocumentOptions;
+    readonly translatedChars?: number;
+    readonly totalChars?: number;
+    readonly errorReason?: string;
+}
+export type DocumentTranslateOptions = DocumentUploadOptions & DocumentDownloadOptions;
+export declare class Documents {
+    private readonly client;
+    private readonly s3Client;
+    constructor(client: LaraClient);
+    upload(file: MultiPartFile, filename: string, source: string | null, target: string, options?: DocumentUploadOptions): Promise<Document>;
+    status(id: string): Promise<Document>;
+    download(id: string, options?: DocumentDownloadOptions): Promise<Blob | Buffer>;
+    downloadStream(id: string, options?: DocumentDownloadOptions): Promise<LaraStream>;
+    translate(file: MultiPartFile, filename: string, source: string | null, target: string, options?: DocumentTranslateOptions): Promise<Blob | Buffer>;
+    translateStream(file: MultiPartFile, filename: string, source: string | null, target: string, options?: DocumentTranslateOptions): Promise<LaraStream>;
+}

package/lib/documents.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Documents = exports.DocumentStatus = void 0;
+const errors_1 = require("./errors");
+const s3_1 = __importDefault(require("./net/s3"));
+const to_snake_case_1 = __importDefault(require("./utils/to-snake-case"));
+// biome-ignore format: keep comments aligned
+var DocumentStatus;
+(function (DocumentStatus) {
+    DocumentStatus["INITIALIZED"] = "initialized";
+    DocumentStatus["ANALYZING"] = "analyzing";
+    DocumentStatus["PAUSED"] = "paused";
+    DocumentStatus["READY"] = "ready";
+    DocumentStatus["TRANSLATING"] = "translating";
+    DocumentStatus["TRANSLATED"] = "translated";
+    DocumentStatus["ERROR"] = "error";
+})(DocumentStatus || (exports.DocumentStatus = DocumentStatus = {}));
+class Documents {
+    constructor(client) {
+        this.client = client;
+        this.s3Client = (0, s3_1.default)();
+    }
+    async upload(file, filename, source, target, options) {
+        const { url, fields } = await this.client.get(`/v2/documents/upload-url`, { filename });
+        await this.s3Client.upload(url, fields, file, options === null || options === void 0 ? void 0 : options.contentLength);
+        const headers = (options === null || options === void 0 ? void 0 : options.noTrace) ? { "X-No-Trace": "true" } : {};
+        return 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) ? (0, to_snake_case_1.default)(options.extractionParams) : undefined
+        }, undefined, headers);
+    }
+    async status(id) {
+        return await this.client.get(`/v2/documents/${id}`);
+    }
+    async download(id, options) {
+        const { url } = await this.client.get(`/v2/documents/${id}/download-url`, {
+            output_format: options === null || options === void 0 ? void 0 : options.outputFormat
+        });
+        return await this.s3Client.download(url);
+    }
+    async downloadStream(id, options) {
+        const { url } = await this.client.get(`/v2/documents/${id}/download-url`, {
+            output_format: options === null || options === void 0 ? void 0 : options.outputFormat
+        });
+        return (await this.s3Client.downloadStream(url));
+    }
+    async translate(file, filename, 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,
+            contentLength: options === null || options === void 0 ? void 0 : options.contentLength
+        };
+        const { id } = await this.upload(file, filename, source, target, uploadOptions);
+        const downloadOptions = (options === null || options === void 0 ? void 0 : options.outputFormat) ? { outputFormat: options.outputFormat } : undefined;
+        const pollingInterval = 2000;
+        const maxWaitTime = 1000 * 60 * 15; // 15 minutes
+        const start = Date.now();
+        while (Date.now() - start < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            const { status, errorReason } = await this.status(id);
+            if (status === DocumentStatus.TRANSLATED)
+                return await this.download(id, downloadOptions);
+            if (status === DocumentStatus.ERROR) {
+                throw new errors_1.LaraApiError(500, "DocumentError", errorReason);
+            }
+        }
+        throw new errors_1.TimeoutError();
+    }
+    async translateStream(file, filename, 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,
+            contentLength: options === null || options === void 0 ? void 0 : options.contentLength
+        };
+        const { id } = await this.upload(file, filename, source, target, uploadOptions);
+        const downloadOptions = (options === null || options === void 0 ? void 0 : options.outputFormat) ? { outputFormat: options.outputFormat } : undefined;
+        const pollingInterval = 2000;
+        const maxWaitTime = 1000 * 60 * 15; // 15 minutes
+        const start = Date.now();
+        while (Date.now() - start < maxWaitTime) {
+            await new Promise((resolve) => setTimeout(resolve, pollingInterval));
+            const { status, errorReason } = await this.status(id);
+            if (status === DocumentStatus.TRANSLATED)
+                return await this.downloadStream(id, downloadOptions);
+            if (status === DocumentStatus.ERROR) {
+                throw new errors_1.LaraApiError(500, "DocumentError", errorReason);
+            }
+        }
+        throw new errors_1.TimeoutError();
+    }
+}
+exports.Documents = Documents;

package/lib/errors.d.ts

@@ -6,5 +6,6 @@ export declare class LaraApiError extends LaraError {
     readonly statusCode: number;
     readonly type: string;
     readonly message: string;
-    constructor(statusCode: number, type: string, message: string);
+    readonly idTransaction?: string;
+    constructor(statusCode: number, type: string, message: string, idTransaction?: string);
 }

package/lib/errors.js

@@ -8,11 +8,12 @@ class TimeoutError extends LaraError {
 }
 exports.TimeoutError = TimeoutError;
 class LaraApiError extends LaraError {
-    constructor(statusCode, type, message) {
+    constructor(statusCode, type, message, idTransaction) {
         super(message);
         this.statusCode = statusCode;
         this.type = type;
         this.message = message;
+        this.idTransaction = idTransaction;
     }
 }
 exports.LaraApiError = LaraApiError;

package/lib/glossaries.d.ts

@@ -0,0 +1,37 @@
+import type { LaraClient } from "./net/lara";
+import type { MultiPartFile } from "./net/lara/client";
+export interface Glossary {
+    readonly id: string;
+    readonly name: string;
+    readonly ownerId: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+export interface GlossaryImport {
+    readonly id: string;
+    readonly begin: number;
+    readonly end: number;
+    readonly channel: number;
+    readonly size: number;
+    readonly progress: number;
+}
+export interface GlossaryCounts {
+    unidirectional?: Record<string, number>;
+    multidirectional?: number;
+}
+export type GlossaryImportCallback = (glossaryImport: GlossaryImport) => void;
+export declare class Glossaries {
+    private readonly client;
+    private readonly pollingInterval;
+    constructor(client: LaraClient);
+    list(): Promise<Glossary[]>;
+    create(name: string): Promise<Glossary>;
+    get(id: string): Promise<Glossary | null>;
+    delete(id: string): Promise<Glossary>;
+    update(id: string, name: string): Promise<Glossary>;
+    importCsv(id: string, csv: MultiPartFile, gzip?: boolean): Promise<GlossaryImport>;
+    getImportStatus(id: string): Promise<GlossaryImport>;
+    waitForImport(gImport: GlossaryImport, updateCallback?: GlossaryImportCallback, 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,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Glossaries = void 0;
+const errors_1 = require("./errors");
+class Glossaries {
+    constructor(client) {
+        this.client = client;
+        this.pollingInterval = 2000;
+    }
+    async list() {
+        return await this.client.get("/v2/glossaries");
+    }
+    async create(name) {
+        return await this.client.post("/v2/glossaries", { name });
+    }
+    async get(id) {
+        try {
+            return await this.client.get(`/v2/glossaries/${id}`);
+        }
+        catch (e) {
+            if (e instanceof errors_1.LaraApiError && e.statusCode === 404) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        return await this.client.delete(`/v2/glossaries/${id}`);
+    }
+    async update(id, name) {
+        return await this.client.put(`/v2/glossaries/${id}`, { name });
+    }
+    async importCsv(id, csv, gzip = false) {
+        return await this.client.post(`/v2/glossaries/${id}/import`, {
+            compression: gzip ? "gzip" : undefined
+        }, {
+            csv
+        });
+    }
+    async getImportStatus(id) {
+        return await this.client.get(`/v2/glossaries/imports/${id}`);
+    }
+    async waitForImport(gImport, updateCallback, maxWaitTime) {
+        const start = Date.now();
+        while (gImport.progress < 1.0) {
+            if (maxWaitTime && Date.now() - start > maxWaitTime)
+                throw new errors_1.TimeoutError();
+            await new Promise((resolve) => setTimeout(resolve, this.pollingInterval));
+            gImport = await this.getImportStatus(gImport.id);
+            if (updateCallback)
+                updateCallback(gImport);
+        }
+        return gImport;
+    }
+    async counts(id) {
+        return await this.client.get(`/v2/glossaries/${id}/counts`);
+    }
+    async export(id, contentType, source) {
+        return await this.client.get(`/v2/glossaries/${id}/export`, {
+            content_type: contentType,
+            source
+        });
+    }
+}
+exports.Glossaries = Glossaries;

package/lib/index.d.ts

@@ -1,6 +1,9 @@
-export { Credentials } from "./credentials";
+export { AccessKey, AuthToken, Credentials } from "./credentials";
+export { Document, DocumentDownloadOptions, DocumentStatus, Documents, DocumentTranslateOptions, DocumentUploadOptions } from "./documents";
 export { LaraApiError, LaraError, TimeoutError } from "./errors";
-export { MultiPartFile } from "./net/client";
-export { version } from "./sdk-version";
-export { Document, DocumentDownloadOptions, DocumentStatus, DocumentUploadOptions, Memory, MemoryImport, NGGlossaryMatch, NGMemoryMatch, TextBlock, TextResult } from "./translator/models";
-export { Documents, DocumentTranslateOptions, Memories, MemoryImportCallback, TranslateOptions, Translator, TranslatorOptions } from "./translator/translator";
+export { Glossaries, GlossaryImport, GlossaryImportCallback } from "./glossaries";
+export { Memories, Memory, MemoryImport, MemoryImportCallback } from "./memories";
+export { MultiPartFile } from "./net/lara/client";
+export type { LaraStream } from "./net/s3/laraStream";
+export { DetectResult, NGGlossaryMatch, NGMemoryMatch, TextBlock, TextResult, TranslateOptions, Translator, TranslatorOptions } from "./translator";
+export { version } from "./utils/sdk-version";

package/lib/index.js

@@ -1,17 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Translator = exports.Memories = exports.Documents = exports.DocumentStatus = exports.version = exports.TimeoutError = exports.LaraError = exports.LaraApiError = exports.Credentials = void 0;
+exports.version = exports.Translator = exports.Memories = exports.Glossaries = exports.TimeoutError = exports.LaraError = exports.LaraApiError = exports.Documents = exports.DocumentStatus = exports.Credentials = exports.AuthToken = exports.AccessKey = void 0;
 var credentials_1 = require("./credentials");
+Object.defineProperty(exports, "AccessKey", { enumerable: true, get: function () { return credentials_1.AccessKey; } });
+Object.defineProperty(exports, "AuthToken", { enumerable: true, get: function () { return credentials_1.AuthToken; } });
 Object.defineProperty(exports, "Credentials", { enumerable: true, get: function () { return credentials_1.Credentials; } });
+var documents_1 = require("./documents");
+Object.defineProperty(exports, "DocumentStatus", { enumerable: true, get: function () { return documents_1.DocumentStatus; } });
+Object.defineProperty(exports, "Documents", { enumerable: true, get: function () { return documents_1.Documents; } });
 var errors_1 = require("./errors");
 Object.defineProperty(exports, "LaraApiError", { enumerable: true, get: function () { return errors_1.LaraApiError; } });
 Object.defineProperty(exports, "LaraError", { enumerable: true, get: function () { return errors_1.LaraError; } });
 Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
-var sdk_version_1 = require("./sdk-version");
-Object.defineProperty(exports, "version", { enumerable: true, get: function () { return sdk_version_1.version; } });
-var models_1 = require("./translator/models");
-Object.defineProperty(exports, "DocumentStatus", { enumerable: true, get: function () { return models_1.DocumentStatus; } });
-var translator_1 = require("./translator/translator");
-Object.defineProperty(exports, "Documents", { enumerable: true, get: function () { return translator_1.Documents; } });
-Object.defineProperty(exports, "Memories", { enumerable: true, get: function () { return translator_1.Memories; } });
+var glossaries_1 = require("./glossaries");
+Object.defineProperty(exports, "Glossaries", { enumerable: true, get: function () { return glossaries_1.Glossaries; } });
+var memories_1 = require("./memories");
+Object.defineProperty(exports, "Memories", { enumerable: true, get: function () { return memories_1.Memories; } });
+var translator_1 = require("./translator");
 Object.defineProperty(exports, "Translator", { enumerable: true, get: function () { return translator_1.Translator; } });
+var sdk_version_1 = require("./utils/sdk-version");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return sdk_version_1.version; } });

package/lib/memories.d.ts

@@ -0,0 +1,38 @@
+import type { LaraClient } from "./net/lara";
+import type { MultiPartFile } from "./net/lara/client";
+export interface Memory {
+    readonly id: string;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+    readonly sharedAt: Date;
+    readonly name: string;
+    readonly externalId?: string;
+    readonly secret?: string;
+    readonly ownerId: string;
+    readonly collaboratorsCount: number;
+}
+export interface MemoryImport {
+    readonly id: string;
+    readonly begin: number;
+    readonly end: number;
+    readonly channel: number;
+    readonly size: number;
+    readonly progress: number;
+}
+export type MemoryImportCallback = (memoryImport: MemoryImport) => void;
+export declare class Memories {
+    private readonly client;
+    private readonly pollingInterval;
+    constructor(client: LaraClient);
+    list(): Promise<Memory[]>;
+    create(name: string, externalId?: string): Promise<Memory>;
+    get(id: string): Promise<Memory | null>;
+    delete(id: string): Promise<Memory>;
+    update(id: string, name: string): Promise<Memory>;
+    connect<T extends string | string[]>(ids: T): Promise<T extends string ? Memory : Memory[]>;
+    importTmx(id: string, tmx: MultiPartFile, gzip?: boolean): Promise<MemoryImport>;
+    addTranslation(id: string | string[], source: string, target: string, sentence: string, translation: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: string, headers?: Record<string, string>): Promise<MemoryImport>;
+    deleteTranslation(id: string | string[], source: string, target: string, sentence?: string, translation?: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: string): Promise<MemoryImport>;
+    getImportStatus(id: string): Promise<MemoryImport>;
+    waitForImport(mImport: MemoryImport, updateCallback?: MemoryImportCallback, maxWaitTime?: number): Promise<MemoryImport>;
+}