generaltranslation 8.2.12 → 8.2.14

package/dist/index.js

@@ -0,0 +1,1345 @@
+// `generaltranslation` language toolkit
+// © 2026, General Translation, Inc.
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 (g && (g = 0, op[0] && (_ = 0)), _) 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 };
+    }
+};
+// ----- IMPORTS ----- //
+import { LocaleConfig, determineLocale as _determineLocale, getRegionProperties as _getRegionProperties, isValidLocale as _isValidLocale, requiresTranslation as _requiresTranslation, resolveAliasLocale as _resolveAliasLocale, resolveCanonicalLocale as _resolveCanonicalLocale, standardizeLocale as _standardizeLocale, } from '@generaltranslation/format';
+import { libraryDefaultLocale } from './settings/settings';
+import { noSourceLocaleProvidedError, noTargetLocaleProvidedError, invalidLocaleError, invalidLocalesError, noProjectIdProvidedError, noApiKeyProvidedError, } from './logging/errors';
+import { gtInstanceLogger } from './logging/logger';
+import _translateMany from './translate/translateMany';
+import _setupProject from './translate/setupProject';
+import _enqueueFiles from './translate/enqueueFiles';
+import _createTag from './translate/createTag';
+import _downloadFileBatch from './translate/downloadFileBatch';
+import _submitUserEditDiffs from './translate/submitUserEditDiffs';
+import _uploadSourceFiles from './translate/uploadSourceFiles';
+import _uploadTranslations from './translate/uploadTranslations';
+import _querySourceFile from './translate/querySourceFile';
+import _getProjectData from './projects/getProjectData';
+import { _checkJobStatus, } from './translate/checkJobStatus';
+import _awaitJobs from './translate/awaitJobs';
+import _queryFileData from './translate/queryFileData';
+import _queryBranchData from './translate/queryBranchData';
+import _createBranch from './translate/createBranch';
+import _processFileMoves from './translate/processFileMoves';
+import _getOrphanedFiles from './translate/getOrphanedFiles';
+import _publishFiles from './translate/publishFiles';
+import { API_VERSION as _API_VERSION } from './translate/api';
+export { LocaleConfig, } from '@generaltranslation/format';
+export { determineLocale, formatCurrency, formatCutoff, formatDateTime, formatList, formatListToParts, formatMessage, formatNum, formatRelativeTime, formatRelativeTimeFromDate, getLocaleDirection, getLocaleEmoji, getLocaleName, getLocaleProperties, getRegionProperties, isSameDialect, isSameLanguage, isSupersetLocale, isValidLocale, requiresTranslation, resolveAliasLocale, resolveCanonicalLocale, standardizeLocale, } from '@generaltranslation/format';
+/**
+ * GT is the core driver for the General Translation library.
+ * This class provides functionality for locale management, formatting, and translation operations.
+ *
+ * @class GT
+ * @description A comprehensive toolkit for handling internationalization and localization.
+ *
+ * @example
+ * const gt = new GT({
+ *   sourceLocale: 'en-US',
+ *   targetLocale: 'es-ES',
+ *   locales: ['en-US', 'es-ES', 'fr-FR']
+ * });
+ */
+var GT = /** @class */ (function () {
+    /**
+     * Constructs an instance of the GT class.
+     *
+     * @param {GTConstructorParams} [params] - The parameters for initializing the GT instance
+     * @throws {Error} If an invalid locale is provided
+     * @throws {Error} If any of the provided locales are invalid
+     *
+     * @example
+     * const gt = new GT({
+     *   apiKey: 'your-api-key',
+     *   sourceLocale: 'en-US',
+     *   targetLocale: 'es-ES',
+     *   locales: ['en-US', 'es-ES', 'fr-FR']
+     * });
+     */
+    function GT(params) {
+        if (params === void 0) { params = {}; }
+        var _a, _b, _c;
+        // Read environment
+        if (typeof process !== 'undefined') {
+            this.apiKey || (this.apiKey = (_a = process.env) === null || _a === void 0 ? void 0 : _a.GT_API_KEY);
+            this.devApiKey || (this.devApiKey = (_b = process.env) === null || _b === void 0 ? void 0 : _b.GT_DEV_API_KEY);
+            this.projectId || (this.projectId = (_c = process.env) === null || _c === void 0 ? void 0 : _c.GT_PROJECT_ID);
+        }
+        // Set up config
+        this.setConfig(params);
+    }
+    Object.defineProperty(GT.prototype, "localeConfig", {
+        /** Runtime-safe locale and formatting helpers */
+        get: function () {
+            return this._localeConfig;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GT.prototype.setConfig = function (_a) {
+        var _b;
+        var apiKey = _a.apiKey, devApiKey = _a.devApiKey, sourceLocale = _a.sourceLocale, targetLocale = _a.targetLocale, locales = _a.locales, projectId = _a.projectId, customMapping = _a.customMapping, baseUrl = _a.baseUrl;
+        // ----- Environment properties ----- //
+        if (apiKey)
+            this.apiKey = apiKey;
+        if (devApiKey)
+            this.devApiKey = devApiKey;
+        if (projectId)
+            this.projectId = projectId;
+        // ----- Standardize locales ----- //
+        // source locale
+        if (sourceLocale) {
+            this.sourceLocale = _standardizeLocale(sourceLocale);
+            if (!_isValidLocale(this.sourceLocale, customMapping))
+                throw new Error(invalidLocaleError(this.sourceLocale));
+        }
+        // target locale
+        if (targetLocale) {
+            this.targetLocale = _standardizeLocale(targetLocale);
+            if (!_isValidLocale(this.targetLocale, customMapping))
+                throw new Error(invalidLocaleError(this.targetLocale));
+        }
+        // locales
+        if (locales) {
+            var result_1 = [];
+            var invalidLocales_1 = [];
+            locales.forEach(function (locale) {
+                var standardizedLocale = _standardizeLocale(locale);
+                if (_isValidLocale(standardizedLocale)) {
+                    result_1.push(standardizedLocale);
+                }
+                else {
+                    invalidLocales_1.push(locale);
+                }
+            });
+            if (invalidLocales_1.length > 0) {
+                throw new Error(invalidLocalesError(invalidLocales_1));
+            }
+            this.locales = result_1;
+        }
+        // ----- Other properties ----- //
+        if (baseUrl)
+            this.baseUrl = baseUrl;
+        if (customMapping) {
+            this.customMapping = customMapping;
+            this.reverseCustomMapping = Object.fromEntries(Object.entries(customMapping)
+                .filter(function (_a) {
+                var value = _a[1];
+                return value && typeof value === 'object' && 'code' in value;
+            })
+                .map(function (_a) {
+                var key = _a[0], value = _a[1];
+                return [value.code, key];
+            }));
+        }
+        this._localeConfig = new LocaleConfig({
+            defaultLocale: this.sourceLocale,
+            locales: (_b = this.locales) !== null && _b !== void 0 ? _b : [],
+            customMapping: this.customMapping,
+        });
+    };
+    // -------------- Private Methods -------------- //
+    GT.prototype._getTranslationConfig = function () {
+        return {
+            baseUrl: this.baseUrl,
+            apiKey: this.apiKey || this.devApiKey,
+            projectId: this.projectId || '',
+        };
+    };
+    GT.prototype._validateAuth = function (functionName) {
+        var errors = [];
+        if (!this.apiKey && !this.devApiKey) {
+            var error = noApiKeyProvidedError(functionName);
+            errors.push(error);
+        }
+        if (!this.projectId) {
+            var error = noProjectIdProvidedError(functionName);
+            errors.push(error);
+        }
+        if (errors.length) {
+            throw new Error(errors.join('\n'));
+        }
+    };
+    // -------------- Branch Methods -------------- //
+    /**
+     * Queries branch information from the API.
+     *
+     * @param {BranchQuery} query - Object mapping the current branch and incoming branches
+     * @returns {Promise<BranchDataResult>} The branch information.
+     */
+    GT.prototype.queryBranchData = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('queryBranchData');
+                        return [4 /*yield*/, _queryBranchData(query, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates a new branch in the API. If the branch already exists, it will be returned.
+     *
+     * @param {CreateBranchQuery} query - Object mapping the branch name and default branch flag
+     * @returns {Promise<CreateBranchResult>} The created branch information.
+     */
+    GT.prototype.createBranch = function (query) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('createBranch');
+                        return [4 /*yield*/, _createBranch(query, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Processes file moves by cloning source files and translations with new fileIds.
+     * This is called when files have been moved/renamed and we want to preserve translations.
+     *
+     * @param {MoveMapping[]} moves - Array of move mappings (old fileId to new fileId)
+     * @param {ProcessMovesOptions} options - Options including branchId and timeout
+     * @returns {Promise<ProcessMovesResponse>} The move processing results.
+     *
+     * @example
+     * const result = await gt.processFileMoves([
+     *   { oldFileId: 'abc123', newFileId: 'def456', newFileName: 'locales/en.json' }
+     * ], { branchId: 'main' });
+     */
+    GT.prototype.processFileMoves = function (moves_1) {
+        return __awaiter(this, arguments, void 0, function (moves, options) {
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('processFileMoves');
+                        return [4 /*yield*/, _processFileMoves(moves, options, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Gets orphaned files for a branch - files that exist on the branch
+     * but whose fileIds are not in the provided list.
+     * Used for move detection.
+     *
+     * @param {string} branchId - The branch to check for orphaned files.
+     * @param {string[]} fileIds - List of current file IDs (files that are NOT orphaned)
+     * @param {Object} options - Options including timeout.
+     * @returns {Promise<GetOrphanedFilesResult>} The orphaned files.
+     *
+     * @example
+     * const result = await gt.getOrphanedFiles('branch-id', ['file-1', 'file-2']);
+     */
+    GT.prototype.getOrphanedFiles = function (branchId_1, fileIds_1) {
+        return __awaiter(this, arguments, void 0, function (branchId, fileIds, options) {
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('getOrphanedFiles');
+                        return [4 /*yield*/, _getOrphanedFiles(branchId, fileIds, options, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    // -------------- Translation Methods -------------- //
+    /**
+     * Enqueues project setup job using the specified file references
+     *
+     * This method creates setup jobs that will process source file references
+     * and generate a project setup. The files parameter contains references (IDs) to source
+     * files that have already been uploaded via uploadSourceFiles. The setup jobs are queued
+     * for processing and will generate a project setup based on the source files.
+     *
+     * @param {FileReference[]} files - Array of file references containing IDs of previously uploaded source files
+     * @param {SetupProjectOptions} [options] - Optional settings for target locales and timeout.
+     * @returns {Promise<SetupProjectResult>} Object containing the jobId and status
+     */
+    GT.prototype.setupProject = function (files, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        this._validateAuth('setupProject');
+                        options = __assign(__assign({}, options), { locales: (_a = options === null || options === void 0 ? void 0 : options.locales) === null || _a === void 0 ? void 0 : _a.map(function (locale) {
+                                return _this.resolveCanonicalLocale(locale);
+                            }) });
+                        return [4 /*yield*/, _setupProject(files, this._getTranslationConfig(), options)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Checks the current status of one or more project jobs by their unique identifiers.
+     *
+     * This method polls the API to determine whether one or more jobs are still running,
+     * have completed successfully, or have failed. Jobs are created after calling either enqueueFiles or setupProject.
+     *
+     * @param {string[]} jobIds - The unique identifiers of the jobs to check.
+     * @param {number} [timeoutMs] - Optional timeout in milliseconds for the API request.
+     * @returns {Promise<CheckJobStatusResult>} Object containing the job status.
+     *
+     * @example
+     * const result = await gt.checkJobStatus([
+     *   'job-123',
+     *   'job-456',
+     * ], {
+     *   timeout: 10000,
+     * });
+     */
+    GT.prototype.checkJobStatus = function (jobIds, timeoutMs) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('checkJobStatus');
+                        return [4 /*yield*/, _checkJobStatus(jobIds, this._getTranslationConfig(), timeoutMs)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Polls job statuses until all jobs from enqueueFiles are finished or the timeout is reached.
+     *
+     * @param {EnqueueFilesResult} enqueueResult - The result returned from enqueueFiles.
+     * @param {AwaitJobsOptions} [options] - Polling configuration (interval, timeout).
+     * @returns {Promise<AwaitJobsResult>} The final status of all jobs and whether they all completed.
+     */
+    GT.prototype.awaitJobs = function (enqueueResult, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('awaitJobs');
+                        return [4 /*yield*/, _awaitJobs(enqueueResult, options, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Enqueues translation jobs for previously uploaded source files.
+     *
+     * This method creates translation jobs that will process existing source files
+     * and generate translations in the specified target languages. The files parameter
+     * contains references (IDs) to source files that have already been uploaded via
+     * uploadSourceFiles. The translation jobs are queued for processing and will
+     * generate translated content based on the source files and target locales provided.
+     *
+     * @param {FileReferenceIds[]} files - Array of file references containing IDs of previously uploaded source files
+     * @param {EnqueueOptions} options - Configuration options including source locale, target locales, and job settings.
+     * @returns {Promise<EnqueueFilesResult>} Result containing job IDs, queue status, and processing information.
+     */
+    GT.prototype.enqueueFiles = function (files, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mergedOptions, error, error;
+            var _this = this;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('enqueueFiles');
+                        mergedOptions = __assign(__assign({}, options), { sourceLocale: (_a = options.sourceLocale) !== null && _a !== void 0 ? _a : this.sourceLocale, targetLocales: (_b = options.targetLocales) !== null && _b !== void 0 ? _b : [this.targetLocale] });
+                        // Require source locale
+                        if (!mergedOptions.sourceLocale) {
+                            error = noSourceLocaleProvidedError('enqueueFiles');
+                            gtInstanceLogger.error(error);
+                            throw new Error(error);
+                        }
+                        // Require target locale(s)
+                        if (!mergedOptions.targetLocales ||
+                            mergedOptions.targetLocales.length === 0) {
+                            error = noTargetLocaleProvidedError('enqueueFiles');
+                            gtInstanceLogger.error(error);
+                            throw new Error(error);
+                        }
+                        // Replace target locales with canonical locales
+                        mergedOptions = __assign(__assign({}, mergedOptions), { targetLocales: mergedOptions.targetLocales.map(function (locale) {
+                                return _this.resolveCanonicalLocale(locale);
+                            }) });
+                        return [4 /*yield*/, _enqueueFiles(files, mergedOptions, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates or upserts a file tag, associating a set of source files
+     * with a user-defined tag ID and optional message.
+     *
+     * @param {CreateTagOptions} options - Tag creation options including tagId, sourceFileIds, and optional message
+     * @returns {Promise<CreateTagResult>} The created or updated tag.
+     */
+    GT.prototype.createTag = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('createTag');
+                        return [4 /*yield*/, _createTag(options, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Publishes or unpublishes files on the CDN.
+     *
+     * @param {PublishFileEntry[]} files - Array of file entries with publish flags
+     * @returns {Promise<PublishFilesResult>} Result containing per-file success/failure
+     */
+    GT.prototype.publishFiles = function (files) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('publishFiles');
+                        return [4 /*yield*/, _publishFiles(files, this._getTranslationConfig())];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Submits user edit diffs for existing translations so future generations preserve user intent.
+     *
+     * @param {SubmitUserEditDiffsPayload} payload - Project-scoped diff payload.
+     * @returns {Promise<void>} Resolves when submission succeeds.
+     */
+    GT.prototype.submitUserEditDiffs = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var normalized;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._validateAuth('submitUserEditDiffs');
+                        normalized = __assign(__assign({}, payload), { diffs: (payload.diffs || []).map(function (d) { return (__assign(__assign({}, d), { locale: _this.resolveCanonicalLocale(d.locale) })); }) });
+                        return [4 /*yield*/, _submitUserEditDiffs(normalized, this._getTranslationConfig())];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Queries data about one or more source or translation files.
+     *
+     * @param {FileDataQuery} data - Object mapping source and translation file information.
+     * @param {CheckFileTranslationsOptions} options - Options for the API call.
+     * @returns {Promise<FileDataResult>} The source and translation file data information.
+     *
+     * @example
+     * const result = await gt.queryFileData({
+     *   sourceFiles: [
+     *     { fileId: '1234567890', versionId: '1234567890', branchId: '1234567890' },
+     *   ],
+     *   translatedFiles: [
+     *     { fileId: '1234567890', versionId: '1234567890', branchId: '1234567890', locale: 'es-ES' },
+     *   ],
+     * }, {
+     *   timeout: 10000,
+     * });
+     *
+     */
+    GT.prototype.queryFileData = function (data_1) {
+        return __awaiter(this, arguments, void 0, function (data, options) {
+            var result;
+            var _this = this;
+            var _a, _b, _c;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('queryFileData');
+                        // Replace target locales with canonical locales
+                        data.translatedFiles = (_a = data.translatedFiles) === null || _a === void 0 ? void 0 : _a.map(function (item) { return (__assign(__assign({}, item), { locale: _this.resolveCanonicalLocale(item.locale) })); });
+                        return [4 /*yield*/, _queryFileData(data, options, this._getTranslationConfig())];
+                    case 1:
+                        result = _d.sent();
+                        // Resolve canonical locales
+                        result.translatedFiles = (_b = result.translatedFiles) === null || _b === void 0 ? void 0 : _b.map(function (item) { return (__assign(__assign({}, item), (item.locale && { locale: _this.resolveAliasLocale(item.locale) }))); });
+                        result.sourceFiles = (_c = result.sourceFiles) === null || _c === void 0 ? void 0 : _c.map(function (item) { return (__assign(__assign(__assign({}, item), (item.sourceLocale && {
+                            sourceLocale: _this.resolveAliasLocale(item.sourceLocale),
+                        })), { locales: item.locales.map(function (locale) { return _this.resolveAliasLocale(locale); }) })); });
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * Gets source and translation information for a given file ID and version ID.
+     *
+     * @param {FileQuery} data - File query containing file ID and version ID.
+     * @param {CheckFileTranslationsOptions} options - Options for getting source and translation information.
+     * @returns {Promise<FileQueryResult>} The source file and translation information.
+     *
+     * @example
+     * const result = await gt.querySourceFile(
+     *   { fileId: '1234567890', versionId: '1234567890' },
+     *   { timeout: 10000 }
+     * );
+     *
+     */
+    GT.prototype.querySourceFile = function (data_1) {
+        return __awaiter(this, arguments, void 0, function (data, options) {
+            var result;
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('querySourceFile');
+                        return [4 /*yield*/, _querySourceFile(data, options, this._getTranslationConfig())];
+                    case 1:
+                        result = _a.sent();
+                        // Replace locales with canonical locales
+                        result.translations = result.translations.map(function (item) { return (__assign(__assign({}, item), (item.locale && { locale: _this.resolveAliasLocale(item.locale) }))); });
+                        result.sourceFile.locales = result.sourceFile.locales.map(function (locale) {
+                            return _this.resolveAliasLocale(locale);
+                        });
+                        if (result.sourceFile.sourceLocale) {
+                            result.sourceFile.sourceLocale = this.resolveAliasLocale(result.sourceFile.sourceLocale);
+                        }
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * Get project data for a given project ID.
+     *
+     * @param {string} projectId - The ID of the project to get the data for.
+     * @returns {Promise<ProjectData>} The project data.
+     *
+     * @example
+     * const result = await gt.getProjectData(
+     *   '1234567890'
+     * );
+     *
+     */
+    GT.prototype.getProjectData = function (projectId_1) {
+        return __awaiter(this, arguments, void 0, function (projectId, options) {
+            var result;
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('getProjectData');
+                        return [4 /*yield*/, _getProjectData(projectId, options, this._getTranslationConfig())];
+                    case 1:
+                        result = _a.sent();
+                        // Replace locales with canonical locales
+                        result.currentLocales = result.currentLocales.map(function (item) {
+                            return _this.resolveAliasLocale(item);
+                        });
+                        result.defaultLocale = this.resolveAliasLocale(result.defaultLocale);
+                        return [2 /*return*/, result];
+                }
+            });
+        });
+    };
+    /**
+     * Downloads a single file.
+     *
+     * @param file - The file query object.
+     * @param {string} file.fileId - The ID of the file to download.
+     * @param {string} [file.branchId] - The ID of the branch to download the file from. If not provided, the default branch will be used.
+     * @param {string} [file.locale] - The locale to download the file for. If not provided, the source file will be downloaded.
+     * @param {string} [file.versionId] - The version ID to download the file from. If not provided, the latest version will be used.
+     * @param {DownloadFileOptions} options - Options for downloading the file.
+     * @returns {Promise<string>} The downloaded file content.
+     *
+     * @example
+     * const result = await gt.downloadFile({
+     *   fileId: '1234567890',
+     *   branchId: '1234567890',
+     *   locale: 'es-ES',
+     *   versionId: '1234567890',
+     * }, {
+     *   timeout: 10000,
+     * });
+     */
+    GT.prototype.downloadFile = function (file_1) {
+        return __awaiter(this, arguments, void 0, function (file, options) {
+            var result;
+            var _a, _b, _c;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('downloadTranslatedFile');
+                        return [4 /*yield*/, _downloadFileBatch([
+                                {
+                                    fileId: file.fileId,
+                                    branchId: file.branchId,
+                                    locale: file.locale
+                                        ? this.resolveCanonicalLocale(file.locale)
+                                        : undefined,
+                                    versionId: file.versionId,
+                                    useLatestAvailableVersion: file.useLatestAvailableVersion,
+                                },
+                            ], options, this._getTranslationConfig())];
+                    case 1:
+                        result = _d.sent();
+                        return [2 /*return*/, (_c = (_b = (_a = result.data) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.data) !== null && _c !== void 0 ? _c : ''];
+                }
+            });
+        });
+    };
+    /**
+     * Downloads multiple files in a batch.
+     *
+     * @param {DownloadFileBatchRequest} requests - Array of file query objects to download.
+     * @param {DownloadFileBatchOptions} options - Options for the batch download.
+     * @returns {Promise<DownloadFileBatchResult>} The batch download results.
+     *
+     * @example
+     * const result = await gt.downloadFileBatch([{
+     *   fileId: '1234567890',
+     *   locale: 'es-ES',
+     *   versionId: '1234567890',
+     * }], {
+     *   timeout: 10000,
+     * });
+     */
+    GT.prototype.downloadFileBatch = function (requests_1) {
+        return __awaiter(this, arguments, void 0, function (requests, options) {
+            var result;
+            var _this = this;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('downloadFileBatch');
+                        requests = requests.map(function (request) { return (__assign(__assign({}, request), { locale: request.locale
+                                ? _this.resolveCanonicalLocale(request.locale)
+                                : undefined })); });
+                        return [4 /*yield*/, _downloadFileBatch(requests, options, this._getTranslationConfig())];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                files: result.data.map(function (file) { return (__assign(__assign({}, file), (file.locale && {
+                                    locale: _this.resolveAliasLocale(file.locale),
+                                }))); }),
+                                count: result.count,
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Translates a single source string to the target locale.
+     * Routes through {@link translateMany} under the hood.
+     *
+     * @param {string} source - The source string to translate.
+     * @param {object} options - Translation options including targetLocale and optional entry metadata.
+     * @returns {Promise<TranslationResult | TranslationError>} The translated content.
+     *
+     * @example
+     * const result = await gt.translate('Hello, world!', { targetLocale: 'es' });
+     *
+     * @example
+     * const result = await gt.translate('Hello, world!', {
+     *   targetLocale: 'es',
+     *   dataFormat: 'ICU',
+     *   context: 'A formal greeting',
+     * });
+     */
+    GT.prototype.translate = function (source, options, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var targetLocale, error, sourceLocale, results;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Normalize string shorthand to options object
+                        if (typeof options === 'string') {
+                            options = { targetLocale: options };
+                        }
+                        // Validation
+                        this._validateAuth('translate');
+                        targetLocale = (options === null || options === void 0 ? void 0 : options.targetLocale) || this.targetLocale;
+                        if (!targetLocale) {
+                            error = noTargetLocaleProvidedError('translate');
+                            gtInstanceLogger.error(error);
+                            throw new Error(error);
+                        }
+                        // Replace target locale with canonical locale
+                        targetLocale = this.resolveCanonicalLocale(targetLocale);
+                        sourceLocale = this.resolveCanonicalLocale((options === null || options === void 0 ? void 0 : options.sourceLocale) || this.sourceLocale || libraryDefaultLocale);
+                        return [4 /*yield*/, _translateMany([source], __assign(__assign({}, options), { targetLocale: targetLocale, sourceLocale: sourceLocale }), this._getTranslationConfig(), timeout)];
+                    case 1:
+                        results = _a.sent();
+                        return [2 /*return*/, results[0]];
+                }
+            });
+        });
+    };
+    GT.prototype.translateMany = function (sources, options, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var targetLocale, error, sourceLocale;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Normalize string shorthand to options object
+                        if (typeof options === 'string') {
+                            options = { targetLocale: options };
+                        }
+                        // Validation
+                        this._validateAuth('translateMany');
+                        targetLocale = (options === null || options === void 0 ? void 0 : options.targetLocale) || this.targetLocale;
+                        if (!targetLocale) {
+                            error = noTargetLocaleProvidedError('translateMany');
+                            gtInstanceLogger.error(error);
+                            throw new Error(error);
+                        }
+                        // Replace target locale with canonical locale
+                        targetLocale = this.resolveCanonicalLocale(targetLocale);
+                        sourceLocale = this.resolveCanonicalLocale((options === null || options === void 0 ? void 0 : options.sourceLocale) || this.sourceLocale || libraryDefaultLocale);
+                        return [4 /*yield*/, _translateMany(sources, __assign(__assign({}, options), { targetLocale: targetLocale, sourceLocale: sourceLocale }), this._getTranslationConfig(), timeout)];
+                    case 1: 
+                    // Request the translation.
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Uploads source files to the translation service without any translation content.
+     *
+     * This method creates or replaces source file entries in your project. Each uploaded
+     * file becomes a source that can later be translated into target languages. The files
+     * are processed and stored as base entries that serve as the foundation for generating
+     * translations through the translation workflow.
+     *
+     * @param {Array<{source: FileUpload}>} files - Array of objects containing source file data to upload
+     * @param {UploadFilesOptions} options - Configuration options including source locale and other upload settings.
+     * @returns {Promise<UploadFilesResponse>} Upload result containing file IDs, version information, and upload status.
+     */
+    GT.prototype.uploadSourceFiles = function (files, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mergedOptions, result;
+            var _this = this;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('uploadSourceFiles');
+                        mergedOptions = __assign(__assign({}, options), { sourceLocale: this.resolveCanonicalLocale((_b = (_a = options.sourceLocale) !== null && _a !== void 0 ? _a : this.sourceLocale) !== null && _b !== void 0 ? _b : libraryDefaultLocale) });
+                        // resolve canonical locales
+                        files = files.map(function (f) { return (__assign(__assign({}, f), { source: __assign(__assign({}, f.source), { locale: _this.resolveCanonicalLocale(f.source.locale) }) })); });
+                        return [4 /*yield*/, _uploadSourceFiles(files, mergedOptions, this._getTranslationConfig())];
+                    case 1:
+                        result = _c.sent();
+                        return [2 /*return*/, {
+                                uploadedFiles: result.data,
+                                count: result.count,
+                                message: "Successfully uploaded ".concat(result.count, " files in ").concat(result.batchCount, " batch(es)"),
+                            }];
+                }
+            });
+        });
+    };
+    /**
+     * Uploads translation files that correspond to previously uploaded source files.
+     *
+     * This method allows you to provide translated content for existing source files in your project.
+     * Each translation must reference an existing source file and include the translated content
+     * along with the target locale information. This is used when you have pre-existing translations
+     * that you want to upload directly rather than generating them through the translation service.
+     *
+     * @param {Array<{source: FileUpload, translations: FileUpload[]}>} files - Array of file objects where:
+     *   - `source`: Reference to the existing source file (contains IDs but no content).
+     *   - `translations`: Array of translated files, each containing content, locale, and reference IDs
+     * @param {UploadFilesOptions} options - Configuration options including source locale and upload settings.
+     * @returns {Promise<UploadFilesResponse>} Upload result containing translation IDs, status, and processing information.
+     */
+    GT.prototype.uploadTranslations = function (files, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var mergedOptions, error, targetFiles, result;
+            var _this = this;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        // Validation
+                        this._validateAuth('uploadTranslations');
+                        mergedOptions = __assign(__assign({}, options), { sourceLocale: (_a = options.sourceLocale) !== null && _a !== void 0 ? _a : this.sourceLocale });
+                        // Require source locale
+                        if (!mergedOptions.sourceLocale) {
+                            error = noSourceLocaleProvidedError('uploadTranslations');
+                            gtInstanceLogger.error(error);
+                            throw new Error(error);
+                        }
+                        targetFiles = files.map(function (f) { return (__assign(__assign({}, f), { translations: f.translations.map(function (t) { return (__assign(__assign({}, t), { locale: _this.resolveCanonicalLocale(t.locale) })); }) })); });
+                        return [4 /*yield*/, _uploadTranslations(targetFiles, mergedOptions, this._getTranslationConfig())];
+                    case 1:
+                        result = _b.sent();
+                        return [2 /*return*/, {
+                                uploadedFiles: result.data,
+                                count: result.count,
+                                message: "Successfully uploaded ".concat(result.count, " files in ").concat(result.batchCount, " batch(es)"),
+                            }];
+                }
+            });
+        });
+    };
+    // -------------- Formatting -------------- //
+    /**
+     * Formats a string with cutoff behavior, applying a terminator when the string exceeds the maximum character limit.
+     *
+     * This method uses the GT instance's rendering locales by default for locale-specific terminator selection,
+     * but can be overridden with custom locales in the options.
+     *
+     * @param {string} value - The string value to format with cutoff behavior.
+     * @param {Object} [options] - Configuration options for cutoff formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for terminator selection. Defaults to instance's rendering locales.
+     * @param {number} [options.maxChars] - The maximum number of characters to display.
+     * - Undefined values are treated as no cutoff.
+     * - Negative values follow .slice() behavior and terminator will be added before the value.
+     * - 0 will result in an empty string.
+     * - If cutoff results in an empty string, no terminator is added.
+     * @param {CutoffFormatStyle} [options.style='ellipsis'] - The style of the terminator.
+     * @param {string} [options.terminator] - Optional override the terminator to use.
+     * @param {string} [options.separator] - Optional override the separator to use between the terminator and the value.
+     * - If no terminator is provided, then separator is ignored.
+     * @returns {string} The formatted string with terminator applied if cutoff occurs.
+     *
+     * @example
+     * const gt = new GT({ targetLocale: 'en-US' });
+     * gt.formatCutoff('Hello, world!', { maxChars: 8 });
+     * // Returns: 'Hello, w...'
+     *
+     * @example
+     * gt.formatCutoff('Hello, world!', { maxChars: -3 });
+     * // Returns: '...ld!'
+     */
+    GT.prototype.formatCutoff = function (value, options) {
+        return this.localeConfig.formatCutoff(value, this.targetLocale, options);
+    };
+    /**
+     * Formats a message according to the specified locales and options.
+     *
+     * @param {string} message - The message to format.
+     * @param {string | string[]} [locales='en'] - The locales to use for formatting.
+     * @param {FormatVariables} [variables={}] - The variables to use for formatting.
+     * @param {StringFormat} [dataFormat='ICU'] - The format of the message.
+     * @returns {string} The formatted message.
+     *
+     * @example
+     * gt.formatMessage('Hello {name}', { name: 'John' });
+     * // Returns: "Hello John"
+     *
+     * gt.formatMessage('Hello {name}', { name: 'John' }, { locales: ['fr'] });
+     * // Returns: "Bonjour John"
+     */
+    GT.prototype.formatMessage = function (message, options) {
+        return this.localeConfig.formatMessage(message, this.targetLocale, options);
+    };
+    /**
+     * Formats a number according to the specified locales and options.
+     *
+     * @param {number} number - The number to format.
+     * @param {Object} [options] - Additional options for number formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @param {Intl.NumberFormatOptions} [options] - Additional Intl.NumberFormat options.
+     * @returns {string} The formatted number.
+     *
+     * @example
+     * gt.formatNum(1234.56, { style: 'currency', currency: 'USD' });
+     * // Returns: "$1,234.56"
+     */
+    GT.prototype.formatNum = function (number, options) {
+        return this.localeConfig.formatNum(number, this.targetLocale, options);
+    };
+    /**
+     * Formats a date according to the specified locales and options.
+     *
+     * @param {Date} date - The date to format.
+     * @param {Object} [options] - Additional options for date formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @param {Intl.DateTimeFormatOptions} [options] - Additional Intl.DateTimeFormat options.
+     * @returns {string} The formatted date.
+     *
+     * @example
+     * gt.formatDateTime(new Date(), { dateStyle: 'full', timeStyle: 'long' });
+     * // Returns: "Thursday, March 14, 2024 at 2:30:45 PM GMT-7"
+     */
+    GT.prototype.formatDateTime = function (date, options) {
+        return this.localeConfig.formatDateTime(date, this.targetLocale, options);
+    };
+    /**
+     * Formats a currency value according to the specified locales and options.
+     *
+     * @param {number} value - The currency value to format.
+     * @param {string} currency - The currency code (e.g., 'USD', 'EUR')
+     * @param {Object} [options] - Additional options for currency formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @param {Intl.NumberFormatOptions} [options] - Additional Intl.NumberFormat options.
+     * @returns {string} The formatted currency value.
+     *
+     * @example
+     * gt.formatCurrency(1234.56, 'USD', { style: 'currency' });
+     * // Returns: "$1,234.56"
+     */
+    GT.prototype.formatCurrency = function (value, currency, options) {
+        return this.localeConfig.formatCurrency(value, currency, this.targetLocale, options);
+    };
+    /**
+     * Formats a list of items according to the specified locales and options.
+     *
+     * @param {Array<string | number>} array - The list of items to format.
+     * @param {Object} [options] - Additional options for list formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @param {Intl.ListFormatOptions} [options] - Additional Intl.ListFormat options.
+     * @returns {string} The formatted list.
+     *
+     * @example
+     * gt.formatList(['apple', 'banana', 'orange'], { type: 'conjunction' });
+     * // Returns: "apple, banana, and orange"
+     */
+    GT.prototype.formatList = function (array, options) {
+        return this.localeConfig.formatList(array, this.targetLocale, options);
+    };
+    /**
+     * Formats a list of items according to the specified locales and options.
+     * @param {Array<T>} array - The list of items to format.
+     * @param {Object} [options] - Additional options for list formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @param {Intl.ListFormatOptions} [options] - Additional Intl.ListFormat options.
+     * @returns {Array<T | string>} The formatted list parts.
+     *
+     * @example
+     * gt.formatListToParts(['apple', 42, { foo: 'bar' }], { type: 'conjunction', style: 'short', locales: ['en'] });
+     * // Returns: ['apple', ', ', 42, ' and ', '{ foo: "bar" }']
+     */
+    GT.prototype.formatListToParts = function (array, options) {
+        return this.localeConfig.formatListToParts(array, this.targetLocale, options);
+    };
+    /**
+     * Formats a relative time value according to the specified locales and options.
+     *
+     * @param {number} value - The relative time value to format.
+     * @param {Intl.RelativeTimeFormatUnit} unit - The unit of time (e.g., 'second', 'minute', 'hour', 'day', 'week', 'month', 'year')
+     * @param {Object} options - Additional options for relative time formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @param {Intl.RelativeTimeFormatOptions} [options] - Additional Intl.RelativeTimeFormat options.
+     * @returns {string} The formatted relative time string.
+     *
+     * @example
+     * gt.formatRelativeTime(-1, 'day', { locales: ['en-US'], numeric: 'auto' });
+     * // Returns: "yesterday"
+     */
+    GT.prototype.formatRelativeTime = function (value, unit, options) {
+        return this.localeConfig.formatRelativeTime(value, unit, this.targetLocale, options);
+    };
+    /**
+     * Formats a relative time string from a Date, automatically selecting the best unit.
+     *
+     * @param {Date} date - The date to format relative to now.
+     * @param {Object} [options] - Additional options for relative time formatting.
+     * @param {string | string[]} [options.locales] - The locales to use for formatting.
+     * @returns {string} The formatted relative time string (e.g., "2 hours ago", "in 3 days")
+     *
+     * @example
+     * gt.formatRelativeTimeFromDate(new Date(Date.now() - 3600000));
+     * // Returns: "1 hour ago"
+     */
+    GT.prototype.formatRelativeTimeFromDate = function (date, options) {
+        return this.localeConfig.formatRelativeTimeFromDate(date, this.targetLocale, options);
+    };
+    // -------------- Locale Properties -------------- //
+    /**
+     * Retrieves the display name of a locale code using Intl.DisplayNames, returning an empty string if no name is found.
+     *
+     * @param {string} [locale=this.targetLocale] - A BCP-47 locale code.
+     * @returns {string} The display name corresponding to the code.
+     * @throws {Error} If no target locale is provided.
+     *
+     * @example
+     * gt.getLocaleName('es-ES');
+     * // Returns: "Spanish (Spain)"
+     */
+    GT.prototype.getLocaleName = function (locale) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('getLocaleName'));
+        return this.localeConfig.getLocaleName(locale);
+    };
+    /**
+     * Retrieves an emoji based on a given locale code.
+     * Uses the locale's region (if present) to select an emoji or falls back on default emojis.
+     *
+     * @param {string} [locale=this.targetLocale] - A BCP-47 locale code (e.g., 'en-US', 'fr-CA')
+     * @returns {string} The emoji representing the locale or its region.
+     * @throws {Error} If no target locale is provided.
+     *
+     * @example
+     * gt.getLocaleEmoji('es-ES');
+     * // Returns: "🇪🇸"
+     */
+    GT.prototype.getLocaleEmoji = function (locale) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('getLocaleEmoji'));
+        return this.localeConfig.getLocaleEmoji(locale);
+    };
+    /**
+     * Generates linguistic details for a given locale code.
+     *
+     * This function returns information about the locale,
+     * script, and region of a given language code both in a standard form and in a maximized form (with likely script and region).
+     * The function provides these names in both your default language and native forms, and an associated emoji.
+     *
+     * @param {string} [locale=this.targetLocale] - The locale code to get properties for (e.g., "de-AT").
+     * @returns {LocaleProperties} - An object containing detailed information about the locale.
+     *
+     * @property {string} code - The full locale code, e.g., "de-AT".
+     * @property {string} name - Language name in the default display language, e.g., "Austrian German".
+     * @property {string} nativeName - Language name in the locale's native language, e.g., "Österreichisches Deutsch".
+     * @property {string} languageCode - The base language code, e.g., "de".
+     * @property {string} languageName - The language name in the default display language, e.g., "German".
+     * @property {string} nativeLanguageName - The language name in the native language, e.g., "Deutsch".
+     * @property {string} nameWithRegionCode - Language name with region in the default language, e.g., "German (AT)".
+     * @property {string} nativeNameWithRegionCode - Language name with region in the native language, e.g., "Deutsch (AT)".
+     * @property {string} regionCode - The region code from maximization, e.g., "AT".
+     * @property {string} regionName - The region name in the default display language, e.g., "Austria".
+     * @property {string} nativeRegionName - The region name in the native language, e.g., "Österreich".
+     * @property {string} scriptCode - The script code from maximization, e.g., "Latn".
+     * @property {string} scriptName - The script name in the default display language, e.g., "Latin".
+     * @property {string} nativeScriptName - The script name in the native language, e.g., "Lateinisch".
+     * @property {string} maximizedCode - The maximized locale code, e.g., "de-Latn-AT".
+     * @property {string} maximizedName - Maximized locale name with likely script in the default language, e.g., "Austrian German (Latin)".
+     * @property {string} nativeMaximizedName - Maximized locale name in the native language, e.g., "Österreichisches Deutsch (Lateinisch)".
+     * @property {string} minimizedCode - Minimized locale code, e.g., "de-AT" (or "de" for "de-DE").
+     * @property {string} minimizedName - Minimized language name in the default language, e.g., "Austrian German".
+     * @property {string} nativeMinimizedName - Minimized language name in the native language, e.g., "Österreichisches Deutsch".
+     * @property {string} emoji - The emoji associated with the locale's region, if applicable.
+     */
+    GT.prototype.getLocaleProperties = function (locale) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('getLocaleProperties'));
+        return this.localeConfig.getLocaleProperties(locale);
+    };
+    /**
+     * Retrieves multiple properties for a given region code, including:
+     * - `code`: the original region code
+     * - `name`: the localized display name
+     * - `emoji`: the associated flag or symbol
+     *
+     * Behavior:
+     * - Accepts ISO 3166-1 alpha-2 or UN M.49 region codes (e.g., `"US"`, `"FR"`, `"419"`).
+     * - Uses the instance's `targetLocale` to localize the region name for the user.
+     * - If `customMapping` contains a `name` or `emoji` for the region, those override the default values.
+     * - Otherwise, uses `Intl.DisplayNames` to get the localized region name, falling back to `libraryDefaultLocale`.
+     * - Falls back to the region code as `name` if display name resolution fails.
+     * - Falls back to a default emoji if no emoji mapping is found in built-in data or `customMapping`.
+     *
+     * @param {string} [region=this.getLocaleProperties().regionCode] - The region code to look up (e.g., `"US"`, `"GB"`, `"DE"`).
+     * @param {CustomRegionMapping} [customMapping] - Optional mapping of region codes to custom names and/or emojis.
+     * @returns {{ code: string, name: string, emoji: string }} An object containing:
+     *  - `code`: the input region code
+     *  - `name`: the localized or custom region name
+     *  - `emoji`: the matching emoji flag or symbol
+     *
+     * @throws {Error} If no target locale is available to determine region properties.
+     *
+     * @example
+     * const gt = new GT({ targetLocale: 'en-US' });
+     * gt.getRegionProperties('US');
+     * // => { code: 'US', name: 'United States', emoji: '🇺🇸' }
+     *
+     * @example
+     * const gt = new GT({ targetLocale: 'fr-FR' });
+     * gt.getRegionProperties('US');
+     * // => { code: 'US', name: 'États-Unis', emoji: '🇺🇸' }
+     *
+     * @example
+     * gt.getRegionProperties('US', { US: { name: 'USA', emoji: '🗽' } });
+     * // => { code: 'US', name: 'USA', emoji: '🗽' }
+     */
+    GT.prototype.getRegionProperties = function (region, customMapping) {
+        if (region === void 0) { region = this.getLocaleProperties().regionCode; }
+        if (!customMapping) {
+            if (this.customMapping && !this.customRegionMapping) {
+                // Lazy derive custom region mapping from customMapping
+                var customRegionMapping = {};
+                for (var _i = 0, _a = Object.entries(this.customMapping); _i < _a.length; _i++) {
+                    var _b = _a[_i], locale = _b[0], lp = _b[1];
+                    if (lp &&
+                        typeof lp === 'object' &&
+                        lp.regionCode &&
+                        !customRegionMapping[lp.regionCode]) {
+                        var name = lp.regionName, emoji = lp.emoji;
+                        customRegionMapping[lp.regionCode] = __assign(__assign({ locale: locale }, (name && { name: name })), (emoji && { emoji: emoji }));
+                    }
+                }
+                this.customRegionMapping = customRegionMapping;
+            }
+            customMapping = this.customRegionMapping;
+        }
+        return _getRegionProperties(region, this.targetLocale, // this.targetLocale because we want it in the user's language
+        customMapping);
+    };
+    /**
+     * Determines whether a translation is required based on the source and target locales.
+     *
+     * @param {string} [sourceLocale=this.sourceLocale] - The locale code for the original content.
+     * @param {string} [targetLocale=this.targetLocale] - The locale code to translate into.
+     * @param {string[]} [approvedLocales=this.locales] - Optional array of approved target locales.
+     * @returns {boolean} True if translation is required, false otherwise
+     * @throws {Error} If no source locale is provided.
+     * @throws {Error} If no target locale is provided.
+     *
+     * @example
+     * gt.requiresTranslation('en-US', 'es-ES');
+     * // Returns: true
+     */
+    GT.prototype.requiresTranslation = function (sourceLocale, targetLocale, approvedLocales, customMapping) {
+        if (sourceLocale === void 0) { sourceLocale = this.sourceLocale; }
+        if (targetLocale === void 0) { targetLocale = this.targetLocale; }
+        if (approvedLocales === void 0) { approvedLocales = this.locales; }
+        if (customMapping === void 0) { customMapping = this.customMapping; }
+        if (!sourceLocale)
+            throw new Error(noSourceLocaleProvidedError('requiresTranslation'));
+        if (!targetLocale)
+            throw new Error(noTargetLocaleProvidedError('requiresTranslation'));
+        if (customMapping === this.customMapping) {
+            return this.localeConfig.requiresTranslation(targetLocale, sourceLocale, approvedLocales);
+        }
+        return _requiresTranslation(sourceLocale, targetLocale, approvedLocales, customMapping);
+    };
+    /**
+     * Determines the best matching locale from the provided approved locales list.
+     *
+     * @param {string | string[]} locales - A single locale or array of locales in preference order.
+     * @param {string[]} [approvedLocales=this.locales] - Array of approved locales in preference order.
+     * @returns {string | undefined} The best matching locale, or undefined if no match is found.
+     *
+     * @example
+     * gt.determineLocale(['fr-CA', 'fr-FR'], ['en-US', 'fr-FR', 'es-ES']);
+     * // Returns: "fr-FR"
+     */
+    GT.prototype.determineLocale = function (locales, approvedLocales, customMapping) {
+        if (approvedLocales === void 0) { approvedLocales = this.locales || []; }
+        if (customMapping === void 0) { customMapping = this.customMapping; }
+        if (customMapping === this.customMapping) {
+            return this.localeConfig.determineLocale(locales, approvedLocales !== null && approvedLocales !== void 0 ? approvedLocales : []);
+        }
+        return _determineLocale(locales, approvedLocales, customMapping);
+    };
+    /**
+     * Gets the text direction for a given locale code.
+     *
+     * @param {string} [locale=this.targetLocale] - A BCP-47 locale code.
+     * @returns {'ltr' | 'rtl'} 'rtl' if the locale is right-to-left; otherwise 'ltr'.
+     * @throws {Error} If no target locale is provided.
+     *
+     * @example
+     * gt.getLocaleDirection('ar-SA');
+     * // Returns: "rtl"
+     */
+    GT.prototype.getLocaleDirection = function (locale) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('getLocaleDirection'));
+        return this.localeConfig.getLocaleDirection(locale);
+    };
+    /**
+     * Checks if a given BCP 47 locale code is valid.
+     *
+     * @param {string} [locale=this.targetLocale] - The BCP 47 locale code to validate.
+     * @param {CustomMapping} [customMapping=this.customMapping] - The custom mapping to use for validation.
+     * @returns {boolean} True if the locale code is valid, false otherwise
+     * @throws {Error} If no target locale is provided.
+     *
+     * @example
+     * gt.isValidLocale('en-US');
+     * // Returns: true
+     */
+    GT.prototype.isValidLocale = function (locale, customMapping) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (customMapping === void 0) { customMapping = this.customMapping; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('isValidLocale'));
+        if (customMapping === this.customMapping) {
+            return this.localeConfig.isValidLocale(locale);
+        }
+        return _isValidLocale(locale, customMapping);
+    };
+    /**
+     * Resolves the canonical locale for a given locale.
+     * @param locale - The locale to resolve the canonical locale for
+     * @param customMapping - The custom mapping to use for resolving the canonical locale
+     * @returns The canonical locale, or the input locale when no canonical mapping exists.
+     */
+    GT.prototype.resolveCanonicalLocale = function (locale, customMapping) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (customMapping === void 0) { customMapping = this.customMapping; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('resolveCanonicalLocale'));
+        if (customMapping === this.customMapping) {
+            return this.localeConfig.resolveCanonicalLocale(locale);
+        }
+        return _resolveCanonicalLocale(locale, customMapping);
+    };
+    /**
+     * Resolves the alias locale for a given locale.
+     * @param locale - The locale to resolve the alias locale for
+     * @param customMapping - The custom mapping to use for resolving the alias locale
+     * @returns The configured alias for a canonical locale, or the input locale when already an alias or no alias mapping exists.
+     */
+    GT.prototype.resolveAliasLocale = function (locale, customMapping) {
+        if (customMapping === void 0) { customMapping = this.customMapping; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('resolveAliasLocale'));
+        if (customMapping === this.customMapping) {
+            return this.localeConfig.resolveAliasLocale(locale);
+        }
+        return _resolveAliasLocale(locale, customMapping);
+    };
+    /**
+     * Standardizes a BCP 47 locale code to ensure correct formatting.
+     *
+     * @param {string} [locale=this.targetLocale] - The BCP 47 locale code to standardize.
+     * @returns {string} The standardized locale code, or the input string if it cannot be standardized.
+     * @throws {Error} If no target locale is provided.
+     *
+     * @example
+     * gt.standardizeLocale('en_us');
+     * // Returns: "en-US"
+     */
+    GT.prototype.standardizeLocale = function (locale) {
+        if (locale === void 0) { locale = this.targetLocale; }
+        if (!locale)
+            throw new Error(noTargetLocaleProvidedError('standardizeLocale'));
+        return this.localeConfig.standardizeLocale(locale);
+    };
+    /**
+     * Checks if multiple BCP 47 locale codes represent the same dialect.
+     *
+     * @param {...(string | string[])} locales - The BCP 47 locale codes to compare.
+     * @returns {boolean} True if all codes represent the same dialect, false otherwise
+     *
+     * @example
+     * gt.isSameDialect('en-US', 'en-GB');
+     * // Returns: false
+     *
+     * gt.isSameDialect('en', 'en-US');
+     * // Returns: true
+     */
+    GT.prototype.isSameDialect = function () {
+        var _a;
+        var locales = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            locales[_i] = arguments[_i];
+        }
+        return (_a = this.localeConfig).isSameDialect.apply(_a, locales);
+    };
+    /**
+     * Checks if multiple BCP 47 locale codes represent the same language.
+     *
+     * @param {...(string | string[])} locales - The BCP 47 locale codes to compare.
+     * @returns {boolean} True if all codes represent the same language, false otherwise
+     *
+     * @example
+     * gt.isSameLanguage('en-US', 'en-GB');
+     * // Returns: true
+     */
+    GT.prototype.isSameLanguage = function () {
+        var _a;
+        var locales = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            locales[_i] = arguments[_i];
+        }
+        return (_a = this.localeConfig).isSameLanguage.apply(_a, locales);
+    };
+    /**
+     * Checks if a locale is a superset of another locale.
+     *
+     * @param {string} superLocale - The locale to check if it is a superset
+     * @param {string} subLocale - The locale to check if it is a subset
+     * @returns {boolean} True if superLocale is a superset of subLocale, false otherwise
+     *
+     * @example
+     * gt.isSupersetLocale('en', 'en-US');
+     * // Returns: true
+     *
+     * gt.isSupersetLocale('en-US', 'en');
+     * // Returns: false
+     */
+    GT.prototype.isSupersetLocale = function (superLocale, subLocale) {
+        return this.localeConfig.isSupersetLocale(superLocale, subLocale);
+    };
+    return GT;
+}());
+export { GT };
+export var API_VERSION = _API_VERSION;