@translated/lara 1.0.1

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2024 Translated, Srl. (https://translated.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# Lara Node.js Library
+
+This library is a Node.js library for the Lara platform. It provides a simple way to interact with the Lara API.

package/lib/_test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/_test.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const credentials_1 = require("./credentials");
+const translator_1 = require("./translator/translator");
+const credentials = new credentials_1.Credentials("7GAFEDT3LDJAJH9HFA1CDJULDU", "EBXxbk71Mx6yR9YG48f1jDyY4s5QQLOff0GcTw2QlfY");
+const lara = new translator_1.Translator(credentials, {
+    serverUrl: "http://localhost:8000/"
+});
+async function main() {
+    const textResult = await lara.translate("Hello, world!", "en", "it");
+    console.log("Text:", textResult.translation);
+    const arrayResult = await lara.translate(["Hello, world!", "Goodbye, world!"], "en", "it");
+    console.log("Array:", arrayResult.translation);
+    const blockResult = await lara.translate([{ text: "Hello, world!" }, { text: "Goodbye, world!" }], "en", "it");
+    console.log("Block:", blockResult.translation);
+    const blockResult2 = await lara.translate([{ text: "Hello, world!", translatable: false }, { text: "Goodbye, world!" }], "en", "it");
+    console.log("Block (2):", blockResult2.translation);
+}
+main().then(() => console.log("done")).catch(console.error);

package/lib/credentials.d.ts

@@ -0,0 +1,5 @@
+export declare class Credentials {
+    readonly accessKeyId: string;
+    readonly accessKeySecret: string;
+    constructor(accessKeyId: string, accessKeySecret: string);
+}

package/lib/credentials.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Credentials = void 0;
+class Credentials {
+    constructor(accessKeyId, accessKeySecret) {
+        this.accessKeyId = accessKeyId;
+        this.accessKeySecret = accessKeySecret;
+    }
+}
+exports.Credentials = Credentials;

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

@@ -0,0 +1 @@
+export {};

package/lib/crypto/browser-crypto.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserCrypto = void 0;
+/** @internal */
+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) {
+        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('');
+    }
+    async hmac(key, data) {
+        const encoder = new TextEncoder();
+        encoder.encode(data);
+        const cKey = await this.subtle.importKey("raw", encoder.encode(key), {
+            name: "hmac",
+            hash: { name: "sha-256" },
+        }, false, ["sign"]);
+        const buffer = await this.subtle.sign("hmac", cKey, encoder.encode(data));
+        return btoa(String.fromCharCode(...new Uint8Array(buffer)));
+    }
+}
+exports.BrowserCrypto = BrowserCrypto;

package/lib/crypto/index.d.ts

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

package/lib/crypto/index.js

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

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

@@ -0,0 +1 @@
+export {};

package/lib/crypto/node-crypto.js

@@ -0,0 +1,45 @@
+"use strict";
+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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeCrypto = void 0;
+const crypto = __importStar(require("crypto"));
+/** @internal */
+class NodeCrypto {
+    digest(data) {
+        return new Promise((resolve) => {
+            const hash = crypto.createHash("md5");
+            hash.update(data);
+            resolve(hash.digest("hex"));
+        });
+    }
+    hmac(key, data) {
+        return new Promise((resolve) => {
+            const hmac = crypto.createHmac("sha256", key);
+            hmac.update(data);
+            resolve(hmac.digest("base64"));
+        });
+    }
+}
+exports.NodeCrypto = NodeCrypto;

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

@@ -0,0 +1 @@
+export {};

package/lib/crypto/portable-crypto.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class LaraError extends Error {
+}
+export declare class TimeoutError extends LaraError {
+}
+export declare class LaraApiError extends LaraError {
+    readonly statusCode: number;
+    readonly name: string;
+    readonly errorMessage: string;
+    constructor(statusCode: number, name: string, message: string);
+}

package/lib/errors.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaraApiError = exports.TimeoutError = exports.LaraError = void 0;
+class LaraError extends Error {
+}
+exports.LaraError = LaraError;
+class TimeoutError extends LaraError {
+}
+exports.TimeoutError = TimeoutError;
+class LaraApiError extends LaraError {
+    constructor(statusCode, name, message) {
+        super(`[HTTP ${statusCode}] ${name}: ${message}`);
+        this.statusCode = statusCode;
+        this.name = name;
+        this.errorMessage = message;
+    }
+}
+exports.LaraApiError = LaraApiError;

package/lib/index.d.ts

@@ -0,0 +1,5 @@
+export { version } from "./sdk-version";
+export { Credentials } from "./credentials";
+export { LaraError, TimeoutError, LaraApiError } from "./errors";
+export { Translator, TranslatorOptions, Memories, MemoryImportCallback, TranslateOptions } from "./translator/translator";
+export { Memory, MemoryImport, TextBlock, TextResult } from "./translator/models";

package/lib/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memories = exports.Translator = exports.LaraApiError = exports.TimeoutError = exports.LaraError = exports.Credentials = exports.version = void 0;
+var sdk_version_1 = require("./sdk-version");
+Object.defineProperty(exports, "version", { enumerable: true, get: function () { return sdk_version_1.version; } });
+var credentials_1 = require("./credentials");
+Object.defineProperty(exports, "Credentials", { enumerable: true, get: function () { return credentials_1.Credentials; } });
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "LaraError", { enumerable: true, get: function () { return errors_1.LaraError; } });
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return errors_1.TimeoutError; } });
+Object.defineProperty(exports, "LaraApiError", { enumerable: true, get: function () { return errors_1.LaraApiError; } });
+var translator_1 = require("./translator/translator");
+Object.defineProperty(exports, "Translator", { enumerable: true, get: function () { return translator_1.Translator; } });
+Object.defineProperty(exports, "Memories", { enumerable: true, get: function () { return translator_1.Memories; } });

package/lib/net/browser-client.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/net/browser-client.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserLaraClient = void 0;
+const client_1 = require("./client");
+function hasDefaultPort(port, secure) {
+    return port === 80 && !secure || port === 443 && secure;
+}
+/** @internal */
+class BrowserLaraClient extends client_1.LaraClient {
+    constructor(baseUrl, accessKeyId, accessKeySecret) {
+        super(accessKeyId, accessKeySecret);
+        let url = `${baseUrl.secure ? "https" : "http"}://${baseUrl.hostname}`;
+        if (!hasDefaultPort(baseUrl.port, baseUrl.secure))
+            url += `:${baseUrl.port}`;
+        this.baseUrl = url;
+    }
+    async send(path, headers, body) {
+        let requestBody = undefined;
+        if (body) {
+            if (headers["Content-Type"] === "multipart/form-data") {
+                delete headers["Content-Type"]; // browser will set it automatically
+                const formBody = new FormData();
+                for (const [key, value] of Object.entries(body)) {
+                    if (!value)
+                        continue;
+                    if (Array.isArray(value))
+                        value.forEach(v => formBody.append(key, v));
+                    else
+                        formBody.append(key, value);
+                }
+                requestBody = formBody;
+            }
+            else {
+                requestBody = JSON.stringify(body, undefined, 0);
+            }
+        }
+        const response = await fetch(this.baseUrl + path, {
+            headers: headers,
+            method: "POST",
+            body: requestBody
+        });
+        return { statusCode: response.status, body: await response.json() };
+    }
+}
+exports.BrowserLaraClient = BrowserLaraClient;

package/lib/net/client.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/net/client.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaraClient = void 0;
+const sdk_version_1 = require("../sdk-version");
+const crypto_1 = __importDefault(require("../crypto"));
+const errors_1 = require("../errors");
+function parseContent(content) {
+    if (content === undefined || content === null)
+        return content;
+    if (Array.isArray(content))
+        return content.map(parseContent);
+    if (typeof content === "string") {
+        // Test if it's a date
+        if (content.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.[0-9]{3}Z$/))
+            return new Date(content);
+        else
+            return content;
+    }
+    if (typeof content == "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(content)) {
+            const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+            result[camelKey] = parseContent(value);
+        }
+        return result;
+    }
+    return content;
+}
+/** @internal */
+class LaraClient {
+    constructor(accessKeyId, accessKeySecret) {
+        this.crypto = (0, crypto_1.default)();
+        this.accessKeyId = accessKeyId;
+        this.accessKeySecret = accessKeySecret;
+    }
+    get(path, params) {
+        return this.request("GET", path, params);
+    }
+    delete(path, params) {
+        return this.request("DELETE", path, params);
+    }
+    post(path, body, files) {
+        return this.request("POST", path, body, files);
+    }
+    put(path, body, files) {
+        return this.request("PUT", path, body, files);
+    }
+    async request(method, path, body, files) {
+        if (!path.startsWith("/"))
+            path = "/" + path;
+        const headers = {
+            "X-HTTP-Method-Override": method,
+            "X-Lara-Date": new Date().toUTCString(),
+            "X-Lara-SDK-Name": "lara-node",
+            'X-Lara-SDK-Version': sdk_version_1.version
+        };
+        if (body) {
+            body = Object.fromEntries(Object.entries(body).filter(([_, v]) => v !== undefined && v !== null));
+            if (Object.keys(body).length === 0)
+                body = undefined;
+            if (body) {
+                const jsonBody = JSON.stringify(body, undefined, 0);
+                headers["Content-MD5"] = await this.crypto.digest(jsonBody);
+            }
+        }
+        let requestBody = undefined;
+        if (files) {
+            headers["Content-Type"] = "multipart/form-data";
+            requestBody = Object.assign({}, files, body);
+        }
+        else {
+            headers["Content-Type"] = "application/json";
+            if (body)
+                requestBody = body;
+        }
+        const signature = await this.sign(method, path, headers);
+        headers["Authorization"] = `Lara ${this.accessKeyId}:${signature}`;
+        const response = await this.send(path, headers, requestBody);
+        if (200 <= response.statusCode && response.statusCode < 300) {
+            return parseContent(response.body.content);
+        }
+        else {
+            const error = response.body.error || {};
+            throw new errors_1.LaraApiError(response.statusCode, error.name || "UnknownError", error.message || "An unknown error occurred");
+        }
+    }
+    async sign(method, path, headers) {
+        const date = headers["X-Lara-Date"].trim();
+        const contentMD5 = (headers["Content-MD5"] || "").trim();
+        const contentType = (headers["Content-Type"] || "").trim();
+        const httpMethod = (headers["X-HTTP-Method-Override"] || method).trim().toUpperCase();
+        const challenge = `${httpMethod}\n${path}\n${contentMD5}\n${contentType}\n${date}`;
+        return await this.crypto.hmac(this.accessKeySecret, challenge);
+    }
+}
+exports.LaraClient = LaraClient;

package/lib/net/index.d.ts

@@ -0,0 +1,3 @@
+import { LaraClient } from "./client";
+export { LaraClient } from "./client";
+export default function create(accessKeyId: string, accessKeySecret: string, baseUrl?: string): LaraClient;

package/lib/net/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaraClient = void 0;
+const browser_client_1 = require("./browser-client");
+const node_client_1 = require("./node-client");
+var client_1 = require("./client");
+Object.defineProperty(exports, "LaraClient", { enumerable: true, get: function () { return client_1.LaraClient; } });
+const DEFAULT_BASE_URL = "https://api.hellolara.ai";
+function create(accessKeyId, accessKeySecret, baseUrl) {
+    const url = new URL(baseUrl || DEFAULT_BASE_URL);
+    if (url.protocol !== "https:" && url.protocol !== "http:")
+        throw new TypeError("Invalid URL (protocol): " + url.protocol);
+    const parsedURL = {
+        secure: url.protocol === "https:",
+        hostname: url.hostname,
+        port: url.port ? parseInt(url.port) : url.protocol === "https:" ? 443 : 80
+    };
+    if (typeof window !== "undefined")
+        return new browser_client_1.BrowserLaraClient(parsedURL, accessKeyId, accessKeySecret);
+    else
+        return new node_client_1.NodeLaraClient(parsedURL, accessKeyId, accessKeySecret);
+}
+exports.default = create;

package/lib/net/node-client.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/net/node-client.js

@@ -0,0 +1,78 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeLaraClient = void 0;
+const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
+const form_data_1 = __importDefault(require("form-data"));
+const client_1 = require("./client");
+/** @internal */
+class NodeLaraClient extends client_1.LaraClient {
+    constructor(baseUrl, accessKeyId, accessKeySecret) {
+        super(accessKeyId, accessKeySecret);
+        this.baseUrl = baseUrl;
+        this.agent = baseUrl.secure ? new https_1.default.Agent({ keepAlive: true }) : new http_1.default.Agent({ keepAlive: true });
+    }
+    async send(path, headers, body) {
+        let requestBody = undefined;
+        if (body) {
+            if (headers["Content-Type"] === "multipart/form-data") {
+                const formBody = new form_data_1.default();
+                for (const [key, value] of Object.entries(body)) {
+                    if (!value)
+                        continue;
+                    if (Array.isArray(value))
+                        value.forEach(v => formBody.append(key, v));
+                    else
+                        formBody.append(key, value);
+                }
+                headers = {
+                    ...headers,
+                    ...formBody.getHeaders()
+                };
+                requestBody = formBody;
+            }
+            else {
+                requestBody = JSON.stringify(body, undefined, 0);
+            }
+        }
+        return new Promise((resolve, reject) => {
+            const options = {
+                host: this.baseUrl.hostname,
+                port: this.baseUrl.port,
+                path: path,
+                method: "POST",
+                headers: headers,
+                agent: this.agent
+            };
+            const req = (this.baseUrl.secure ? https_1.default : http_1.default).request(options, (res) => {
+                let data = "";
+                res.on("data", (chunk) => data += chunk);
+                res.on("end", () => {
+                    let json;
+                    try {
+                        json = JSON.parse(data);
+                    }
+                    catch (e) {
+                        reject(new Error("Invalid JSON response"));
+                    }
+                    resolve({
+                        statusCode: res.statusCode,
+                        body: json
+                    });
+                });
+            });
+            req.on("error", reject);
+            if (requestBody instanceof form_data_1.default) {
+                requestBody.pipe(req);
+            }
+            else if (requestBody) {
+                req.write(requestBody);
+            }
+            req.end();
+        });
+    }
+}
+exports.NodeLaraClient = NodeLaraClient;

package/lib/sdk-version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.0.0";

package/lib/sdk-version.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.version = void 0;
+exports.version = "1.0.0";

package/lib/translator/models.d.ts

@@ -0,0 +1,29 @@
+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 interface TextBlock {
+    readonly text: string;
+    readonly translatable?: boolean;
+}
+export interface TextResult<T extends string | string[] | TextBlock[]> {
+    readonly contentType: string;
+    readonly sourceLanguage: string;
+    readonly translation: T;
+    readonly adaptedTo?: string[];
+}

package/lib/translator/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/translator/translator.d.ts

@@ -0,0 +1,38 @@
+import { Credentials } from "../credentials";
+import { LaraClient } from "../net";
+import { Memory, MemoryImport, TextBlock, TextResult } from "./models";
+export type TranslatorOptions = {
+    serverUrl?: string;
+};
+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: any, gzip?: boolean): Promise<MemoryImport>;
+    addTranslation(id: string | string[], source: string, target: string, sentence: string, translation: string, tuid?: string, sentenceBefore?: string, sentenceAfter?: 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>;
+}
+export type TranslateOptions = {
+    sourceHint?: string;
+    adaptTo?: string[];
+    instructions?: string[];
+    contentType?: string;
+    multiline?: boolean;
+    timeoutInMillis?: number;
+};
+export declare class Translator {
+    private readonly client;
+    readonly memories: Memories;
+    constructor(credentials: Credentials, options?: TranslatorOptions);
+    getLanguages(): Promise<string[]>;
+    translate<T extends string | string[] | TextBlock[]>(text: T, source: string | null, target: string, options?: TranslateOptions): Promise<TextResult<T>>;
+}

package/lib/translator/translator.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translator = exports.Memories = void 0;
+const net_1 = __importDefault(require("../net"));
+const errors_1 = require("../errors");
+class Memories {
+    constructor(client) {
+        this.client = client;
+        this.pollingInterval = 2000;
+    }
+    async list() {
+        return await this.client.get("/memories");
+    }
+    async create(name, externalId) {
+        return await this.client.post("/memories", {
+            name, external_id: externalId
+        });
+    }
+    async get(id) {
+        try {
+            return await this.client.get(`/memories/${id}`);
+        }
+        catch (e) {
+            if (e instanceof errors_1.LaraApiError && e.statusCode === 404) {
+                return null;
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        return await this.client.delete(`/memories/${id}`);
+    }
+    async update(id, name) {
+        return await this.client.put(`/memories/${id}`, { name });
+    }
+    async connect(ids) {
+        const memories = await this.client.post("/memories/connect", {
+            ids: Array.isArray(ids) ? ids : [ids]
+        });
+        return (Array.isArray(ids) ? memories : memories[0]);
+    }
+    async importTmx(id, tmx, gzip = false) {
+        return await this.client.post(`/memories/${id}/import`, {
+            compression: gzip ? 'gzip' : undefined
+        }, {
+            tmx
+        });
+    }
+    async addTranslation(id, source, target, sentence, translation, tuid, sentenceBefore, sentenceAfter) {
+        const body = {
+            source,
+            target,
+            sentence,
+            translation,
+            tuid,
+            sentence_before: sentenceBefore,
+            sentence_after: sentenceAfter
+        };
+        if (Array.isArray(id)) {
+            body.ids = id;
+            return await this.client.put("/memories/content", body);
+        }
+        else {
+            return await this.client.put(`/memories/${id}/content`, body);
+        }
+    }
+    async deleteTranslation(id, source, target, sentence, translation, tuid, sentenceBefore, sentenceAfter) {
+        const body = {
+            source,
+            target,
+            sentence,
+            translation,
+            tuid,
+            sentence_before: sentenceBefore,
+            sentence_after: sentenceAfter
+        };
+        if (Array.isArray(id)) {
+            body.ids = id;
+            return await this.client.delete("/memories/content", body);
+        }
+        else {
+            return await this.client.delete(`/memories/${id}/content`, body);
+        }
+    }
+    async getImportStatus(id) {
+        return await this.client.get(`/memories/imports/${id}`);
+    }
+    async waitForImport(mImport, updateCallback, maxWaitTime) {
+        const start = Date.now();
+        while (mImport.progress < 1.) {
+            if (maxWaitTime && Date.now() - start > maxWaitTime)
+                throw new errors_1.TimeoutError();
+            await new Promise(resolve => setTimeout(resolve, this.pollingInterval));
+            mImport = await this.getImportStatus(mImport.id);
+            if (updateCallback)
+                updateCallback(mImport);
+        }
+        return mImport;
+    }
+}
+exports.Memories = Memories;
+class Translator {
+    constructor(credentials, options) {
+        this.client = (0, net_1.default)(credentials.accessKeyId, credentials.accessKeySecret, options === null || options === void 0 ? void 0 : options.serverUrl);
+        this.memories = new Memories(this.client);
+    }
+    async getLanguages() {
+        return await this.client.get("/languages");
+    }
+    async translate(text, source, target, options) {
+        return await this.client.post("/translate", {
+            q: text, source, target, source_hint: options === null || options === void 0 ? void 0 : options.sourceHint, content_type: options === null || options === void 0 ? void 0 : options.contentType,
+            multiline: (options === null || options === void 0 ? void 0 : options.multiline) !== false, adapt_to: options === null || options === void 0 ? void 0 : options.adaptTo,
+            instructions: options === null || options === void 0 ? void 0 : options.instructions, timeout: options === null || options === void 0 ? void 0 : options.timeoutInMillis
+        });
+    }
+}
+exports.Translator = Translator;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@translated/lara",
+  "version": "1.0.1",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "engines": {
+    "node": ">=12.*"
+  },
+  "scripts": {
+    "build": "rm -rf lib/* lib-browser/* && node scripts/generate-sdk-version.js && tsc && webpack"
+  },
+  "files": [
+    "lib",
+    "LICENSE"
+  ],
+  "keywords": [
+    "lara",
+    "ai",
+    "translate",
+    "translated",
+    "api"
+  ],
+  "author": {
+    "name": "Davide Caroselli",
+    "email": "davide.caroselli@translated.com"
+  },
+  "license": "MIT",
+  "homepage": "https://lara.translated.com",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/translated/lara-node.git"
+  },
+  "description": "Official Lara SDK for JavaScript and Node.js",
+  "dependencies": {
+    "form-data": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.14.2",
+    "typescript": "^5.4.5",
+    "webpack": "^5.91.0",
+    "webpack-cli": "^5.1.4"
+  }
+}