@language-weaver/lw-sdk-js 1.0.0

package/lib/EdgeLanguageWeaverClient.d.ts

@@ -0,0 +1,60 @@
+import { LanguageWeaverClient } from './LanguageWeaverClient';
+import ClientConfiguration from './common/configurations/ClientConfiguration';
+import EdgeLanguagePairsResult from './translation/translate/result/edge/EdgeLanguagePairsResult';
+import TranslateTextRequest from './translation/translate/request/TranslateTextRequest';
+import EdgeTranslateTextRequest from './translation/translate/request/edge/EdgeTranslateTextRequest';
+import EdgeTranslationTextResult from './translation/translate/result/edge/EdgeTranslationTextResult';
+import TranslateTextResult from './translation/translate/result/TranslateTextResult';
+import TokenConfiguration from './common/configurations/TokenConfiguration';
+import TranslateFileRequest from './translation/translate/request/TranslateFileRequest';
+import TranslationFileResult from './translation/translate/result/TranslationFileResult';
+import EdgeTranslateFileRequest from './translation/translate/request/edge/EdgeTranslateFileRequest';
+import EdgeTranslationFileResult from './translation/translate/result/edge/EdgeTranslationFileResult';
+import LanguagePairsResult from './translation/translate/result/LanguagePairsResult';
+import EdgeTranslateBatchFileRequest from './translation/translate/request/edge/EdgeTranslateBatchFileRequest';
+import EdgeTranslationBatchFileResult from './translation/translate/result/edge/EdgeTranslationBatchFileResult';
+import TranslateBatchFileRequest from './translation/translate/request/TranslateBatchFileRequest';
+import TranslationBatchFileResult from './translation/translate/result/TranslationBatchFileResult';
+import DictionariesResult from './translation/translate/result/DictionariesResult';
+import EdgeDictionariesResult from './translation/translate/result/edge/EdgeDictionariesResult';
+export default class EdgeLanguageWeaverClient implements LanguageWeaverClient {
+    private _clientConfiguration;
+    private _url;
+    private _overwriteUrl;
+    private _token;
+    private _client;
+    constructor();
+    withConfigurations(clientConfiguration: ClientConfiguration): EdgeLanguageWeaverClient;
+    withTokenConfigurations(tokenConfiguration: TokenConfiguration): EdgeLanguageWeaverClient;
+    build(): Promise<EdgeLanguageWeaverClient>;
+    get overwriteUrl(): string | undefined;
+    set overwriteUrl(value: string | undefined);
+    translateTextUsingEdgeParams(translateTextRequest: EdgeTranslateTextRequest): Promise<EdgeTranslationTextResult>;
+    translateFileUsingEdgeParams(translateFileRequest: EdgeTranslateFileRequest): Promise<EdgeTranslationFileResult>;
+    translateBatchFileUsingEdgeParams(translateBatchFileRequest: EdgeTranslateBatchFileRequest): Promise<EdgeTranslationBatchFileResult>;
+    translateText(translateTextRequest: TranslateTextRequest): Promise<TranslateTextResult>;
+    translateFile(translateFileRequest: TranslateFileRequest): Promise<TranslationFileResult>;
+    translateBatchFile(translateBatchFileRequest: TranslateBatchFileRequest): Promise<TranslationBatchFileResult>;
+    getLanguagePairs(): Promise<LanguagePairsResult>;
+    getEdgeLanguagePairs(): Promise<EdgeLanguagePairsResult>;
+    getDictionaries(page: number, perPage?: number): Promise<DictionariesResult>;
+    getEdgeDictionaries(page: number, perPage?: number): Promise<EdgeDictionariesResult>;
+    private getEdgeLanguagePairsPromise;
+    private translate;
+    private requestTranslateText;
+    private requestTranslateFile;
+    private handleStatusResponse;
+    private requestTranslateBatchFile;
+    private translateFileFromBatch;
+    private translateSyncText;
+    private translateAsyncText;
+    private getTextTranslationResponse;
+    private getFileTranslationResponse;
+    private retrieveTranslation;
+    private obtainFinalStatus;
+    private getEdgeTranslateTextRequest;
+    private hasToken;
+    private hasCredentialsConfiguration;
+    private setUrl;
+    private getLanguagePairForGivenData;
+}

package/lib/EdgeLanguageWeaverClient.js

@@ -0,0 +1,580 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ClientConfiguration_1 = __importDefault(require("./common/configurations/ClientConfiguration"));
+var Token_1 = __importDefault(require("./auth/domain/Token"));
+var Product_1 = require("./translation/common/Product");
+var TranslationConstants_1 = require("./common/constants/TranslationConstants");
+var RestClient_1 = __importDefault(require("./common/requests/RestClient"));
+var EdgeTranslateTextRequest_1 = __importDefault(require("./translation/translate/request/edge/EdgeTranslateTextRequest"));
+var EdgeTranslationTextResult_1 = __importDefault(require("./translation/translate/result/edge/EdgeTranslationTextResult"));
+var EdgeStatuses_1 = require("./common/constants/EdgeStatuses");
+var EdgeFinalSubStatuses_1 = require("./common/constants/EdgeFinalSubStatuses");
+var EdgeTranslationException_1 = __importDefault(require("./common/exceptions/EdgeTranslationException"));
+var Statuses_1 = require("./translation/common/Statuses");
+var Utils_1 = __importDefault(require("./common/utils/Utils"));
+var EdgeTranslateFileRequest_1 = __importDefault(require("./translation/translate/request/edge/EdgeTranslateFileRequest"));
+var EdgeTranslationFileResult_1 = __importDefault(require("./translation/translate/result/edge/EdgeTranslationFileResult"));
+var TranslateFileUtil_1 = require("./translation/translate/utils/TranslateFileUtil");
+var LanguagePairsResult_1 = __importDefault(require("./translation/translate/result/LanguagePairsResult"));
+var LanguagePair_1 = __importDefault(require("./translation/translate/response/LanguagePair"));
+var EdgeTranslateBatchFileRequest_1 = __importDefault(require("./translation/translate/request/edge/EdgeTranslateBatchFileRequest"));
+var EdgeTranslationBatchFileResult_1 = __importDefault(require("./translation/translate/result/edge/EdgeTranslationBatchFileResult"));
+var DictionariesResult_1 = __importDefault(require("./translation/translate/result/DictionariesResult"));
+var DictionaryResponse_1 = __importDefault(require("./translation/translate/response/DictionaryResponse"));
+var FormatToMimeType_1 = require("./common/constants/FormatToMimeType");
+var EdgeLanguageWeaverClient = /** @class */ (function () {
+    function EdgeLanguageWeaverClient() {
+        this._clientConfiguration = new ClientConfiguration_1.default();
+        this._url = TranslationConstants_1.EDGE_DEFAULT_URL;
+        this._client = new RestClient_1.default(this._url);
+    }
+    EdgeLanguageWeaverClient.prototype.withConfigurations = function (clientConfiguration) {
+        this._clientConfiguration = clientConfiguration;
+        this._clientConfiguration.product = Product_1.Product.EDGE;
+        return this;
+    };
+    EdgeLanguageWeaverClient.prototype.withTokenConfigurations = function (tokenConfiguration) {
+        this._token = tokenConfiguration.token;
+        return this;
+    };
+    EdgeLanguageWeaverClient.prototype.build = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var encoding;
+            return __generator(this, function (_b) {
+                this.setUrl();
+                if (!this.hasToken() && this.hasCredentialsConfiguration()) {
+                    encoding = Utils_1.default.encodeStringToBase64(((_a = this._clientConfiguration) === null || _a === void 0 ? void 0 : _a.credentialsConfiguration.clientId) + ':');
+                    this._token = new Token_1.default(encoding, undefined, 'Basic');
+                }
+                return [2 /*return*/, this];
+            });
+        });
+    };
+    Object.defineProperty(EdgeLanguageWeaverClient.prototype, "overwriteUrl", {
+        get: function () {
+            return this._overwriteUrl;
+        },
+        set: function (value) {
+            this._overwriteUrl = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    EdgeLanguageWeaverClient.prototype.translateTextUsingEdgeParams = function (translateTextRequest) {
+        return this.translate(translateTextRequest);
+    };
+    EdgeLanguageWeaverClient.prototype.translateFileUsingEdgeParams = function (translateFileRequest) {
+        return this.requestTranslateFile(translateFileRequest);
+    };
+    EdgeLanguageWeaverClient.prototype.translateBatchFileUsingEdgeParams = function (translateBatchFileRequest) {
+        return this.requestTranslateBatchFile(translateBatchFileRequest);
+    };
+    EdgeLanguageWeaverClient.prototype.translateText = function (translateTextRequest) {
+        var _this = this;
+        var sourceLanguageId = translateTextRequest.sourceLanguageId, targetLanguageId = translateTextRequest.targetLanguageId, model = translateTextRequest.model;
+        if (!sourceLanguageId || !targetLanguageId || !model) {
+            return Promise.reject({ message: TranslationConstants_1.LANGUAGE_PAIR_NOT_FOUND_ERROR });
+        }
+        else {
+            return this.getLanguagePairForGivenData(sourceLanguageId, targetLanguageId, model)
+                .then(function (lp) {
+                var request = new EdgeTranslateTextRequest_1.default();
+                request.input = translateTextRequest.input;
+                request.languagePairId = lp.languagePairId;
+                request.inputFormat = translateTextRequest.inputFormat;
+                request.dictionaries = translateTextRequest.dictionaries;
+                return _this.translate(request);
+            })
+                .catch(function (error) { return Promise.reject(error); });
+        }
+    };
+    EdgeLanguageWeaverClient.prototype.translateFile = function (translateFileRequest) {
+        var _this = this;
+        var sourceLanguageId = translateFileRequest.sourceLanguageId, targetLanguageId = translateFileRequest.targetLanguageId, model = translateFileRequest.model;
+        if (!sourceLanguageId || !targetLanguageId || !model) {
+            return Promise.reject({ message: TranslationConstants_1.LANGUAGE_PAIR_NOT_FOUND_ERROR });
+        }
+        else {
+            return this.getLanguagePairForGivenData(sourceLanguageId, targetLanguageId, model)
+                .then(function (lp) {
+                var request = new EdgeTranslateFileRequest_1.default();
+                request.input = translateFileRequest.input;
+                request.outputDir = translateFileRequest.outputDir;
+                request.outputFile = translateFileRequest.outputFile;
+                request.languagePairId = lp.languagePairId;
+                request.dictionaries = translateFileRequest.dictionaries;
+                return _this.requestTranslateFile(request);
+            })
+                .catch(function (error) { return Promise.reject(error); });
+        }
+    };
+    EdgeLanguageWeaverClient.prototype.translateBatchFile = function (translateBatchFileRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var sourceLanguageId, targetLanguageId, model, edgeLanguagePair, request;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sourceLanguageId = translateBatchFileRequest.sourceLanguageId, targetLanguageId = translateBatchFileRequest.targetLanguageId, model = translateBatchFileRequest.model;
+                        if (!(!sourceLanguageId || !targetLanguageId || !model)) return [3 /*break*/, 1];
+                        return [2 /*return*/, Promise.reject({ message: TranslationConstants_1.LANGUAGE_PAIR_NOT_FOUND_ERROR })];
+                    case 1: return [4 /*yield*/, this.getLanguagePairForGivenData(sourceLanguageId, targetLanguageId, model)];
+                    case 2:
+                        edgeLanguagePair = _a.sent();
+                        request = new EdgeTranslateBatchFileRequest_1.default();
+                        request.input = translateBatchFileRequest.input;
+                        request.outputDir = translateBatchFileRequest.outputDir;
+                        request.dictionaries = translateBatchFileRequest.dictionaries;
+                        request.languagePairId = edgeLanguagePair.languagePairId;
+                        return [2 /*return*/, this.requestTranslateBatchFile(request)];
+                }
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getLanguagePairs = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var edgeResult, languagePairs_1, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getEdgeLanguagePairs()];
+                    case 1:
+                        edgeResult = _b.sent();
+                        languagePairs_1 = [];
+                        (_a = edgeResult.languagePairs) === null || _a === void 0 ? void 0 : _a.forEach(function (lp) {
+                            var languagePair = new LanguagePair_1.default();
+                            languagePair.sourceLanguageId = lp.sourceLanguageId;
+                            languagePair.targetLanguageId = lp.targetLanguageId;
+                            languagePair.model = lp.domain;
+                            languagePair.name = lp.languagePairId;
+                            languagePairs_1.push(languagePair);
+                        });
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                var result = new LanguagePairsResult_1.default();
+                                result.languagePairs = languagePairs_1;
+                                resolve(result);
+                            })];
+                    case 2:
+                        e_1 = _b.sent();
+                        return [2 /*return*/, Promise.reject(e_1)];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getEdgeLanguagePairs = function () {
+        return this.getEdgeLanguagePairsPromise()
+            .then(function (response) {
+            return Promise.resolve(response);
+        })
+            .catch(function (e) {
+            return Promise.reject(e);
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getDictionaries = function (page, perPage) {
+        var _a;
+        if (perPage === void 0) { perPage = TranslationConstants_1.DEFAULT_DICTIONARIES_PAGE_SIZE; }
+        return __awaiter(this, void 0, void 0, function () {
+            var edgeDictionariesResult, dictionaries_1, e_2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.getEdgeDictionaries(page, perPage)];
+                    case 1:
+                        edgeDictionariesResult = _b.sent();
+                        dictionaries_1 = [];
+                        (_a = edgeDictionariesResult.dictionaries) === null || _a === void 0 ? void 0 : _a.forEach(function (dictionary) {
+                            var dictionaryResponse = new DictionaryResponse_1.default();
+                            dictionaryResponse.id = dictionary.dictionaryId;
+                            dictionaryResponse.source = dictionary.sourceLanguageId;
+                            dictionaryResponse.target = dictionary.targetLanguageId;
+                            dictionaries_1.push(dictionaryResponse);
+                        });
+                        return [2 /*return*/, new Promise(function (resolve) {
+                                var result = new DictionariesResult_1.default();
+                                result.dictionaries = dictionaries_1;
+                                resolve(result);
+                            })];
+                    case 2:
+                        e_2 = _b.sent();
+                        return [2 /*return*/, Promise.reject(e_2)];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getEdgeDictionaries = function (page, perPage) {
+        if (perPage === void 0) { perPage = TranslationConstants_1.DEFAULT_DICTIONARIES_PAGE_SIZE; }
+        return this._client
+            .requestJson(this._token, 'GET', TranslationConstants_1.EDGE_GET_ALL_DICTIONARIES_PATH, undefined, { page: page, perPage: perPage })
+            .then(function (response) {
+            return Promise.resolve(response);
+        })
+            .catch(function (e) {
+            return Promise.reject(e);
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getEdgeLanguagePairsPromise = function () {
+        return this._client.requestJson(this._token, 'GET', TranslationConstants_1.EDGE_LANGUAGE_PAIRS_PATH);
+    };
+    EdgeLanguageWeaverClient.prototype.translate = function (request) {
+        if (request.input && request.input.length > 1) {
+            return Promise.reject({
+                message: 'Array translation is supported only for CLOUD specific implementation. Please provide single input or use CloudLanguageWeaverClient.',
+            });
+        }
+        return this.requestTranslateText(request)
+            .then(function (response) {
+            var _a;
+            response.translation = ((_a = response.translation) === null || _a === void 0 ? void 0 : _a.length)
+                ? Utils_1.default.decodeStringFromBase64(response.translation)
+                : '';
+            return Promise.resolve(response);
+        })
+            .catch(function (error) { return Promise.reject(error); });
+    };
+    EdgeLanguageWeaverClient.prototype.requestTranslateText = function (translateTextRequest) {
+        var encodedText = Utils_1.default.encodeStringToBase64(translateTextRequest.input[0]);
+        translateTextRequest.input = [encodedText];
+        if (Utils_1.default.getInputSize(translateTextRequest.input) < TranslationConstants_1.SYNC_SIZE_LIMIT) {
+            return this.translateSyncText(translateTextRequest);
+        }
+        else {
+            return this.translateAsyncText(translateTextRequest);
+        }
+    };
+    EdgeLanguageWeaverClient.prototype.requestTranslateFile = function (translateFileRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validationError, fileSize, request, formData, translationPromise;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!translateFileRequest.languagePairId) {
+                            return [2 /*return*/, new Promise(function (resolve, reject) { return reject({ message: TranslationConstants_1.MISSING_REQUIRED_LANGUAGE_PAIR_ID }); })];
+                        }
+                        validationError = (0, TranslateFileUtil_1.validateInputDataForFileTranslation)(translateFileRequest);
+                        if (validationError) {
+                            return [2 /*return*/, Promise.reject({ message: validationError })];
+                        }
+                        fileSize = translateFileRequest.input ? Utils_1.default.getFileSize(translateFileRequest.input) : 0;
+                        return [4 /*yield*/, this.getEdgeTranslateTextRequest(translateFileRequest)];
+                    case 1:
+                        request = _a.sent();
+                        formData = createBodyForTranslationTextRequest(request);
+                        translationPromise = this._client.requestMultipart(this._token, 'POST', TranslationConstants_1.EDGE_ASYNC_TRANSLATION_PATH, formData);
+                        return [2 /*return*/, translationPromise
+                                .then(function (translationResponse) {
+                                var statusPromise = _this.obtainFinalStatus(translationResponse.translationId, fileSize);
+                                return _this.handleStatusResponse(translationResponse.translationId, statusPromise, function (statusResponse) {
+                                    var _a;
+                                    return _this.getFileTranslationResponse(translationResponse.translationId, translateFileRequest, request.outputFormat, (_a = statusResponse.profile) === null || _a === void 0 ? void 0 : _a.languagePairId);
+                                });
+                            })
+                                .catch(function (error) { return Promise.reject(error); })];
+                }
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.handleStatusResponse = function (translationId, statusPromise, successHandler) {
+        return statusPromise
+            .then(function (statusResponse) {
+            if (statusResponse.state === EdgeStatuses_1.DONE) {
+                switch (statusResponse.substate) {
+                    case EdgeFinalSubStatuses_1.SUCCEEDED:
+                        return Promise.resolve(successHandler(statusResponse));
+                    case EdgeFinalSubStatuses_1.FAILED:
+                        return Promise.reject(EdgeTranslationException_1.default.getTranslationException(statusResponse.substate, translationId, statusResponse.errorMessage));
+                    case EdgeFinalSubStatuses_1.CANCELED:
+                        return Promise.reject(EdgeTranslationException_1.default.getTranslationException(statusResponse.substate, translationId));
+                    default:
+                        return Promise.reject(EdgeTranslationException_1.default.getTranslationException(Statuses_1.UNK_TRANSLATION_STATUS, translationId));
+                }
+            }
+            else {
+                return Promise.reject(EdgeTranslationException_1.default.getTranslationException(statusResponse.substate, translationId, TranslationConstants_1.TRANSLATION_TIMEOUT));
+            }
+        })
+            .catch(function (error) { return Promise.reject(error); });
+    };
+    EdgeLanguageWeaverClient.prototype.requestTranslateBatchFile = function (translateBatchFileRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var validationError, files, promises;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!translateBatchFileRequest.languagePairId) {
+                            return [2 /*return*/, new Promise(function (resolve, reject) { return reject({ message: TranslationConstants_1.MISSING_REQUIRED_LANGUAGE_PAIR_ID }); })];
+                        }
+                        return [4 /*yield*/, (0, TranslateFileUtil_1.validateInputDataForBatchFileTranslation)(translateBatchFileRequest)];
+                    case 1:
+                        validationError = _a.sent();
+                        if (validationError) {
+                            return [2 /*return*/, Promise.reject({ message: validationError })];
+                        }
+                        return [4 /*yield*/, (0, TranslateFileUtil_1.getInputFilesFromBatchFileRequest)(translateBatchFileRequest)];
+                    case 2:
+                        files = _a.sent();
+                        promises = [];
+                        files.forEach(function (file) {
+                            promises.push(_this.translateFileFromBatch(file, translateBatchFileRequest));
+                        });
+                        return [2 /*return*/, Promise.allSettled(promises).then(function (results) {
+                                var fileResults = [];
+                                results.forEach(function (result) {
+                                    if (result.status === 'fulfilled') {
+                                        fileResults.push(result.value);
+                                    }
+                                });
+                                var translationResult = new EdgeTranslationBatchFileResult_1.default();
+                                translationResult.translationFileResults = fileResults;
+                                return Promise.resolve(translationResult);
+                            })];
+                }
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.translateFileFromBatch = function (file, translateBatchFileRequest) {
+        var inputFileFormat = Utils_1.default.getFormatForFile(file);
+        var request = new EdgeTranslateFileRequest_1.default();
+        request.languagePairId = translateBatchFileRequest.languagePairId;
+        request.outputFormat = translateBatchFileRequest.outputFormat;
+        request.title = translateBatchFileRequest.title;
+        request.dictionaries = translateBatchFileRequest.dictionaries;
+        request.encoding = translateBatchFileRequest.encoding;
+        request.inputFormat = inputFileFormat;
+        request.input = file;
+        if (!Utils_1.default.isBrowser() && typeof translateBatchFileRequest.outputDir === 'string') {
+            request.outputDir = translateBatchFileRequest.outputDir;
+        }
+        return this.requestTranslateFile(request);
+    };
+    EdgeLanguageWeaverClient.prototype.translateSyncText = function (translateTextRequest) {
+        var error = validateRequiredFields(translateTextRequest);
+        if (error) {
+            return new Promise(function (resolve, reject) { return reject(error); });
+        }
+        var formData = createBodyForTranslationTextRequest(translateTextRequest);
+        return this._client.requestMultipart(this._token, 'POST', TranslationConstants_1.EDGE_QUICK_TRANSLATION_PATH, formData);
+    };
+    EdgeLanguageWeaverClient.prototype.translateAsyncText = function (translateTextRequest) {
+        var _this = this;
+        var error = validateRequiredFields(translateTextRequest);
+        if (error) {
+            return new Promise(function (resolve, reject) { return reject(error); });
+        }
+        var formData = createBodyForTranslationTextRequest(translateTextRequest);
+        var translationPromise = this._client.requestMultipart(this._token, 'POST', TranslationConstants_1.EDGE_ASYNC_TRANSLATION_PATH, formData);
+        return translationPromise
+            .then(function (translationResponse) {
+            var statusPromise = _this.obtainFinalStatus(translationResponse.translationId, translateTextRequest.input[0].length);
+            return _this.handleStatusResponse(translationResponse.translationId, statusPromise, function () {
+                return _this.getTextTranslationResponse(translationResponse.translationId);
+            });
+        })
+            .catch(function (e) { return Promise.reject(e); });
+    };
+    EdgeLanguageWeaverClient.prototype.getTextTranslationResponse = function (requestId) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.retrieveTranslation(requestId)
+                .then(function (contentResponse) {
+                var textTranslationResult = new EdgeTranslationTextResult_1.default();
+                textTranslationResult.translation = contentResponse.data;
+                resolve(textTranslationResult);
+            })
+                .catch(function (error) { return reject(error); });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getFileTranslationResponse = function (requestId, translateFileRequest, outputFormat, languagePairId) {
+        var _this = this;
+        return new Promise(function (resolve, reject) {
+            _this.retrieveTranslation(requestId)
+                .then(function (contentResponse) { return __awaiter(_this, void 0, void 0, function () {
+                var edgeTranslationFileResult, fs;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            edgeTranslationFileResult = new EdgeTranslationFileResult_1.default();
+                            edgeTranslationFileResult.languagePairId = languagePairId;
+                            edgeTranslationFileResult.requestId = requestId;
+                            edgeTranslationFileResult.fileContent = contentResponse.data;
+                            if (Utils_1.default.isBrowser()) {
+                                if (translateFileRequest.input instanceof File) {
+                                    edgeTranslationFileResult.filename = (0, TranslateFileUtil_1.getFileNameFromHeaders)(contentResponse, translateFileRequest);
+                                    edgeTranslationFileResult.mimeType =
+                                        outputFormat ||
+                                            FormatToMimeType_1.formatToMimeType[Utils_1.default.getFormatForFile(edgeTranslationFileResult.filename)];
+                                    edgeTranslationFileResult.fileContent = Utils_1.default.decodeStringFromBase64ToBlob(contentResponse.data);
+                                }
+                            }
+                            if (!(translateFileRequest.outputDir && !Utils_1.default.isBrowser())) return [3 /*break*/, 2];
+                            fs = require('fs');
+                            return [4 /*yield*/, fs.promises.writeFile(Utils_1.default.getFullPath(translateFileRequest.outputDir, (0, TranslateFileUtil_1.getFileNameFromHeaders)(contentResponse, translateFileRequest)), contentResponse.data, { encoding: 'base64' }, function (error) { return reject(error); })];
+                        case 1:
+                            _a.sent();
+                            _a.label = 2;
+                        case 2:
+                            resolve(edgeTranslationFileResult);
+                            return [2 /*return*/];
+                    }
+                });
+            }); })
+                .catch(function (error) {
+                reject(error);
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.retrieveTranslation = function (requestId) {
+        return this._client.requestJson(this._token, 'GET', TranslationConstants_1.EDGE_ASYNC_TRANSLATION_PATH + '/' + requestId + '/download', undefined, undefined, { headersNeeded: true });
+    };
+    EdgeLanguageWeaverClient.prototype.obtainFinalStatus = function (requestId, fileSize) {
+        var self = this;
+        return new Promise(function (resolve, reject) {
+            var delay = fileSize < 500 ? TranslationConstants_1.SMALL_INPUT_GET_TRANSLATION_STATUS_DELAY : TranslationConstants_1.LARGE_INPUT_GET_TRANSLATION_STATUS_DELAY;
+            var startTime = new Date().getTime();
+            getStatus();
+            function getStatus() {
+                self._client
+                    .requestJson(self._token, 'GET', TranslationConstants_1.EDGE_ASYNC_TRANSLATION_PATH + '/' + requestId)
+                    .then(function (statusResponse) {
+                    if ([EdgeStatuses_1.PREPARING, EdgeStatuses_1.IN_PROGRESS].includes(statusResponse.state) &&
+                        new Date().getTime() - startTime < TranslationConstants_1.CHECK_STATUS_TIMEOUT) {
+                        setTimeout(function () {
+                            getStatus();
+                        }, delay);
+                    }
+                    else {
+                        resolve(statusResponse);
+                    }
+                })
+                    .catch(function (e) { return reject(e); });
+            }
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.getEdgeTranslateTextRequest = function (translateFileRequest) {
+        return __awaiter(this, void 0, void 0, function () {
+            var encodedFile, request;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Utils_1.default.getEncodedFile(translateFileRequest.input)];
+                    case 1:
+                        encodedFile = _a.sent();
+                        request = new EdgeTranslateTextRequest_1.default();
+                        request.languagePairId = translateFileRequest.languagePairId;
+                        request.dictionaries = translateFileRequest.dictionaries;
+                        request.outputFormat = translateFileRequest.outputFormat;
+                        request.inputFormat =
+                            translateFileRequest.inputFormat || Utils_1.default.getFormatForFile(translateFileRequest.input || '');
+                        request.title = translateFileRequest.title;
+                        request.encoding = translateFileRequest.encoding;
+                        request.addInput(encodedFile);
+                        return [2 /*return*/, request];
+                }
+            });
+        });
+    };
+    EdgeLanguageWeaverClient.prototype.hasToken = function () {
+        return this._token && this._token.accessToken && this._token.tokenType;
+    };
+    EdgeLanguageWeaverClient.prototype.hasCredentialsConfiguration = function () {
+        return (this._clientConfiguration &&
+            this._clientConfiguration.credentialsConfiguration &&
+            this._clientConfiguration.credentialsConfiguration.clientId);
+    };
+    EdgeLanguageWeaverClient.prototype.setUrl = function () {
+        if (this._overwriteUrl) {
+            this._url = this._overwriteUrl;
+        }
+        else {
+            var overwriteUrl = Utils_1.default.getEdgeOverwriteUrlEnvVar();
+            if (overwriteUrl) {
+                this._url = overwriteUrl;
+            }
+        }
+        this._client.baseUrl = this._url;
+    };
+    EdgeLanguageWeaverClient.prototype.getLanguagePairForGivenData = function (source, target, model) {
+        return this.getEdgeLanguagePairsPromise().then(function (lps) {
+            var languagePair = lps.languagePairs.find(function (lp) { return lp.sourceLanguageId === source && lp.targetLanguageId === target && lp.domain === model; });
+            if (!languagePair) {
+                return Promise.reject({ message: TranslationConstants_1.LANGUAGE_PAIR_NOT_FOUND_ERROR });
+            }
+            return Promise.resolve(languagePair);
+        });
+    };
+    return EdgeLanguageWeaverClient;
+}());
+exports.default = EdgeLanguageWeaverClient;
+function validateRequiredFields(translateTextRequest) {
+    if (!translateTextRequest.input || !translateTextRequest.input[0]) {
+        return TranslationConstants_1.INPUT + ' field is required';
+    }
+}
+function createBodyForTranslationTextRequest(translateTextRequest) {
+    var formData = Utils_1.default.getNewFormDataObject();
+    formData.append(TranslationConstants_1.INPUT, translateTextRequest.input[0]);
+    if (translateTextRequest.languagePairId) {
+        formData.append(TranslationConstants_1.LANGUAGE_PAIR_ID, translateTextRequest.languagePairId);
+    }
+    if (translateTextRequest.dictionaries && translateTextRequest.dictionaries.length > 0) {
+        formData.append(TranslationConstants_1.DICTIONARY_IDS, translateTextRequest.dictionaries.join(','));
+    }
+    if (translateTextRequest.inputFormat) {
+        formData.append(TranslationConstants_1.INPUT_FORMAT, FormatToMimeType_1.formatToMimeType[translateTextRequest.inputFormat]);
+    }
+    if (translateTextRequest.title) {
+        formData.append(TranslationConstants_1.TITLE, translateTextRequest.title);
+    }
+    if (translateTextRequest.outputFormat) {
+        formData.append(TranslationConstants_1.OUTPUT_FORMAT, FormatToMimeType_1.formatToMimeType[translateTextRequest.outputFormat]);
+    }
+    if (translateTextRequest.encoding) {
+        formData.append(TranslationConstants_1.ENCODING, translateTextRequest.encoding);
+    }
+    return formData;
+}
+//# sourceMappingURL=EdgeLanguageWeaverClient.js.map