gtx-cli 1.2.15 → 1.2.16

package/dist/api/checkFileTranslations.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Checks the status of translations for a given version ID
+ * @param apiKey - The API key for the General Translation API
+ * @param baseUrl - The base URL for the General Translation API
+ * @param versionId - The version ID of the project
+ * @param locales - The locales to wait for
+ * @param startTime - The start time of the wait
+ * @param timeoutDuration - The timeout duration for the wait in seconds
+ * @returns True if all translations are deployed, false otherwise
+ */
+export declare function checkFileTranslations(apiKey: string, baseUrl: string, data: {
+    [key: string]: {
+        versionId: string;
+        fileName: string;
+    };
+}, locales: string[], timeoutDuration: number, resolveOutputPath: (sourcePath: string, locale: string) => string, downloadStatus: {
+    downloaded: Set<string>;
+    failed: Set<string>;
+}): Promise<boolean>;

package/dist/api/checkFileTranslations.js

@@ -0,0 +1,244 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkFileTranslations = checkFileTranslations;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = require("../console");
+const generaltranslation_1 = require("generaltranslation");
+const downloadFile_1 = require("./downloadFile");
+const downloadFileBatch_1 = require("./downloadFileBatch");
+/**
+ * Checks the status of translations for a given version ID
+ * @param apiKey - The API key for the General Translation API
+ * @param baseUrl - The base URL for the General Translation API
+ * @param versionId - The version ID of the project
+ * @param locales - The locales to wait for
+ * @param startTime - The start time of the wait
+ * @param timeoutDuration - The timeout duration for the wait in seconds
+ * @returns True if all translations are deployed, false otherwise
+ */
+async function checkFileTranslations(apiKey, baseUrl, data, locales, timeoutDuration, resolveOutputPath, downloadStatus) {
+    const startTime = Date.now();
+    console.log();
+    const spinner = await (0, console_1.createOraSpinner)();
+    spinner.start('Waiting for translation...');
+    // Initialize the query data
+    const fileQueryData = prepareFileQueryData(data, locales);
+    // Do first check immediately
+    const initialCheck = await checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath);
+    if (initialCheck) {
+        spinner.succeed(chalk_1.default.green('Files translated!'));
+        return true;
+    }
+    // Calculate time until next 5-second interval since startTime
+    const msUntilNextInterval = Math.max(0, 5000 - ((Date.now() - startTime) % 5000));
+    return new Promise((resolve) => {
+        let intervalCheck;
+        // Start the interval aligned with the original request time
+        setTimeout(() => {
+            intervalCheck = setInterval(async () => {
+                const isDeployed = await checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath);
+                const elapsed = Date.now() - startTime;
+                if (isDeployed || elapsed >= timeoutDuration * 1000) {
+                    clearInterval(intervalCheck);
+                    if (isDeployed) {
+                        spinner.succeed(chalk_1.default.green('All files translated!'));
+                        resolve(true);
+                    }
+                    else {
+                        spinner.fail(chalk_1.default.red('Timed out waiting for translations'));
+                        resolve(false);
+                    }
+                }
+            }, 5000);
+        }, msUntilNextInterval);
+    });
+}
+/**
+ * Prepares the file query data from input data and locales
+ */
+function prepareFileQueryData(data, locales) {
+    const fileQueryData = [];
+    for (const file in data) {
+        for (const locale of locales) {
+            fileQueryData.push({
+                versionId: data[file].versionId,
+                fileName: data[file].fileName,
+                locale,
+            });
+        }
+    }
+    return fileQueryData;
+}
+/**
+ * Generates a formatted status text showing translation progress
+ * @param downloadedFiles - Set of downloaded file+locale combinations
+ * @param fileQueryData - Array of file query data objects
+ * @returns Formatted status text
+ */
+function generateStatusSuffixText(downloadStatus, fileQueryData) {
+    // Simple progress indicator
+    const progressText = chalk_1.default.green(`[${downloadStatus.downloaded.size + downloadStatus.failed.size}/${fileQueryData.length}]`) + ` translations completed`;
+    // Get terminal height to adapt our output
+    const terminalHeight = process.stdout.rows || 24; // Default to 24 if undefined
+    // If terminal is very small, just show the basic progress
+    if (terminalHeight < 6) {
+        return `${progressText}`;
+    }
+    const newSuffixText = [`${progressText}`];
+    // Organize data by filename
+    const fileStatus = new Map();
+    // Initialize with all files and locales from fileQueryData
+    for (const item of fileQueryData) {
+        if (!fileStatus.has(item.fileName)) {
+            fileStatus.set(item.fileName, {
+                completed: new Set(),
+                pending: new Set([item.locale]),
+                failed: new Set(),
+            });
+        }
+        else {
+            fileStatus.get(item.fileName)?.pending.add(item.locale);
+        }
+    }
+    // Mark which ones are completed or failed
+    for (const fileLocale of downloadStatus.downloaded) {
+        const [fileName, locale] = fileLocale.split(':');
+        const status = fileStatus.get(fileName);
+        if (status) {
+            status.pending.delete(locale);
+            status.completed.add(locale);
+        }
+    }
+    for (const fileLocale of downloadStatus.failed) {
+        const [fileName, locale] = fileLocale.split(':');
+        const status = fileStatus.get(fileName);
+        if (status) {
+            status.pending.delete(locale);
+            status.failed.add(locale);
+        }
+    }
+    // Calculate how many files we can show based on terminal height
+    const filesArray = Array.from(fileStatus.entries());
+    const maxFilesToShow = Math.min(filesArray.length, terminalHeight - 3 // Header + progress + buffer
+    );
+    // Display each file with its status on a single line
+    for (let i = 0; i < maxFilesToShow; i++) {
+        const [fileName, status] = filesArray[i];
+        // Create condensed locale status
+        const localeStatuses = [];
+        // Add completed locales
+        if (status.completed.size > 0) {
+            const completedCodes = Array.from(status.completed)
+                .map((locale) => (0, generaltranslation_1.getLocaleProperties)(locale).code)
+                .join(', ');
+            localeStatuses.push(chalk_1.default.green(`${completedCodes}`));
+        }
+        // Add failed locales
+        if (status.failed.size > 0) {
+            const failedCodes = Array.from(status.failed)
+                .map((locale) => (0, generaltranslation_1.getLocaleProperties)(locale).code)
+                .join(', ');
+            localeStatuses.push(chalk_1.default.red(`${failedCodes}`));
+        }
+        // Add pending locales
+        if (status.pending.size > 0) {
+            const pendingCodes = Array.from(status.pending)
+                .map((locale) => (0, generaltranslation_1.getLocaleProperties)(locale).code)
+                .join(', ');
+            localeStatuses.push(chalk_1.default.yellow(`${pendingCodes}`));
+        }
+        // Format the line
+        newSuffixText.push(`${chalk_1.default.bold(fileName)} [${localeStatuses.join(', ')}]`);
+    }
+    // If we couldn't show all files, add an indicator
+    if (filesArray.length > maxFilesToShow) {
+        newSuffixText.push(`... and ${filesArray.length - maxFilesToShow} more files`);
+    }
+    return newSuffixText.join('\n');
+}
+/**
+ * Checks translation status and downloads ready files
+ */
+async function checkTranslationDeployment(baseUrl, apiKey, fileQueryData, downloadStatus, spinner, resolveOutputPath) {
+    try {
+        // Only query for files that haven't been downloaded yet
+        const currentQueryData = fileQueryData.filter((item) => !downloadStatus.downloaded.has(`${item.fileName}:${item.locale}`) &&
+            !downloadStatus.failed.has(`${item.fileName}:${item.locale}`));
+        // If all files have been downloaded, we're done
+        if (currentQueryData.length === 0) {
+            return true;
+        }
+        const response = await fetch(`${baseUrl}/v1/project/translations/files/retrieve`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...(apiKey && { 'x-gt-api-key': apiKey }),
+            },
+            body: JSON.stringify({ files: currentQueryData }),
+        });
+        if (response.ok) {
+            const responseData = await response.json();
+            const translations = responseData.translations || [];
+            // Filter for ready translations
+            const readyTranslations = translations.filter((translation) => translation.isReady && translation.fileName);
+            if (readyTranslations.length > 0) {
+                // Prepare batch download data
+                const batchFiles = readyTranslations.map((translation) => {
+                    const locale = translation.locale;
+                    const fileName = translation.fileName;
+                    const translationId = translation.id;
+                    const outputPath = resolveOutputPath(fileName, locale);
+                    return {
+                        translationId,
+                        outputPath,
+                        fileLocale: `${fileName}:${locale}`,
+                    };
+                });
+                // Use batch download if there are multiple files
+                if (batchFiles.length > 1) {
+                    const batchResult = await (0, downloadFileBatch_1.downloadFileBatch)(baseUrl, apiKey, batchFiles.map(({ translationId, outputPath }) => ({
+                        translationId,
+                        outputPath,
+                    })));
+                    // Process results
+                    batchFiles.forEach((file) => {
+                        const { translationId, fileLocale } = file;
+                        if (batchResult.successful.includes(translationId)) {
+                            downloadStatus.downloaded.add(fileLocale);
+                        }
+                        else if (batchResult.failed.includes(translationId)) {
+                            downloadStatus.failed.add(fileLocale);
+                        }
+                    });
+                }
+                else if (batchFiles.length === 1) {
+                    // For a single file, use the original downloadFile method
+                    const file = batchFiles[0];
+                    const result = await (0, downloadFile_1.downloadFile)(baseUrl, apiKey, file.translationId, file.outputPath);
+                    if (result) {
+                        downloadStatus.downloaded.add(file.fileLocale);
+                    }
+                    else {
+                        downloadStatus.failed.add(file.fileLocale);
+                    }
+                }
+            }
+            // Force a refresh of the spinner display
+            const statusText = generateStatusSuffixText(downloadStatus, fileQueryData);
+            // Clear and reapply the suffix to force a refresh
+            spinner.text = statusText;
+        }
+        if (downloadStatus.downloaded.size + downloadStatus.failed.size ===
+            fileQueryData.length) {
+            return true;
+        }
+        return false;
+    }
+    catch (error) {
+        (0, console_1.logError)(chalk_1.default.red('Error checking translation status: ') + error);
+        return false;
+    }
+}

package/dist/api/downloadFile.d.ts

@@ -0,0 +1 @@
+export declare function downloadFile(baseUrl: string, apiKey: string, translationId: string, outputPath: string, maxRetries?: number, retryDelay?: number): Promise<boolean>;

package/dist/api/downloadFile.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFile = downloadFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_1 = require("../console/console");
+// Helper function to download a file
+async function downloadFile(baseUrl, apiKey, translationId, outputPath, maxRetries = 3, retryDelay = 1000) {
+    let retries = 0;
+    while (retries <= maxRetries) {
+        try {
+            const downloadResponse = await fetch(`${baseUrl}/v1/project/translations/files/${translationId}/download`, {
+                method: 'GET',
+                headers: {
+                    ...(apiKey && { 'x-gt-api-key': apiKey }),
+                },
+            });
+            if (downloadResponse.ok) {
+                // Ensure the directory exists
+                const dir = path.dirname(outputPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                // Get the file data as an ArrayBuffer
+                const fileData = await downloadResponse.arrayBuffer();
+                // Write the file to disk
+                await fs.promises.writeFile(outputPath, Buffer.from(fileData));
+                return true;
+            }
+            // If we get here, the response was not OK
+            if (retries >= maxRetries) {
+                (0, console_1.logError)(`Failed to download file ${outputPath}. Status: ${downloadResponse.status} after ${maxRetries + 1} attempts.`);
+                return false;
+            }
+            // Increment retry counter and wait before next attempt
+            retries++;
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        catch (error) {
+            if (retries >= maxRetries) {
+                (0, console_1.logError)(`Error downloading file ${outputPath} after ${maxRetries + 1} attempts: ` +
+                    error);
+                return false;
+            }
+            retries++;
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+    }
+    return false;
+}

package/dist/api/downloadFileBatch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Downloads multiple translation files in a single batch request
+ * @param baseUrl - The base URL for the General Translation API
+ * @param apiKey - The API key for the General Translation API
+ * @param files - Array of files to download with their output paths
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryDelay - Delay between retries in milliseconds
+ * @returns Object containing successful and failed file IDs
+ */
+export declare function downloadFileBatch(baseUrl: string, apiKey: string, files: Array<{
+    translationId: string;
+    outputPath: string;
+}>, maxRetries?: number, retryDelay?: number): Promise<{
+    successful: string[];
+    failed: string[];
+}>;

package/dist/api/downloadFileBatch.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadFileBatch = downloadFileBatch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_1 = require("../console/console");
+/**
+ * Downloads multiple translation files in a single batch request
+ * @param baseUrl - The base URL for the General Translation API
+ * @param apiKey - The API key for the General Translation API
+ * @param files - Array of files to download with their output paths
+ * @param maxRetries - Maximum number of retry attempts
+ * @param retryDelay - Delay between retries in milliseconds
+ * @returns Object containing successful and failed file IDs
+ */
+async function downloadFileBatch(baseUrl, apiKey, files, maxRetries = 3, retryDelay = 1000) {
+    let retries = 0;
+    const fileIds = files.map((file) => file.translationId);
+    const result = { successful: [], failed: [] };
+    // Create a map of translationId to outputPath for easier lookup
+    const outputPathMap = new Map(files.map((file) => [file.translationId, file.outputPath]));
+    while (retries <= maxRetries) {
+        try {
+            const response = await fetch(`${baseUrl}/v1/project/translations/files/batch-download`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...(apiKey && { 'x-gt-api-key': apiKey }),
+                },
+                body: JSON.stringify({ fileIds }),
+            });
+            if (response.ok) {
+                const responseData = await response.json();
+                const downloadedFiles = responseData.files || [];
+                // Process each file in the response
+                for (const file of downloadedFiles) {
+                    try {
+                        const translationId = file.id;
+                        const outputPath = outputPathMap.get(translationId);
+                        if (!outputPath) {
+                            (0, console_1.logWarning)(`No output path found for file: ${translationId}`);
+                            result.failed.push(translationId);
+                            continue;
+                        }
+                        // Ensure the directory exists
+                        const dir = path.dirname(outputPath);
+                        if (!fs.existsSync(dir)) {
+                            fs.mkdirSync(dir, { recursive: true });
+                        }
+                        // Write the file to disk
+                        await fs.promises.writeFile(outputPath, file.data);
+                        result.successful.push(translationId);
+                    }
+                    catch (error) {
+                        (0, console_1.logError)(`Error saving file ${file.id}: ` + error);
+                        result.failed.push(file.id);
+                    }
+                }
+                // Add any files that weren't in the response to the failed list
+                const downloadedIds = new Set(downloadedFiles.map((file) => file.id));
+                for (const fileId of fileIds) {
+                    if (!downloadedIds.has(fileId) && !result.failed.includes(fileId)) {
+                        result.failed.push(fileId);
+                    }
+                }
+                return result;
+            }
+            // If we get here, the response was not OK
+            if (retries >= maxRetries) {
+                (0, console_1.logError)(`Failed to download files in batch. Status: ${response.status} after ${maxRetries + 1} attempts.`);
+                // Mark all files as failed
+                result.failed = [...fileIds];
+                return result;
+            }
+            // Increment retry counter and wait before next attempt
+            retries++;
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        catch (error) {
+            if (retries >= maxRetries) {
+                (0, console_1.logError)(`Error downloading files in batch after ${maxRetries + 1} attempts: ` +
+                    error);
+                // Mark all files as failed
+                result.failed = [...fileIds];
+                return result;
+            }
+            retries++;
+            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+    }
+    // Mark all files as failed if we get here
+    result.failed = [...fileIds];
+    return result;
+}

package/dist/api/fetchTranslations.d.ts

@@ -0,0 +1,10 @@
+import { RetrievedTranslations } from '../types/api';
+/**
+ * Fetches translations from the API and saves them to a local directory
+ * @param baseUrl - The base URL for the API
+ * @param apiKey - The API key for the API
+ * @param versionId - The version ID of the project
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+export declare function fetchTranslations(baseUrl: string, apiKey: string, versionId: string): Promise<RetrievedTranslations>;

package/dist/api/fetchTranslations.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTranslations = fetchTranslations;
+const chalk_1 = __importDefault(require("chalk"));
+const errors_1 = require("../console/errors");
+/**
+ * Fetches translations from the API and saves them to a local directory
+ * @param baseUrl - The base URL for the API
+ * @param apiKey - The API key for the API
+ * @param versionId - The version ID of the project
+ * @param translationsDir - The directory to save the translations to
+ * @param fileType - The file type to save the translations as (file extension)
+ */
+async function fetchTranslations(baseUrl, apiKey, versionId) {
+    // First fetch the translations from the API
+    const response = await fetch(`${baseUrl}/v1/project/translations/info/${encodeURIComponent(versionId)}`, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+            ...(apiKey && { 'x-gt-api-key': apiKey }),
+        },
+    });
+    if (response.ok) {
+        const data = await response.json();
+        const translations = data.translations;
+        return translations;
+    }
+    else {
+        (0, errors_1.logError)(chalk_1.default.red('Failed to fetch translations'));
+    }
+    return [];
+}

package/dist/api/sendFiles.d.ts

@@ -0,0 +1,24 @@
+import { Settings } from '../types';
+import { FileFormats, DataFormat } from '../types/data';
+export interface FileToTranslate {
+    content: string;
+    fileName: string;
+    fileFormat: FileFormats;
+    dataFormat: DataFormat;
+}
+type ApiOptions = Settings & {
+    publish: boolean;
+    wait: boolean;
+};
+/**
+ * Sends multiple files for translation to the API
+ * @param files - Array of file objects to translate
+ * @param options - The options for the API call
+ * @returns The translated content or version ID
+ */
+export declare function sendFiles(files: FileToTranslate[], options: ApiOptions): Promise<{
+    data: any;
+    locales: any;
+    translations: any;
+}>;
+export {};

package/dist/api/sendFiles.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendFiles = sendFiles;
+const chalk_1 = __importDefault(require("chalk"));
+const console_1 = require("../console");
+/**
+ * Sends multiple files for translation to the API
+ * @param files - Array of file objects to translate
+ * @param options - The options for the API call
+ * @returns The translated content or version ID
+ */
+async function sendFiles(files, options) {
+    const { apiKey } = options;
+    (0, console_1.logMessage)(chalk_1.default.cyan('Files to translate:') +
+        '\n' +
+        files.map((file) => `  - ${chalk_1.default.bold(file.fileName)}`).join('\n'));
+    const spinner = (0, console_1.createSpinner)('dots');
+    spinner.start(`Sending ${files.length} file${files.length > 1 ? 's' : ''} to General Translation API...`);
+    try {
+        // Create form data
+        const formData = new FormData();
+        // Add each file to the form data
+        files.forEach((file, index) => {
+            formData.append(`file${index}`, new Blob([file.content]), file.fileName);
+            formData.append(`fileFormat${index}`, file.fileFormat);
+            formData.append(`fileDataFormat${index}`, file.dataFormat); // Only used when translating JSON files
+            formData.append(`fileName${index}`, file.fileName);
+        });
+        // Add number of files
+        formData.append('fileCount', String(files.length));
+        // Add other metadata
+        formData.append('sourceLocale', options.defaultLocale);
+        formData.append('targetLocales', JSON.stringify(options.locales));
+        formData.append('projectId', options.projectId);
+        formData.append('publish', String(options.publish));
+        formData.append('versionId', options._versionId || '');
+        formData.append('description', options.description || '');
+        const response = await fetch(`${options.baseUrl}/v1/project/translations/files/upload`, {
+            method: 'POST',
+            headers: {
+                ...(apiKey && { 'x-gt-api-key': apiKey }),
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            spinner.stop(chalk_1.default.red(await response.text()));
+            process.exit(1);
+        }
+        const responseData = await response.json();
+        // Handle version ID response (for async processing)
+        const { data, message, locales, translations } = responseData;
+        spinner.stop(chalk_1.default.green('Files for translation uploaded successfully'));
+        (0, console_1.logSuccess)(message);
+        return { data, locales, translations };
+    }
+    catch (error) {
+        spinner.stop(chalk_1.default.red('Failed to send files for translation'));
+        throw error;
+    }
+}

package/dist/api/sendUpdates.d.ts

@@ -0,0 +1,19 @@
+import { Settings, SupportedLibraries, Updates } from '../types';
+import { DataFormat } from '../types/data';
+type ApiOptions = Settings & {
+    timeout: string;
+    dataFormat: DataFormat;
+    description?: string;
+    requireApproval?: boolean;
+};
+/**
+ * Sends updates to the API
+ * @param updates - The updates to send
+ * @param options - The options for the API call
+ * @returns The versionId of the updated project
+ */
+export declare function sendUpdates(updates: Updates, options: ApiOptions, library: SupportedLibraries): Promise<{
+    versionId: string;
+    locales: string[];
+}>;
+export {};