gtx-cli 2.4.15 → 2.5.0-alpha.1

package/dist/workflow/BranchStep.js

@@ -0,0 +1,131 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner, logError, logErrorAndExit, } from '../console/logging.js';
+import chalk from 'chalk';
+import { getCurrentBranch, getIncomingBranches, getCheckedOutBranches, } from '../git/branches.js';
+import { ApiError } from 'generaltranslation/errors';
+// Step 1: Resolve the current branch id & update API with branch information
+export class BranchStep extends WorkflowStep {
+    spinner = createSpinner('dots');
+    branchData;
+    settings;
+    gt;
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+        this.branchData = {
+            currentBranch: {
+                id: '',
+                name: '',
+            },
+            incomingBranch: null,
+            checkedOutBranch: null,
+        };
+    }
+    async run() {
+        this.spinner.start(`Resolving branch information...`);
+        // First get some info about the branches we're working with
+        let current = null;
+        let incoming = [];
+        let checkedOut = [];
+        let useDefaultBranch = true;
+        if (this.settings.branchOptions.enabled &&
+            this.settings.branchOptions.autoDetectBranches) {
+            const [currentResult, incomingResult, checkedOutResult] = await Promise.all([
+                getCurrentBranch(this.settings.branchOptions.remoteName),
+                getIncomingBranches(this.settings.branchOptions.remoteName),
+                getCheckedOutBranches(this.settings.branchOptions.remoteName),
+            ]);
+            current = currentResult;
+            incoming = incomingResult;
+            checkedOut = checkedOutResult;
+            useDefaultBranch = false;
+        }
+        if (this.settings.branchOptions.enabled &&
+            this.settings.branchOptions.currentBranch) {
+            current = {
+                currentBranchName: this.settings.branchOptions.currentBranch,
+                defaultBranch: current?.defaultBranch ?? false, // we have no way of knowing if this is the default branch without using the auto-detection logic
+            };
+            useDefaultBranch = false;
+        }
+        const branchData = await this.gt.queryBranchData({
+            branchNames: [
+                ...(current ? [current.currentBranchName] : []),
+                ...incoming,
+                ...checkedOut,
+            ],
+        });
+        if (useDefaultBranch) {
+            if (!branchData.defaultBranch) {
+                const createBranchResult = await this.gt.createBranch({
+                    branchName: 'main', // name doesn't matter for default branch
+                    defaultBranch: true,
+                });
+                this.branchData.currentBranch = createBranchResult.branch;
+            }
+            else {
+                this.branchData.currentBranch = branchData.defaultBranch;
+            }
+        }
+        else {
+            if (!current) {
+                logErrorAndExit('Failed to determine the current branch. Please specify a custom branch or enable automatic branch detection.');
+            }
+            const currentBranch = branchData.branches.find((b) => b.name === current.currentBranchName);
+            if (!currentBranch) {
+                try {
+                    const createBranchResult = await this.gt.createBranch({
+                        branchName: current.currentBranchName,
+                        defaultBranch: current.defaultBranch,
+                    });
+                    this.branchData.currentBranch = createBranchResult.branch;
+                }
+                catch (error) {
+                    if (error instanceof ApiError && error.code === 403) {
+                        logError('Failed to create branch. To enable branching, please upgrade your plan.');
+                        // retry with default branch
+                        const createBranchResult = await this.gt.createBranch({
+                            branchName: 'main', // name doesn't matter for default branch
+                            defaultBranch: true,
+                        });
+                        this.branchData.currentBranch = createBranchResult.branch;
+                    }
+                }
+            }
+            else {
+                this.branchData.currentBranch = currentBranch;
+            }
+        }
+        // Now set the incoming and checked out branches (first one that exists)
+        this.branchData.incomingBranch =
+            incoming
+                .map((b) => {
+                const branch = branchData.branches.find((bb) => bb.name === b);
+                if (branch) {
+                    return branch;
+                }
+                else {
+                    return null;
+                }
+            })
+                .filter((b) => b !== null)[0] ?? null;
+        this.branchData.checkedOutBranch =
+            checkedOut
+                .map((b) => {
+                const branch = branchData.branches.find((bb) => bb.name === b);
+                if (branch) {
+                    return branch;
+                }
+                else {
+                    return null;
+                }
+            })
+                .filter((b) => b !== null)[0] ?? null;
+        this.spinner.stop(chalk.green('Branch information resolved successfully'));
+        return this.branchData;
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/DownloadStep.d.ts

@@ -0,0 +1,19 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import { FileStatusTracker } from './PollJobsStep.js';
+export type DownloadTranslationsInput = {
+    fileTracker: FileStatusTracker;
+    resolveOutputPath: (sourcePath: string, locale: string) => string | null;
+    forceDownload?: boolean;
+};
+export declare class DownloadTranslationsStep extends WorkflowStep<DownloadTranslationsInput, boolean> {
+    private gt;
+    private settings;
+    private spinner;
+    constructor(gt: GT, settings: Settings);
+    run({ fileTracker, resolveOutputPath, forceDownload, }: DownloadTranslationsInput): Promise<boolean>;
+    private downloadFiles;
+    private downloadFilesWithRetry;
+    wait(): Promise<void>;
+}

package/dist/workflow/DownloadStep.js

@@ -0,0 +1,127 @@
+import chalk from 'chalk';
+import { WorkflowStep } from './Workflow.js';
+import { createProgressBar, logError, logWarning } from '../console/logging.js';
+import { downloadFileBatch, } from '../api/downloadFileBatch.js';
+export class DownloadTranslationsStep extends WorkflowStep {
+    gt;
+    settings;
+    spinner = null;
+    constructor(gt, settings) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+    }
+    async run({ fileTracker, resolveOutputPath, forceDownload, }) {
+        this.spinner = createProgressBar(fileTracker.completed.size);
+        this.spinner.start('Downloading files...');
+        // Download ready files
+        const success = await this.downloadFiles(fileTracker, resolveOutputPath, forceDownload);
+        if (success) {
+            this.spinner.stop(chalk.green('Downloaded files successfully'));
+        }
+        else {
+            this.spinner.stop(chalk.red('Failed to download files'));
+        }
+        return success;
+    }
+    async downloadFiles(fileTracker, resolveOutputPath, forceDownload) {
+        try {
+            // Only download files that are marked as completed
+            const currentQueryData = Array.from(fileTracker.completed.values());
+            // If no files to download, we're done
+            if (currentQueryData.length === 0) {
+                return true;
+            }
+            // Check for translations
+            const responseData = await this.gt.queryFileData({
+                translatedFiles: currentQueryData.map((item) => ({
+                    fileId: item.fileId,
+                    versionId: item.versionId,
+                    branchId: item.branchId,
+                    locale: item.locale,
+                })),
+            });
+            const translatedFiles = responseData.translatedFiles || [];
+            // Filter for ready translations
+            const readyTranslations = translatedFiles.filter((file) => file.completedAt !== null);
+            // Prepare batch download data
+            const batchFiles = readyTranslations
+                .map((translation) => {
+                const fileKey = `${translation.branchId}:${translation.fileId}:${translation.versionId}:${translation.locale}`;
+                const fileProperties = fileTracker.completed.get(fileKey);
+                if (!fileProperties) {
+                    return null;
+                }
+                const outputPath = resolveOutputPath(fileProperties.fileName, translation.locale);
+                // Skip downloading GTJSON files that are not in the files configuration
+                if (outputPath === null) {
+                    fileTracker.completed.delete(fileKey);
+                    fileTracker.skipped.set(fileKey, fileProperties);
+                    return null;
+                }
+                return {
+                    branchId: translation.branchId,
+                    fileId: translation.fileId,
+                    versionId: translation.versionId,
+                    locale: translation.locale,
+                    inputPath: fileProperties.fileName,
+                    outputPath,
+                };
+            })
+                .filter((file) => file !== null);
+            if (batchFiles.length > 0) {
+                const batchResult = await this.downloadFilesWithRetry(fileTracker, batchFiles, forceDownload);
+                this.spinner?.stop(chalk.green(`Downloaded ${batchResult.successful.length} files${batchResult.skipped.length > 0 ? `, skipped ${batchResult.skipped.length} files` : ''}`));
+                if (batchResult.failed.length > 0) {
+                    logWarning(`Failed to download ${batchResult.failed.length} files: ${batchResult.failed.map((f) => f.inputPath).join('\n')}`);
+                }
+            }
+            else {
+                this.spinner?.stop(chalk.green('No files to download'));
+            }
+            return true;
+        }
+        catch (error) {
+            this.spinner?.stop(chalk.red('An error occurred while downloading translations'));
+            logError(chalk.red('Error: ') + error);
+            return false;
+        }
+    }
+    async downloadFilesWithRetry(fileTracker, files, forceDownload, maxRetries = 3, initialDelay = 1000) {
+        let remainingFiles = files;
+        let allSuccessful = [];
+        let retryCount = 0;
+        let allSkipped = [];
+        while (remainingFiles.length > 0 && retryCount <= maxRetries) {
+            const batchResult = await downloadFileBatch(fileTracker, remainingFiles, this.settings, forceDownload);
+            allSuccessful = [...allSuccessful, ...batchResult.successful];
+            allSkipped = [...allSkipped, ...batchResult.skipped];
+            this.spinner?.advance(batchResult.successful.length +
+                batchResult.skipped.length +
+                batchResult.failed.length);
+            // If no failures or we've exhausted retries, we're done
+            if (batchResult.failed.length === 0 || retryCount === maxRetries) {
+                return {
+                    successful: allSuccessful,
+                    failed: batchResult.failed,
+                    skipped: allSkipped,
+                };
+            }
+            // Calculate exponential backoff delay
+            const delay = initialDelay * Math.pow(2, retryCount);
+            logError(chalk.yellow(`Retrying ${batchResult.failed.length} failed file(s) in ${delay}ms (attempt ${retryCount + 1}/${maxRetries})...`));
+            // Wait before retrying
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            remainingFiles = batchResult.failed;
+            retryCount++;
+        }
+        return {
+            successful: allSuccessful,
+            failed: remainingFiles,
+            skipped: allSkipped,
+        };
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/EnqueueStep.d.ts

@@ -0,0 +1,15 @@
+import type { EnqueueFilesResult } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+import type { FileReference } from 'generaltranslation/types';
+export declare class EnqueueStep extends WorkflowStep<FileReference[], EnqueueFilesResult> {
+    private gt;
+    private settings;
+    private force?;
+    private spinner;
+    private result;
+    constructor(gt: GT, settings: Settings, force?: boolean | undefined);
+    run(files: FileReference[]): Promise<EnqueueFilesResult>;
+    wait(): Promise<void>;
+}

package/dist/workflow/EnqueueStep.js

@@ -0,0 +1,33 @@
+import { WorkflowStep } from './Workflow.js';
+import { createSpinner } from '../console/logging.js';
+import chalk from 'chalk';
+export class EnqueueStep extends WorkflowStep {
+    gt;
+    settings;
+    force;
+    spinner = createSpinner('dots');
+    result = null;
+    constructor(gt, settings, force) {
+        super();
+        this.gt = gt;
+        this.settings = settings;
+        this.force = force;
+    }
+    async run(files) {
+        this.spinner.start('Enqueuing translations...');
+        this.result = await this.gt.enqueueFiles(files, {
+            sourceLocale: this.settings.defaultLocale,
+            targetLocales: this.settings.locales,
+            publish: this.settings.publish,
+            requireApproval: this.settings.stageTranslations,
+            modelProvider: this.settings.modelProvider,
+            force: this.force,
+        });
+        return this.result;
+    }
+    async wait() {
+        if (this.result) {
+            this.spinner.stop(chalk.green('Translations enqueued successfully'));
+        }
+    }
+}

package/dist/workflow/PollJobsStep.d.ts

@@ -0,0 +1,31 @@
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { EnqueueFilesResult } from 'generaltranslation/types';
+import type { FileProperties } from '../types/files.js';
+export type PollJobsInput = {
+    fileTracker: FileStatusTracker;
+    fileQueryData: FileProperties[];
+    jobData: EnqueueFilesResult;
+    timeoutDuration: number;
+    forceRetranslation?: boolean;
+};
+export type FileStatusTracker = {
+    completed: Map<string, FileProperties>;
+    inProgress: Map<string, FileProperties>;
+    failed: Map<string, FileProperties>;
+    skipped: Map<string, FileProperties>;
+};
+export type PollJobsOutput = {
+    success: boolean;
+    fileTracker: FileStatusTracker;
+};
+export declare class PollTranslationJobsStep extends WorkflowStep<PollJobsInput, PollJobsOutput> {
+    private gt;
+    private spinner;
+    private previousProgress;
+    constructor(gt: GT);
+    run({ fileTracker, fileQueryData, jobData, timeoutDuration, forceRetranslation, }: PollJobsInput): Promise<PollJobsOutput>;
+    private updateSpinner;
+    private generateStatusSuffixText;
+    wait(): Promise<void>;
+}

package/dist/workflow/PollJobsStep.js

@@ -0,0 +1,284 @@
+import chalk from 'chalk';
+import { WorkflowStep } from './Workflow.js';
+import { createProgressBar, logError } from '../console/logging.js';
+import { TEMPLATE_FILE_NAME } from '../cli/commands/stage.js';
+export class PollTranslationJobsStep extends WorkflowStep {
+    gt;
+    spinner = null;
+    previousProgress = 0;
+    constructor(gt) {
+        super();
+        this.gt = gt;
+    }
+    async run({ fileTracker, fileQueryData, jobData, timeoutDuration, forceRetranslation, }) {
+        const startTime = Date.now();
+        this.spinner = createProgressBar(fileQueryData.length);
+        const spinnerMessage = forceRetranslation
+            ? 'Waiting for retranslation...'
+            : 'Waiting for translation...';
+        this.spinner.start(spinnerMessage);
+        // Build a map of branchId:fileId:versionId:locale -> FileProperties
+        const filePropertiesMap = new Map();
+        fileQueryData.forEach((item) => {
+            filePropertiesMap.set(`${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`, item);
+        });
+        // Initial query to check which files already have translations
+        const initialFileData = await this.gt.queryFileData({
+            translatedFiles: fileQueryData.map((item) => ({
+                fileId: item.fileId,
+                versionId: item.versionId,
+                branchId: item.branchId,
+                locale: item.locale,
+            })),
+        });
+        const existingTranslations = initialFileData.translatedFiles || [];
+        // Mark all existing translations as completed
+        existingTranslations.forEach((translation) => {
+            if (!translation.completedAt) {
+                return;
+            }
+            const fileKey = `${translation.branchId}:${translation.fileId}:${translation.versionId}:${translation.locale}`;
+            const fileProperties = filePropertiesMap.get(fileKey);
+            if (fileProperties) {
+                fileTracker.completed.set(fileKey, fileProperties);
+            }
+        });
+        // Build a map of jobs for quick lookup:
+        // branchId:fileId:versionId:locale -> job
+        const jobMap = new Map();
+        Object.entries(jobData.jobData).forEach(([jobId, job]) => {
+            const key = `${job.branchId}:${job.fileId}:${job.versionId}:${job.targetLocale}`;
+            jobMap.set(key, { ...job, jobId });
+        });
+        // Build a map of jobs for quick lookup:
+        // jobId -> file data for the job
+        const jobFileMap = new Map();
+        Object.entries(jobData.jobData).forEach(([jobId, job]) => {
+            jobFileMap.set(jobId, {
+                branchId: job.branchId,
+                fileId: job.fileId,
+                versionId: job.versionId,
+                locale: job.targetLocale,
+            });
+        });
+        // Categorize each file query item
+        for (const item of fileQueryData) {
+            const fileKey = `${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`;
+            // Check if translation already exists (completedAt is truthy)
+            const existingTranslation = fileTracker.completed.get(fileKey);
+            if (existingTranslation) {
+                continue;
+            }
+            // Check if there's a job for this file
+            const jobKey = `${item.branchId}:${item.fileId}:${item.versionId}:${item.locale}`;
+            const job = jobMap.get(jobKey);
+            if (job) {
+                // Job exists - mark as in progress initially
+                fileTracker.inProgress.set(fileKey, item);
+            }
+            else {
+                // No job and no existing translation - mark as skipped
+                fileTracker.skipped.set(fileKey, item);
+            }
+        }
+        // Update spinner with initial status
+        this.updateSpinner(fileTracker, fileQueryData);
+        // If force retranslation, don't skip the initial check
+        if (!forceRetranslation) {
+            // Check if all jobs are already complete
+            if (fileTracker.inProgress.size === 0) {
+                this.spinner.stop(chalk.green('All translations ready'));
+                return { success: true, fileTracker };
+            }
+        }
+        // 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;
+            setTimeout(() => {
+                intervalCheck = setInterval(async () => {
+                    try {
+                        // Query job status
+                        const jobIds = Array.from(jobFileMap.keys());
+                        const jobStatusResponse = await this.gt.checkJobStatus(jobIds);
+                        // Update status based on job completion
+                        for (const job of jobStatusResponse) {
+                            const jobFileProperties = jobFileMap.get(job.jobId);
+                            if (jobFileProperties) {
+                                const fileKey = `${jobFileProperties.branchId}:${jobFileProperties.fileId}:${jobFileProperties.versionId}:${jobFileProperties.locale}`;
+                                const fileProperties = filePropertiesMap.get(fileKey);
+                                if (!fileProperties) {
+                                    continue;
+                                }
+                                if (job.status === 'completed') {
+                                    fileTracker.completed.set(fileKey, fileProperties);
+                                    fileTracker.inProgress.delete(fileKey);
+                                }
+                                else if (job.status === 'failed') {
+                                    fileTracker.failed.set(fileKey, fileProperties);
+                                    fileTracker.inProgress.delete(fileKey);
+                                }
+                                else if (job.status === 'unknown') {
+                                    fileTracker.skipped.set(fileKey, fileProperties);
+                                    fileTracker.inProgress.delete(fileKey);
+                                }
+                                jobFileMap.delete(job.jobId);
+                            }
+                        }
+                        // Update spinner
+                        this.updateSpinner(fileTracker, fileQueryData);
+                        const elapsed = Date.now() - startTime;
+                        const allJobsProcessed = fileTracker.inProgress.size === 0;
+                        if (allJobsProcessed || elapsed >= timeoutDuration * 1000) {
+                            clearInterval(intervalCheck);
+                            if (fileTracker.inProgress.size === 0) {
+                                this.spinner.stop(chalk.green('Translation jobs finished'));
+                                resolve({ success: true, fileTracker });
+                            }
+                            else {
+                                this.spinner.stop(chalk.red('Timed out waiting for translation jobs'));
+                                resolve({ success: false, fileTracker });
+                            }
+                        }
+                    }
+                    catch (error) {
+                        logError(chalk.red('Error checking job status: ') + error);
+                    }
+                }, 5000);
+            }, msUntilNextInterval);
+        });
+    }
+    updateSpinner(fileTracker, fileQueryData) {
+        if (!this.spinner)
+            return;
+        const statusText = this.generateStatusSuffixText(fileTracker, fileQueryData);
+        const currentProgress = fileTracker.completed.size +
+            fileTracker.failed.size +
+            fileTracker.skipped.size;
+        const progressDelta = currentProgress - this.previousProgress;
+        this.spinner.advance(progressDelta, statusText);
+        this.previousProgress = currentProgress;
+    }
+    generateStatusSuffixText(fileTracker, fileQueryData) {
+        // Simple progress indicator
+        const progressText = `${chalk.green(`[${fileTracker.completed.size +
+            fileTracker.failed.size +
+            fileTracker.skipped.size}/${fileQueryData.length}]`)} translations completed`;
+        // Get terminal height to adapt our output
+        const terminalHeight = process.stdout.rows || 24;
+        // If terminal is very small, just show the basic progress
+        if (terminalHeight < 6) {
+            return progressText;
+        }
+        const newSuffixText = [progressText];
+        // Organize data by filename : locale
+        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(),
+                    skipped: new Set(),
+                });
+            }
+            else {
+                fileStatus.get(item.fileName)?.pending.add(item.locale);
+            }
+        }
+        // Mark which ones are completed, failed, or skipped
+        for (const [_, fileProperties] of fileTracker.completed) {
+            const { fileName, locale } = fileProperties;
+            const status = fileStatus.get(fileName);
+            if (status) {
+                status.pending.delete(locale);
+                status.completed.add(locale);
+            }
+        }
+        for (const [_, fileProperties] of fileTracker.failed) {
+            const { fileName, locale } = fileProperties;
+            const status = fileStatus.get(fileName);
+            if (status) {
+                status.pending.delete(locale);
+                status.failed.add(locale);
+            }
+        }
+        for (const [_, fileProperties] of fileTracker.skipped) {
+            const { fileName, locale } = fileProperties;
+            const status = fileStatus.get(fileName);
+            if (status) {
+                status.pending.delete(locale);
+                status.skipped.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 (green)
+            if (status.completed.size > 0) {
+                localeStatuses.push(...Array.from(status.completed).map((locale) => ({
+                    locale,
+                    status: 'completed',
+                })));
+            }
+            // Add skipped locales (green)
+            if (status.skipped.size > 0) {
+                localeStatuses.push(...Array.from(status.skipped).map((locale) => ({
+                    locale,
+                    status: 'skipped',
+                })));
+            }
+            // Add failed locales (red)
+            if (status.failed.size > 0) {
+                localeStatuses.push(...Array.from(status.failed).map((locale) => ({
+                    locale,
+                    status: 'failed',
+                })));
+            }
+            // Add pending locales (yellow)
+            if (status.pending.size > 0) {
+                localeStatuses.push(...Array.from(status.pending).map((locale) => ({
+                    locale,
+                    status: 'pending',
+                })));
+            }
+            // Sort localeStatuses by locale
+            localeStatuses.sort((a, b) => a.locale.localeCompare(b.locale));
+            // Add colors
+            const localeString = localeStatuses
+                .map((locale) => {
+                if (locale.status === 'completed') {
+                    return chalk.green(locale.locale);
+                }
+                else if (locale.status === 'skipped') {
+                    return chalk.gray(locale.locale);
+                }
+                else if (locale.status === 'failed') {
+                    return chalk.red(locale.locale);
+                }
+                else if (locale.status === 'pending') {
+                    return chalk.yellow(locale.locale);
+                }
+            })
+                .join(', ');
+            // Format the line
+            const prettyFileName = fileName === TEMPLATE_FILE_NAME ? '<React Elements>' : fileName;
+            newSuffixText.push(`${chalk.bold(prettyFileName)} [${localeString}]`);
+        }
+        // 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');
+    }
+    async wait() {
+        return;
+    }
+}

package/dist/workflow/SetupStep.d.ts

@@ -0,0 +1,16 @@
+import { FileReference } from 'generaltranslation/types';
+import { WorkflowStep } from './Workflow.js';
+import { GT } from 'generaltranslation';
+import { Settings } from '../types/index.js';
+export declare class SetupStep extends WorkflowStep<FileReference[], FileReference[]> {
+    private gt;
+    private settings;
+    private timeoutMs;
+    private spinner;
+    private setupJobId;
+    private files;
+    private completed;
+    constructor(gt: GT, settings: Settings, timeoutMs: number);
+    run(files: FileReference[]): Promise<FileReference[]>;
+    wait(): Promise<void>;
+}