@translated/lara 1.6.6 → 2.0.0-beta.0

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;
+}

package/lib/Translator.js

@@ -0,0 +1,152 @@
+import axios from 'axios';
+import Memories from './Memories';
+import { version } from './sdk-version';
+import Glossaries from './Glossaries';
+import Documents from './Documents';
+import toCamelCase from './utils/toCamelCase';
+const DEFAULT_BASE_URL = 'https://api.laratranslate.com';
+export class Translator {
+    constructor(accessKey, credentials, authToken, options) {
+        var _a;
+        this.accessKey = accessKey;
+        this.credentials = credentials;
+        this.authToken = authToken;
+        this.options = options || {};
+        this.client = axios.create({
+            baseURL: (_a = options === null || options === void 0 ? void 0 : options.serverUrl) !== null && _a !== void 0 ? _a : DEFAULT_BASE_URL,
+            headers: {
+                'X-Lara-SDK-Name': 'lara-node',
+                'X-Lara-SDK-Version': version,
+                'X-Lara-Date': new Date().toUTCString(),
+                ...((options === null || options === void 0 ? void 0 : options.extraHeaders) || {}),
+            },
+        });
+        // Intercept request to add authentication header
+        this.client.interceptors.request.use(async (request) => {
+            const token = await this.authenticate();
+            request.headers.Authorization = `Bearer ${token}`;
+            return request;
+        }, Promise.reject);
+        // Intercepts errors to handle authentication errors
+        this.client.interceptors.response.use((response) => {
+            response.data && console.log(response.data);
+            // Convert payload in camel case if needed
+            if (response.data && typeof response.data === 'object') {
+                response.data = toCamelCase(response.data);
+            }
+            return response;
+        }, async (error) => {
+            const originalRequest = error.config;
+            if (originalRequest.isRetry)
+                return Promise.reject(error);
+            if (error.response && error.response.status === 401 && error.response.message === 'jwt expired') {
+                this.token = undefined;
+                const token = await this.authenticate();
+                originalRequest.isRetry = true;
+                originalRequest.headers.Authorization = `Bearer ${token}`;
+                return this.client(originalRequest);
+            }
+            return Promise.reject(error);
+        });
+        this.memories = new Memories(this.client);
+        this.glossaries = new Glossaries(this.client);
+        this.documents = new Documents(this.client);
+    }
+    async authenticate() {
+        var _a, _b, _c, _d, _e, _f;
+        // If the token is set, return it
+        if (this.token)
+            return this.token;
+        // If we have a refresh token, use it to get a new token
+        if (this.refreshToken) {
+            const { data } = await axios.post(`${(_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.serverUrl) !== null && _b !== void 0 ? _b : DEFAULT_BASE_URL}/v2/auth/refresh`, null, {
+                headers: {
+                    authorization: `Bearer ${this.refreshToken}`,
+                    'X-Lara-Date': new Date().toUTCString(),
+                },
+            });
+            this.token = data.token;
+            this.refreshToken = data.refresh_token;
+            return this.token;
+        }
+        else if (this.accessKey) {
+            // Use access key to get a new token
+            const { data } = await axios.post(`${(_d = (_c = this.options) === null || _c === void 0 ? void 0 : _c.serverUrl) !== null && _d !== void 0 ? _d : DEFAULT_BASE_URL}/v2/auth`, this.accessKey, {
+                headers: {
+                    'X-Lara-Date': new Date().toUTCString(),
+                },
+            });
+            this.token = data.token;
+            this.refreshToken = data.refresh_token;
+            return this.token;
+        }
+        else if (this.credentials) {
+            // Use credentials to get a new token
+            const { data } = await axios.post(
+            //FIXME: client id should be set
+            `${(_f = (_e = this.options) === null || _e === void 0 ? void 0 : _e.serverUrl) !== null && _f !== void 0 ? _f : DEFAULT_BASE_URL}/v2/auth/Unknown/login`, this.credentials, {
+                headers: {
+                    'X-Lara-Date': new Date().toUTCString(),
+                },
+            });
+            this.token = data.token;
+            this.refreshToken = data.refresh_token;
+            return this.token;
+        }
+        else if (this.authToken) {
+            // Use the provided auth token
+            this.token = this.authToken.token;
+            this.refreshToken = this.authToken.refresh_token;
+            this.authToken = undefined;
+            return this.token;
+        }
+        else {
+            throw new Error('No authentication method provided');
+        }
+    }
+    async translate(text, source, target, options) {
+        const headers = {};
+        if (options === null || options === void 0 ? void 0 : options.headers) {
+            for (const [name, value] of Object.entries(options.headers)) {
+                headers[name] = value;
+            }
+        }
+        if (options === null || options === void 0 ? void 0 : options.noTrace)
+            headers['X-No-Trace'] = 'true';
+        const { data } = await this.client.post(`/v2/translate`, {
+            q: text,
+            source: !!source ? source : undefined,
+            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,
+            glossaries: options === null || options === void 0 ? void 0 : options.glossaries,
+            instructions: options === null || options === void 0 ? void 0 : options.instructions,
+            timeout: options === null || options === void 0 ? void 0 : options.timeoutInMillis,
+            priority: options === null || options === void 0 ? void 0 : options.priority,
+            use_cache: options === null || options === void 0 ? void 0 : options.useCache,
+            cache_ttl: options === null || options === void 0 ? void 0 : options.cacheTTLSeconds,
+            verbose: options === null || options === void 0 ? void 0 : options.verbose,
+            style: options === null || options === void 0 ? void 0 : options.style,
+        }, headers);
+        return data;
+    }
+    async getLanguages() {
+        const { data } = await this.client.get(`/v2/languages`);
+        return data;
+    }
+    static async getLoginUrl(serverUrl) {
+        const { data } = await axios.get(`${serverUrl !== null && serverUrl !== void 0 ? serverUrl : DEFAULT_BASE_URL}/v2/auth/login-page`);
+        return data;
+    }
+    static byAccessKey(id, secret, options) {
+        return new Translator({ id, secret }, undefined, undefined, options);
+    }
+    static byCredentials(email, password, options) {
+        return new Translator(undefined, { email, password }, undefined, options);
+    }
+    static byAuthToken(token, refresh_token, options) {
+        return new Translator(undefined, undefined, { token, refresh_token }, options);
+    }
+}

package/lib/index.d.ts

@@ -1,6 +1,2 @@
-export { Credentials } from "./credentials";
-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 * from './Translator';
+export * from './models';

package/lib/index.js

@@ -1,17 +1,2 @@
-"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;
-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, "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; } });
-Object.defineProperty(exports, "Translator", { enumerable: true, get: function () { return translator_1.Translator; } });
+export * from './Translator';
+export * from './models';

package/lib/models/Authentication.d.ts

@@ -0,0 +1,12 @@
+export type AccessKey = {
+    id: string;
+    secret: string;
+};
+export type AuthToken = {
+    token: string;
+    refresh_token: string;
+};
+export type Credentials = {
+    email: string;
+    password: string;
+};

package/lib/models/Authentication.js

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

package/lib/models/UploadableFile.d.ts

@@ -0,0 +1 @@
+export type UploadableFile = File | import('stream').Readable;

package/lib/models/UploadableFile.js

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

package/lib/models/documents.d.ts

@@ -0,0 +1,51 @@
+import { TranslationStyle } from './translator';
+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 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 type DocumentOptions = {
+    adaptTo?: string[];
+    glossaries?: string[];
+    noTrace?: boolean;
+    style?: TranslationStyle;
+};
+export type DocumentUploadOptions = DocumentOptions & {
+    password?: string;
+    extractionParams?: DocxExtractionParams;
+};
+export type DocumentDownloadOptions = {
+    outputFormat?: string;
+};
+export type DocumentTranslateOptions = DocumentUploadOptions & DocumentDownloadOptions;
+export interface DocxExtractionParams {
+    extractComments?: boolean;
+    accepsRevisions?: boolean;
+}
+interface S3UploadFields {
+    acl: string;
+    bucket: string;
+    key: string;
+}
+export interface UploadUrlData {
+    url: string;
+    fields: S3UploadFields;
+}
+export {};

package/lib/{translator/models.js → models/documents.js}

@@ -1,8 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentStatus = void 0;
-// biome-ignore format: keep comments aligned
-var DocumentStatus;
+export var DocumentStatus;
 (function (DocumentStatus) {
     DocumentStatus["INITIALIZED"] = "initialized";
     DocumentStatus["ANALYZING"] = "analyzing";
@@ -11,4 +7,4 @@ var DocumentStatus;
     DocumentStatus["TRANSLATING"] = "translating";
     DocumentStatus["TRANSLATED"] = "translated";
     DocumentStatus["ERROR"] = "error";
-})(DocumentStatus || (exports.DocumentStatus = DocumentStatus = {}));
+})(DocumentStatus || (DocumentStatus = {}));

package/lib/models/glossaries.d.ts

@@ -0,0 +1,19 @@
+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;
+}

package/lib/models/glossaries.js

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

package/lib/models/index.d.ts

@@ -0,0 +1,6 @@
+export * from './Authentication';
+export * from './documents';
+export * from './glossaries';
+export * from './memories';
+export * from './translator';
+export * from './UploadableFile';

package/lib/models/index.js

@@ -0,0 +1,6 @@
+export * from './Authentication';
+export * from './documents';
+export * from './glossaries';
+export * from './memories';
+export * from './translator';
+export * from './UploadableFile';

package/lib/models/memories.d.ts

@@ -0,0 +1,19 @@
+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;
+}

package/lib/models/memories.js

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