gtx-cli 2.5.0-alpha.0 → 2.5.0-alpha.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # gtx-cli
 
+## 2.4.15
+
+### Patch Changes
+
+- [#792](https://github.com/generaltranslation/gt/pull/792) [`b6d6869`](https://github.com/generaltranslation/gt/commit/b6d686917316f6ed44130a54509459a7f9ee35fa) Thanks [@fernando-aviles](https://github.com/fernando-aviles)! - Skipping over JSON and YAML files with failing parse to avoid crashing
+
+## 2.4.14
+
+### Patch Changes
+
+- Updated dependencies [[`3da05a1`](https://github.com/generaltranslation/gt/commit/3da05a12a37a62ace3c7e321aa2fed5a4af52ad9)]:
+  - generaltranslation@7.9.1
+
 ## 2.4.13
 
 ### Patch Changes

package/dist/api/collectUserEditDiffs.d.ts

@@ -1,14 +1,9 @@
 import { Settings } from '../types/index.js';
-type UploadedFileRef = {
-    fileId: string;
-    versionId: string;
-    fileName: string;
-};
+import { FileReference } from 'generaltranslation/types';
 /**
  * Collects local user edits by diffing the latest downloaded server translation version
  * against the current local translation file, and submits the diffs upstream.
  *
  * Must run before enqueueing new translations so rules are available to the generator.
  */
-export declare function collectAndSendUserEditDiffs(uploadedFiles: UploadedFileRef[], settings: Settings): Promise<void>;
-export {};
+export declare function collectAndSendUserEditDiffs(files: FileReference[], settings: Settings): Promise<void>;

package/dist/api/collectUserEditDiffs.js

@@ -3,48 +3,41 @@ import * as path from 'node:path';
 import { getDownloadedVersions } from '../fs/config/downloadedVersions.js';
 import { createFileMapping } from '../formats/files/fileMapping.js';
 import { getGitUnifiedDiff } from '../utils/gitDiff.js';
-import { sendUserEditDiffs } from './sendUserEdits.js';
 import { gt } from '../utils/gt.js';
-const MAX_DIFF_BATCH_BYTES = 1_500_000;
-const MAX_DOWNLOAD_BATCH = 100;
+import os from 'node:os';
+import { randomUUID } from 'node:crypto';
 /**
  * Collects local user edits by diffing the latest downloaded server translation version
  * against the current local translation file, and submits the diffs upstream.
  *
  * Must run before enqueueing new translations so rules are available to the generator.
  */
-export async function collectAndSendUserEditDiffs(uploadedFiles, settings) {
+export async function collectAndSendUserEditDiffs(files, settings) {
     if (!settings.files)
         return;
     const { resolvedPaths, placeholderPaths, transformPaths } = settings.files;
     const fileMapping = createFileMapping(resolvedPaths, placeholderPaths, transformPaths, settings.locales, settings.defaultLocale);
     const downloadedVersions = getDownloadedVersions(settings.configDirectory);
-    const tempDir = path.join(settings.configDirectory, 'tmp');
+    const tempDir = path.join(os.tmpdir(), randomUUID());
     if (!fs.existsSync(tempDir))
         fs.mkdirSync(tempDir, { recursive: true });
     const candidates = [];
-    for (const uploadedFile of uploadedFiles) {
+    for (const uploadedFile of files) {
         for (const locale of settings.locales) {
-            const resolvedLocale = gt.resolveAliasLocale(locale);
             const outputPath = fileMapping[locale]?.[uploadedFile.fileName] ?? null;
             if (!outputPath)
                 continue;
             if (!fs.existsSync(outputPath))
                 continue;
-            const lockKeyById = uploadedFile.fileId
-                ? `${uploadedFile.fileId}:${resolvedLocale}`
-                : null;
-            const lockKeyByName = `${uploadedFile.fileName}:${resolvedLocale}`;
-            const lockEntry = (lockKeyById && downloadedVersions.entries[lockKeyById]) ||
-                downloadedVersions.entries[lockKeyByName];
-            const versionId = lockEntry?.versionId;
-            if (!versionId)
+            const downloadedVersion = downloadedVersions.entries?.[uploadedFile.branchId]?.[uploadedFile.fileId]?.[uploadedFile.versionId]?.[locale];
+            if (!downloadedVersion)
                 continue;
             candidates.push({
+                branchId: uploadedFile.branchId,
                 fileName: uploadedFile.fileName,
                 fileId: uploadedFile.fileId,
-                versionId,
-                locale: resolvedLocale,
+                versionId: uploadedFile.versionId,
+                locale: locale,
                 outputPath,
             });
         }
@@ -53,59 +46,39 @@ export async function collectAndSendUserEditDiffs(uploadedFiles, settings) {
     if (candidates.length > 0) {
         const fileQueryData = candidates.map((c) => ({
             versionId: c.versionId,
-            fileName: c.fileName,
             locale: c.locale,
+            fileId: c.fileId,
+            branchId: c.branchId,
         }));
         // Single batched check to obtain translation IDs
-        const checkResponse = await gt.checkFileTranslations(fileQueryData);
-        const translations = (checkResponse?.translations || []).filter((t) => t && t.isReady && t.id && t.fileName && t.locale);
-        // Map fileName:resolvedLocale -> translationId
-        const idByKey = new Map();
-        for (const t of translations) {
-            const resolved = gt.resolveAliasLocale(t.locale);
-            idByKey.set(`${t.fileName}:${resolved}`, t.id);
-        }
-        // Collect translation IDs in batches and download contents
-        const ids = [];
-        for (const c of candidates) {
-            const id = idByKey.get(`${c.fileName}:${c.locale}`);
-            if (id)
-                ids.push(id);
-        }
-        // Helper to chunk array
-        function chunk(arr, size) {
-            const res = [];
-            for (let i = 0; i < arr.length; i += size)
-                res.push(arr.slice(i, i + size));
-            return res;
-        }
+        const checkResponse = await gt.queryFileData({
+            translatedFiles: fileQueryData,
+        });
+        const translatedFiles = checkResponse.translatedFiles?.filter((t) => t.completedAt) ?? [];
         const serverContentByKey = new Map();
-        for (const idChunk of chunk(ids, MAX_DOWNLOAD_BATCH)) {
-            try {
-                const resp = await gt.downloadFileBatch(idChunk);
-                const files = resp?.files || [];
-                for (const f of files) {
-                    // Find corresponding candidate key via idByKey reverse lookup
-                    for (const [key, id] of idByKey.entries()) {
-                        if (id === f.id) {
-                            serverContentByKey.set(key, f.data);
-                            break;
-                        }
-                    }
-                }
-            }
-            catch {
-                // Ignore chunk failures; proceed with what we have
+        try {
+            const resp = await gt.downloadFileBatch(translatedFiles.map((file) => ({
+                branchId: file.branchId,
+                fileId: file.fileId,
+                locale: file.locale,
+                versionId: file.versionId,
+            })));
+            const files = resp?.files || [];
+            for (const f of files) {
+                serverContentByKey.set(`${f.branchId}:${f.fileId}:${f.versionId}:${f.locale}`, f.data);
             }
         }
+        catch {
+            // Ignore chunk failures; proceed with what we have
+        }
         // Compute diffs using fetched server contents
         for (const c of candidates) {
-            const key = `${c.fileName}:${c.locale}`;
+            const key = `${c.branchId}:${c.fileId}:${c.versionId}:${c.locale}`;
             const serverContent = serverContentByKey.get(key);
             if (!serverContent)
                 continue;
             try {
-                const safeName = Buffer.from(`${c.fileName}:${c.locale}`)
+                const safeName = Buffer.from(`${c.branchId}:${c.fileId}:${c.versionId}:${c.locale}`)
                     .toString('base64')
                     .replace(/=+$/g, '');
                 const tempServerFile = path.join(tempDir, `${safeName}.server`);
@@ -121,6 +94,7 @@ export async function collectAndSendUserEditDiffs(uploadedFiles, settings) {
                         fileName: c.fileName,
                         locale: c.locale,
                         diff,
+                        branchId: c.branchId,
                         versionId: c.versionId,
                         fileId: c.fileId,
                         localContent,
@@ -133,25 +107,6 @@ export async function collectAndSendUserEditDiffs(uploadedFiles, settings) {
         }
     }
     if (collectedDiffs.length > 0) {
-        // Batch by payload size
-        const maxBatchBytes = MAX_DIFF_BATCH_BYTES;
-        const batches = [];
-        let currentBatch = [];
-        for (const d of collectedDiffs) {
-            const tentative = [...currentBatch, d];
-            const bytes = Buffer.byteLength(JSON.stringify({ projectId: settings.projectId, diffs: tentative }), 'utf8');
-            if (bytes > maxBatchBytes && currentBatch.length > 0) {
-                batches.push(currentBatch);
-                currentBatch = [d];
-            }
-            else {
-                currentBatch = tentative;
-            }
-        }
-        if (currentBatch.length > 0)
-            batches.push(currentBatch);
-        for (const batch of batches) {
-            await sendUserEditDiffs(batch, settings);
-        }
+        await gt.submitUserEditDiffs({ diffs: collectedDiffs });
     }
 }

package/dist/api/downloadFileBatch.d.ts

@@ -1,16 +1,17 @@
 import { Settings } from '../types/index.js';
-export type BatchedFiles = Array<{
-    translationId: string;
+import type { FileStatusTracker } from '../workflow/PollJobsStep.js';
+export type BatchedFiles = {
+    branchId: string;
+    fileId: string;
+    versionId: string;
+    locale: string;
     outputPath: string;
     inputPath: string;
-    locale: string;
-    fileLocale: string;
-    fileId?: string;
-    versionId?: string;
-}>;
+}[];
 export type DownloadFileBatchResult = {
-    successful: string[];
-    failed: string[];
+    successful: BatchedFiles;
+    failed: BatchedFiles;
+    skipped: BatchedFiles;
 };
 /**
  * Downloads multiple translation files in a single batch request
@@ -19,4 +20,4 @@ export type DownloadFileBatchResult = {
  * @param retryDelay - Delay between retries in milliseconds
  * @returns Object containing successful and failed file IDs
  */
-export declare function downloadFileBatch(files: BatchedFiles, options: Settings, maxRetries?: number, retryDelay?: number, forceDownload?: boolean): Promise<DownloadFileBatchResult>;
+export declare function downloadFileBatch(fileTracker: FileStatusTracker, files: BatchedFiles, options: Settings, forceDownload?: boolean): Promise<DownloadFileBatchResult>;

package/dist/api/downloadFileBatch.js

@@ -6,7 +6,7 @@ import { validateJsonSchema } from '../formats/json/utils.js';
 import { validateYamlSchema } from '../formats/yaml/utils.js';
 import { mergeJson } from '../formats/json/mergeJson.js';
 import mergeYaml from '../formats/yaml/mergeYaml.js';
-import { getDownloadedVersions, saveDownloadedVersions, } from '../fs/config/downloadedVersions.js';
+import { getDownloadedVersions, saveDownloadedVersions, ensureNestedObject, } from '../fs/config/downloadedVersions.js';
 import { recordDownloaded } from '../state/recentDownloads.js';
 import stringify from 'fast-json-stable-stringify';
 /**
@@ -16,152 +16,145 @@ import stringify from 'fast-json-stable-stringify';
  * @param retryDelay - Delay between retries in milliseconds
  * @returns Object containing successful and failed file IDs
  */
-export async function downloadFileBatch(files, options, maxRetries = 3, retryDelay = 1000, forceDownload = false) {
+export async function downloadFileBatch(fileTracker, files, options, forceDownload = false) {
     // Local record of what version was last downloaded for each fileName:locale
     const downloadedVersions = getDownloadedVersions(options.configDirectory);
     let didUpdateDownloadedLock = false;
-    let retries = 0;
-    const fileIds = files.map((file) => file.translationId);
-    const result = { successful: [], failed: [] };
+    // Create a map of requested file keys to the file object
+    const requestedFileMap = new Map(files.map((file) => [
+        `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,
+        file,
+    ]));
+    const result = {
+        successful: [],
+        failed: [],
+        skipped: [],
+    };
     // Create a map of translationId to outputPath for easier lookup
-    const outputPathMap = new Map(files.map((file) => [file.translationId, file.outputPath]));
-    const inputPathMap = new Map(files.map((file) => [file.translationId, file.inputPath]));
-    const fileIdMap = new Map(files.map((file) => [file.translationId, file.fileId]));
-    const localeMap = new Map(files.map((file) => [
-        file.translationId,
-        gt.resolveAliasLocale(file.locale),
+    const outputPathMap = new Map(files.map((file) => [
+        `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`,
+        file.outputPath,
     ]));
-    const versionMap = new Map(files.map((file) => [file.translationId, file.versionId]));
-    while (retries <= maxRetries) {
-        try {
-            // Download the files
-            const responseData = await gt.downloadFileBatch(fileIds);
-            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);
-                    const inputPath = inputPathMap.get(translationId);
-                    const locale = localeMap.get(translationId);
-                    const fileId = fileIdMap.get(translationId);
-                    const versionId = versionMap.get(translationId);
-                    if (!outputPath || !inputPath) {
-                        logWarning(`No input/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 });
-                    }
-                    // If a local translation already exists for the same source version, skip overwrite
-                    const keyId = fileId || inputPath;
-                    const downloadedKey = `${keyId}:${locale}`;
-                    const alreadyDownloadedVersion = downloadedVersions.entries[downloadedKey]?.versionId;
-                    const fileExists = fs.existsSync(outputPath);
-                    if (!forceDownload &&
-                        fileExists &&
-                        versionId &&
-                        alreadyDownloadedVersion === versionId) {
-                        result.successful.push(translationId);
-                        continue;
-                    }
-                    let data = file.data;
-                    if (options.options?.jsonSchema && locale) {
-                        const jsonSchema = validateJsonSchema(options.options, inputPath);
-                        if (jsonSchema) {
-                            const originalContent = fs.readFileSync(inputPath, 'utf8');
-                            if (originalContent) {
-                                data = mergeJson(originalContent, inputPath, options.options, [
-                                    {
-                                        translatedContent: file.data,
-                                        targetLocale: locale,
-                                    },
-                                ], options.defaultLocale)[0];
-                            }
+    try {
+        // Download the files
+        const responseData = await gt.downloadFileBatch(files.map((file) => ({
+            fileId: file.fileId,
+            branchId: file.branchId,
+            versionId: file.versionId,
+            locale: file.locale,
+        })));
+        const downloadedFiles = responseData.files || [];
+        // Process each file in the response
+        for (const file of downloadedFiles) {
+            const fileKey = `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`;
+            const requestedFile = requestedFileMap.get(fileKey);
+            if (!requestedFile) {
+                continue;
+            }
+            try {
+                const outputPath = outputPathMap.get(fileKey);
+                const fileProperties = fileTracker.completed.get(fileKey);
+                if (!outputPath || !fileProperties) {
+                    logWarning(`No input/output path found for file: ${fileKey}`);
+                    result.failed.push(requestedFile);
+                    continue;
+                }
+                const { fileId, versionId, locale, branchId, fileName: inputPath, } = fileProperties;
+                // Ensure the directory exists
+                const dir = path.dirname(outputPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                // If a local translation already exists for the same source version, skip overwrite
+                const downloadedVersion = downloadedVersions.entries[branchId]?.[fileId]?.[versionId]?.[locale];
+                const fileExists = fs.existsSync(outputPath);
+                if (!forceDownload && fileExists && downloadedVersion) {
+                    result.skipped.push(requestedFile);
+                    continue;
+                }
+                let data = file.data;
+                if (options.options?.jsonSchema && locale) {
+                    const jsonSchema = validateJsonSchema(options.options, inputPath);
+                    if (jsonSchema) {
+                        const originalContent = fs.readFileSync(inputPath, 'utf8');
+                        if (originalContent) {
+                            data = mergeJson(originalContent, inputPath, options.options, [
+                                {
+                                    translatedContent: file.data,
+                                    targetLocale: locale,
+                                },
+                            ], options.defaultLocale)[0];
                         }
                     }
-                    if (options.options?.yamlSchema && locale) {
-                        const yamlSchema = validateYamlSchema(options.options, inputPath);
-                        if (yamlSchema) {
-                            const originalContent = fs.readFileSync(inputPath, 'utf8');
-                            if (originalContent) {
-                                data = mergeYaml(originalContent, inputPath, options.options, [
-                                    {
-                                        translatedContent: file.data,
-                                        targetLocale: locale,
-                                    },
-                                ], options.defaultLocale)[0];
-                            }
+                }
+                if (options.options?.yamlSchema && locale) {
+                    const yamlSchema = validateYamlSchema(options.options, inputPath);
+                    if (yamlSchema) {
+                        const originalContent = fs.readFileSync(inputPath, 'utf8');
+                        if (originalContent) {
+                            data = mergeYaml(originalContent, inputPath, options.options, [
+                                {
+                                    translatedContent: file.data,
+                                    targetLocale: locale,
+                                },
+                            ], options.defaultLocale)[0];
                         }
                     }
-                    // If the file is a GTJSON file, stable sort the order and format the data
-                    if (file.fileFormat === 'GTJSON') {
-                        try {
-                            const jsonData = JSON.parse(data);
-                            const sortedData = stringify(jsonData); // stably sort with fast-json-stable-stringify
-                            const sortedJsonData = JSON.parse(sortedData);
-                            data = JSON.stringify(sortedJsonData, null, 2); // format the data
-                        }
-                        catch (error) {
-                            logWarning(`Failed to sort GTJson file: ${file.id}: ` + error);
-                        }
+                }
+                // If the file is a GTJSON file, stable sort the order and format the data
+                if (file.fileFormat === 'GTJSON') {
+                    try {
+                        const jsonData = JSON.parse(data);
+                        const sortedData = stringify(jsonData); // stably sort with fast-json-stable-stringify
+                        const sortedJsonData = JSON.parse(sortedData);
+                        data = JSON.stringify(sortedJsonData, null, 2); // format the data
                     }
-                    // Write the file to disk
-                    await fs.promises.writeFile(outputPath, data);
-                    // Track as downloaded
-                    recordDownloaded(outputPath);
-                    result.successful.push(translationId);
-                    if (versionId) {
-                        downloadedVersions.entries[downloadedKey] = {
-                            versionId,
-                            fileId: fileId || undefined,
-                            fileName: inputPath,
-                            updatedAt: new Date().toISOString(),
-                        };
-                        didUpdateDownloadedLock = true;
+                    catch (error) {
+                        logWarning(`Failed to sort GTJson file: ${file.id}: ` + error);
                     }
                 }
-                catch (error) {
-                    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);
+                // Write the file to disk
+                await fs.promises.writeFile(outputPath, data);
+                // Track as downloaded
+                recordDownloaded(outputPath);
+                result.successful.push(requestedFile);
+                if (branchId && fileId && versionId && locale) {
+                    ensureNestedObject(downloadedVersions.entries, [
+                        branchId,
+                        fileId,
+                        versionId,
+                        locale,
+                    ]);
+                    downloadedVersions.entries[branchId][fileId][versionId][locale] = {
+                        updatedAt: new Date().toISOString(),
+                    };
+                    didUpdateDownloadedLock = true;
                 }
             }
-            // Persist any updates to the downloaded map at the end of a successful cycle
-            if (didUpdateDownloadedLock) {
-                saveDownloadedVersions(options.configDirectory, downloadedVersions);
-                didUpdateDownloadedLock = false;
+            catch (error) {
+                logError(`Error saving file ${fileKey}: ` + error);
+                result.failed.push(requestedFile);
             }
-            return result;
         }
-        catch (error) {
-            // If we've retried too many times, log an error and return false
-            if (retries >= maxRetries) {
-                logError(`Error downloading files in batch after ${maxRetries + 1} attempts: ` +
-                    error);
-                // Mark all files as failed
-                result.failed = [...fileIds];
-                if (didUpdateDownloadedLock) {
-                    saveDownloadedVersions(options.configDirectory, downloadedVersions);
-                }
-                return result;
+        // Add any files that weren't in the response to the failed list
+        const downloadedFileKeys = new Set(downloadedFiles.map((file) => `${file.branchId}:${file.fileId}:${file.versionId}:${file.locale}`));
+        for (const [fileKey, requestedFile] of requestedFileMap.entries()) {
+            if (!downloadedFileKeys.has(fileKey)) {
+                result.failed.push(requestedFile);
             }
-            // Increment retry counter and wait before next attempt
-            retries++;
-            await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }
+        // Persist any updates to the downloaded map at the end of a successful cycle
+        if (didUpdateDownloadedLock) {
+            saveDownloadedVersions(options.configDirectory, downloadedVersions);
+            didUpdateDownloadedLock = false;
+        }
+        return result;
+    }
+    catch (error) {
+        logError(`An unexpected error occurred while downloading files: ` + error);
     }
     // Mark all files as failed if we get here
-    result.failed = [...fileIds];
+    result.failed = [...requestedFileMap.values()];
     if (didUpdateDownloadedLock) {
         saveDownloadedVersions(options.configDirectory, downloadedVersions);
     }

package/dist/api/saveLocalEdits.js

@@ -1,6 +1,8 @@
-import { gt } from '../utils/gt.js';
 import { aggregateFiles } from '../formats/files/translate.js';
 import { collectAndSendUserEditDiffs } from './collectUserEditDiffs.js';
+import { gt } from '../utils/gt.js';
+import { BranchStep } from '../workflow/BranchStep.js';
+import { logErrorAndExit } from '../console/logging.js';
 /**
  * Uploads current source files to obtain file references, then collects and sends
  * diffs for all locales based on last downloaded versions. Does not enqueue translations.
@@ -12,19 +14,20 @@ export async function saveLocalEdits(settings) {
     const files = await aggregateFiles(settings);
     if (!files.length)
         return;
-    const uploads = files.map(({ content, fileName, fileFormat, dataFormat }) => ({
-        source: {
-            content,
-            fileName,
-            fileFormat,
-            dataFormat,
-            locale: settings.defaultLocale,
-        },
+    // run branch query to get branch id
+    // Run the branch step
+    const branchStep = new BranchStep(gt, settings);
+    const branchResult = await branchStep.run();
+    await branchStep.wait();
+    if (!branchResult) {
+        logErrorAndExit('Failed to resolve git branch information.');
+    }
+    const uploads = files.map((file) => ({
+        fileName: file.fileName,
+        fileFormat: file.fileFormat,
+        branchId: branchResult.currentBranch.id,
+        fileId: file.fileId,
+        versionId: file.versionId,
     }));
-    // Upload sources only to get file references, then compute diffs
-    const upload = await gt.uploadSourceFiles(uploads, {
-        sourceLocale: settings.defaultLocale,
-        modelProvider: settings.modelProvider,
-    });
-    await collectAndSendUserEditDiffs(upload.uploadedFiles, settings);
+    await collectAndSendUserEditDiffs(uploads, settings);
 }

package/dist/cli/base.js

@@ -94,7 +94,7 @@ export class BaseCLI {
         if (!settings.stageTranslations) {
             const results = await handleStage(initOptions, settings, this.library, false);
             if (results) {
-                await handleTranslate(initOptions, settings, results);
+                await handleTranslate(initOptions, settings, results.fileVersionData, results.jobData, results.branchData);
             }
         }
         else {

package/dist/cli/commands/stage.d.ts

@@ -1,5 +1,11 @@
 import { Settings, SupportedLibraries, TranslateFlags } from '../../types/index.js';
-import { SendFilesResult } from '../../api/sendFiles.js';
+import type { EnqueueFilesResult } from 'generaltranslation/types';
+import { FileTranslationData } from '../../workflow/download.js';
+import { BranchData } from '../../types/branch.js';
 export declare const TEMPLATE_FILE_NAME = "__INTERNAL_GT_TEMPLATE_NAME__";
 export declare const TEMPLATE_FILE_ID: string;
-export declare function handleStage(options: TranslateFlags, settings: Settings, library: SupportedLibraries, stage: boolean): Promise<SendFilesResult | undefined>;
+export declare function handleStage(options: TranslateFlags, settings: Settings, library: SupportedLibraries, stage: boolean): Promise<{
+    fileVersionData: FileTranslationData | undefined;
+    jobData: EnqueueFilesResult | undefined;
+    branchData: BranchData | undefined;
+} | null>;