@translated/lara 1.7.0 → 1.7.2

package/lib/documents.d.ts

@@ -0,0 +1,57 @@
+import type { LaraClient } from "./net";
+import type { MultiPartFile } from "./net/client";
+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;
+};
+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>;
+    translate(file: MultiPartFile, filename: string, source: string | null, target: string, options?: DocumentTranslateOptions): Promise<Blob | Buffer>;
+}

package/lib/documents.js

@@ -0,0 +1,76 @@
+"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(`/documents/upload-url`, { filename });
+        await this.s3Client.upload(url, fields, file);
+        const headers = (options === null || options === void 0 ? void 0 : options.noTrace) ? { "X-No-Trace": "true" } : {};
+        return this.client.post("/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(`/documents/${id}`);
+    }
+    async download(id, options) {
+        const { url } = await this.client.get(`/documents/${id}/download-url`, {
+            output_format: options === null || options === void 0 ? void 0 : options.outputFormat
+        });
+        return await this.s3Client.download(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
+        };
+        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();
+    }
+}
+exports.Documents = Documents;

package/lib/glossaries.d.ts

@@ -0,0 +1,37 @@
+import type { LaraClient } from "./net";
+import type { MultiPartFile } from "./net/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("/glossaries");
+    }
+    async create(name) {
+        return await this.client.post("/glossaries", { name });
+    }
+    async get(id) {
+        try {
+            return await this.client.get(`/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(`/glossaries/${id}`);
+    }
+    async update(id, name) {
+        return await this.client.put(`/glossaries/${id}`, { name });
+    }
+    async importCsv(id, csv, gzip = false) {
+        return await this.client.post(`/glossaries/${id}/import`, {
+            compression: gzip ? "gzip" : undefined
+        }, {
+            csv
+        });
+    }
+    async getImportStatus(id) {
+        return await this.client.get(`/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(`/glossaries/${id}/counts`);
+    }
+    async export(id, contentType, source) {
+        return await this.client.get(`/glossaries/${id}/export`, {
+            content_type: contentType,
+            source
+        });
+    }
+}
+exports.Glossaries = Glossaries;

package/lib/index.d.ts

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

package/lib/index.js

@@ -1,17 +1,20 @@
 "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 = void 0;
 var credentials_1 = require("./credentials");
 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";
+import type { MultiPartFile } from "./net/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>;
+}

package/lib/memories.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memories = void 0;
+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, headers) {
+        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, undefined, headers);
+        }
+        else {
+            return await this.client.put(`/memories/${id}/content`, body, undefined, headers);
+        }
+    }
+    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.0) {
+            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;

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

@@ -4,5 +4,6 @@ export declare class BrowserLaraClient extends LaraClient {
     private readonly baseUrl;
     constructor(baseUrl: BaseURL, accessKeyId: string, accessKeySecret: string);
     protected send(path: string, headers: Record<string, string>, body?: Record<string, any>): Promise<ClientResponse>;
+    protected sendAndGetStream(path: string, headers: Record<string, string>, body?: Record<string, any>): AsyncGenerator<ClientResponse>;
     protected wrapMultiPartFile(file: MultiPartFile): File;
 }

package/lib/net/browser-client.js

@@ -53,6 +53,83 @@ class BrowserLaraClient extends client_1.LaraClient {
         }
         return { statusCode: response.status, body: await response.json() };
     }
+    async *sendAndGetStream(path, headers, body) {
+        let requestBody;
+        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)) {
+                        for (const v of value)
+                            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,
+            method: "POST",
+            body: requestBody
+        });
+        if (!response.body) {
+            throw new Error("Response body is not available for streaming");
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+            while (true) {
+                const readResult = await reader.read();
+                const { done, value } = readResult;
+                if (done) {
+                    // Process any remaining data in buffer
+                    if (buffer.trim()) {
+                        try {
+                            const json = JSON.parse(buffer);
+                            yield {
+                                statusCode: json.status || response.status,
+                                body: json.data || json
+                            };
+                        }
+                        catch (_e) {
+                            // Skip invalid JSON
+                        }
+                    }
+                    break;
+                }
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || ""; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    if (line.trim()) {
+                        try {
+                            const json = JSON.parse(line);
+                            yield {
+                                statusCode: json.status || response.status,
+                                body: json.data || json
+                            };
+                        }
+                        catch (_e) {
+                            // Skip invalid JSON lines
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
     wrapMultiPartFile(file) {
         if (file instanceof File)
             return file;

package/lib/net/client.d.ts

@@ -25,10 +25,13 @@ export declare abstract class LaraClient {
     get<T>(path: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
     delete<T>(path: string, params?: Record<string, any>, headers?: Record<string, string>): Promise<T>;
     post<T>(path: string, body?: Record<string, any>, files?: Record<string, MultiPartFile>, headers?: Record<string, string>): Promise<T>;
+    postAndGetStream<T>(path: string, body?: Record<string, any>, files?: Record<string, MultiPartFile>, headers?: Record<string, string>): AsyncGenerator<T>;
     put<T>(path: string, body?: Record<string, any>, files?: Record<string, MultiPartFile>, headers?: Record<string, string>): Promise<T>;
+    protected requestStream<T>(method: HttpMethod, path: string, body?: Record<string, any>, files?: Record<string, MultiPartFile>, headers?: Record<string, string>): AsyncGenerator<T>;
     protected request<T>(method: HttpMethod, path: string, body?: Record<string, any>, files?: Record<string, MultiPartFile>, headers?: Record<string, string>): Promise<T>;
     private sign;
     protected abstract send(path: string, headers: Record<string, string>, body?: Record<string, any>): Promise<ClientResponse>;
+    protected abstract sendAndGetStream(path: string, headers: Record<string, string>, body?: Record<string, any>): AsyncGenerator<ClientResponse>;
     protected abstract wrapMultiPartFile(file: MultiPartFile): any;
 }
 export {};

package/lib/net/client.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LaraClient = void 0;
 const crypto_1 = __importDefault(require("../crypto"));
 const errors_1 = require("../errors");
-const sdk_version_1 = require("../sdk-version");
+const sdk_version_1 = require("../utils/sdk-version");
 function parseContent(content) {
     if (content === undefined || content === null)
         return content;
@@ -49,9 +49,53 @@ class LaraClient {
     post(path, body, files, headers) {
         return this.request("POST", path, body, files, headers);
     }
+    async *postAndGetStream(path, body, files, headers) {
+        for await (const chunk of this.requestStream("POST", path, body, files, headers)) {
+            yield chunk;
+        }
+    }
     put(path, body, files, headers) {
         return this.request("PUT", path, body, files, headers);
     }
+    async *requestStream(method, path, body, files, headers) {
+        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,
+            ...this.extraHeaders,
+            ...headers
+        };
+        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;
+        if (files) {
+            // validate files
+            for (const [key, file] of Object.entries(files))
+                files[key] = this.wrapMultiPartFile(file);
+            _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}`;
+        for await (const chunk of this.sendAndGetStream(path, _headers, requestBody)) {
+            yield parseContent(chunk.body.content);
+        }
+    }
     async request(method, path, body, files, headers) {
         if (!path.startsWith("/"))
             path = `/${path}`;

package/lib/net/index.d.ts

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

package/lib/net/index.js

@@ -7,7 +7,7 @@ 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.laratranslate.com";
-function create(accessKeyId, accessKeySecret, baseUrl) {
+function create(accessKeyId, accessKeySecret, baseUrl, keepAlive) {
     const url = new URL(baseUrl || DEFAULT_BASE_URL);
     if (url.protocol !== "https:" && url.protocol !== "http:")
         throw new TypeError(`Invalid URL (protocol): ${url.protocol}`);
@@ -19,5 +19,5 @@ function create(accessKeyId, accessKeySecret, baseUrl) {
     if (typeof window !== "undefined")
         return new browser_client_1.BrowserLaraClient(parsedURL, accessKeyId, accessKeySecret);
     else
-        return new node_client_1.NodeLaraClient(parsedURL, accessKeyId, accessKeySecret);
+        return new node_client_1.NodeLaraClient(parsedURL, accessKeyId, accessKeySecret, keepAlive !== null && keepAlive !== void 0 ? keepAlive : true);
 }

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

@@ -4,7 +4,8 @@ import { type BaseURL, type ClientResponse, LaraClient, type MultiPartFile } fro
 export declare class NodeLaraClient extends LaraClient {
     private readonly baseUrl;
     private readonly agent;
-    constructor(baseUrl: BaseURL, accessKeyId: string, accessKeySecret: string);
+    constructor(baseUrl: BaseURL, accessKeyId: string, accessKeySecret: string, keepAlive?: boolean);
     protected send(path: string, headers: Record<string, string>, body?: Record<string, any>): Promise<ClientResponse>;
+    protected sendAndGetStream(path: string, headers: Record<string, string>, body?: Record<string, any>): AsyncGenerator<ClientResponse>;
     protected wrapMultiPartFile(file: MultiPartFile): Readable;
 }