gtx-cli 2.0.5 → 2.0.6-alpha.6

package/dist/api/checkFileTranslations.d.ts

@@ -1,3 +1,9 @@
+export type CheckFileTranslationData = {
+    [key: string]: {
+        versionId: string;
+        fileName: string;
+    };
+};
 /**
  * Checks the status of translations for a given version ID
  * @param apiKey - The API key for the General Translation API

package/dist/api/checkFileTranslations.js

@@ -3,7 +3,7 @@ import { createOraSpinner, logError } from '../console/logging.js';
 import { getLocaleProperties } from 'generaltranslation';
 import { downloadFile } from './downloadFile.js';
 import { downloadFileBatch } from './downloadFileBatch.js';
-import { getAuthHeaders } from '../utils/headers.js';
+import { gt } from '../utils/gt.js';
 /**
  * Checks the status of translations for a given version ID
  * @param apiKey - The API key for the General Translation API
@@ -166,74 +166,65 @@ async function checkTranslationDeployment(baseUrl, projectId, apiKey, fileQueryD
         if (currentQueryData.length === 0) {
             return true;
         }
-        const response = await fetch(`${baseUrl}/v1/project/translations/files/retrieve`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...getAuthHeaders(projectId, 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 downloadFileBatch(baseUrl, projectId, 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 downloadFile(baseUrl, projectId, apiKey, file.translationId, file.outputPath);
-                    if (result) {
-                        downloadStatus.downloaded.add(file.fileLocale);
+        // Check for translations
+        const responseData = await gt.checkFileTranslations(currentQueryData);
+        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 downloadFileBatch(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 {
-                        downloadStatus.failed.add(file.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 downloadFile(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;
         }
+        // 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 all files have been downloaded, we're done
         if (downloadStatus.downloaded.size + downloadStatus.failed.size ===
             fileQueryData.length) {
             return true;
         }
-        return false;
     }
     catch (error) {
         logError(chalk.red('Error checking translation status: ') + error);
-        return false;
     }
+    return false;
 }

package/dist/api/downloadFile.d.ts

@@ -1 +1,8 @@
-export declare function downloadFile(baseUrl: string, projectId: string, apiKey: string, translationId: string, outputPath: string, maxRetries?: number, retryDelay?: number): Promise<boolean>;
+/**
+ * Downloads a file from the API and saves it to a local directory
+ * @param translationId - The ID of the translation to download
+ * @param outputPath - The path to save the file to
+ * @param maxRetries - The maximum number of retries to attempt
+ * @param retryDelay - The delay between retries in milliseconds
+ */
+export declare function downloadFile(translationId: string, outputPath: string, maxRetries?: number, retryDelay?: number): Promise<boolean>;

package/dist/api/downloadFile.js

@@ -1,45 +1,37 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { logError } from '../console/logging.js';
-import { getAuthHeaders } from '../utils/headers.js';
-// Helper function to download a file
-export async function downloadFile(baseUrl, projectId, apiKey, translationId, outputPath, maxRetries = 3, retryDelay = 1000) {
+import { gt } from '../utils/gt.js';
+/**
+ * Downloads a file from the API and saves it to a local directory
+ * @param translationId - The ID of the translation to download
+ * @param outputPath - The path to save the file to
+ * @param maxRetries - The maximum number of retries to attempt
+ * @param retryDelay - The delay between retries in milliseconds
+ */
+export async function downloadFile(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: {
-                    ...getAuthHeaders(projectId, 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;
+            // Get the file data as an ArrayBuffer
+            const fileData = await gt.downloadFile(translationId);
+            // Ensure the directory exists
+            const dir = path.dirname(outputPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
             }
-            // If we get here, the response was not OK
-            if (retries >= maxRetries) {
-                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));
+            // Write the file to disk
+            await fs.promises.writeFile(outputPath, Buffer.from(fileData));
+            return true;
         }
         catch (error) {
+            // If we've retried too many times, log an error and return false
             if (retries >= maxRetries) {
                 logError(`Error downloading file ${outputPath} after ${maxRetries + 1} attempts: ` +
                     error);
                 return false;
             }
+            // Increment retry counter and wait before next attempt
             retries++;
             await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }

package/dist/api/downloadFileBatch.d.ts

@@ -1,16 +1,16 @@
+export type BatchedFiles = Array<{
+    translationId: string;
+    outputPath: string;
+}>;
+export type DownloadFileBatchResult = {
+    successful: string[];
+    failed: string[];
+};
 /**
  * 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, projectId: string, apiKey: string, files: Array<{
-    translationId: string;
-    outputPath: string;
-}>, maxRetries?: number, retryDelay?: number): Promise<{
-    successful: string[];
-    failed: string[];
-}>;
+export declare function downloadFileBatch(files: BatchedFiles, maxRetries?: number, retryDelay?: number): Promise<DownloadFileBatchResult>;

package/dist/api/downloadFileBatch.js

@@ -1,17 +1,15 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { logError, logWarning } from '../console/logging.js';
-import { getAuthHeaders } from '../utils/headers.js';
+import { gt } from '../utils/gt.js';
 /**
  * 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 async function downloadFileBatch(baseUrl, projectId, apiKey, files, maxRetries = 3, retryDelay = 1000) {
+export async function downloadFileBatch(files, maxRetries = 3, retryDelay = 1000) {
     let retries = 0;
     const fileIds = files.map((file) => file.translationId);
     const result = { successful: [], failed: [] };
@@ -19,62 +17,56 @@ export async function downloadFileBatch(baseUrl, projectId, apiKey, files, maxRe
     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',
-                    ...getAuthHeaders(projectId, 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) {
-                            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);
+            // 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);
+                    if (!outputPath) {
+                        logWarning(`No output path found for file: ${translationId}`);
+                        result.failed.push(translationId);
+                        continue;
                     }
-                    catch (error) {
-                        logError(`Error saving file ${file.id}: ` + error);
-                        result.failed.push(file.id);
+                    // 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);
                 }
-                // 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);
-                    }
+                catch (error) {
+                    logError(`Error saving file ${file.id}: ` + error);
+                    result.failed.push(file.id);
                 }
-                return result;
             }
-            // If we get here, the response was not OK
-            if (retries >= maxRetries) {
-                logError(`Failed to download files in batch. Status: ${response.status} after ${maxRetries + 1} attempts.`);
-                // Mark all files as failed
-                result.failed = [...fileIds];
-                return result;
+            // 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);
+                }
             }
-            // Increment retry counter and wait before next attempt
-            retries++;
-            await new Promise((resolve) => setTimeout(resolve, retryDelay));
+            return result;
+            // // If we get here, the response was not OK
+            // if (retries >= maxRetries) {
+            //   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 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);
@@ -82,6 +74,7 @@ export async function downloadFileBatch(baseUrl, projectId, apiKey, files, maxRe
                 result.failed = [...fileIds];
                 return result;
             }
+            // Increment retry counter and wait before next attempt
             retries++;
             await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }

package/dist/api/fetchTranslations.d.ts

@@ -1,10 +1,7 @@
-import { RetrievedTranslations } from '../types/api.js';
+import { RetrievedTranslations } from 'generaltranslation/types';
 /**
  * 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, projectId: string, apiKey: string, versionId: string): Promise<RetrievedTranslations>;
+export declare function fetchTranslations(versionId: string): Promise<RetrievedTranslations>;

package/dist/api/fetchTranslations.js

@@ -1,30 +1,18 @@
 import chalk from 'chalk';
 import { logError } from '../console/logging.js';
-import { getAuthHeaders } from '../utils/headers.js';
+import { gt } from '../utils/gt.js';
 /**
  * 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 async function fetchTranslations(baseUrl, projectId, 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',
-            ...getAuthHeaders(projectId, apiKey),
-        },
-    });
-    if (response.ok) {
-        const data = await response.json();
-        const translations = data.translations;
-        return translations;
+export async function fetchTranslations(versionId) {
+    try {
+        const result = await gt.fetchTranslations(versionId);
+        return result.translations;
     }
-    else {
+    catch {
         logError(chalk.red('Failed to fetch translations'));
+        return [];
     }
-    return [];
 }

package/dist/api/sendFiles.d.ts

@@ -1,22 +1,17 @@
 import { Settings } from '../types/index.js';
-import { FileFormat, DataFormat } from '../types/data.js';
-/**
- * File object structure
- * @param content - The content of the file
- * @param fileName - The name of the file
- * @param fileExtension - The format of the file (JSON, MDX, MD, etc.)
- * @param dataFormat - The format of the data within the file
- */
-export interface FileToTranslate {
-    content: string;
-    fileName: string;
-    fileFormat: FileFormat;
-    dataFormat: DataFormat;
-}
-type ApiOptions = Settings & {
+import { CompletedFileTranslationData, FileToTranslate } from 'generaltranslation/types';
+export type ApiOptions = Settings & {
     publish: boolean;
     wait: boolean;
 };
+export type SendFilesResult = {
+    data: Record<string, {
+        fileName: string;
+        versionId: string;
+    }>;
+    locales: string[];
+    translations: CompletedFileTranslationData[];
+};
 /**
  * Sends multiple files for translation to the API
  * @param files - Array of file objects to translate
@@ -24,8 +19,10 @@ type ApiOptions = Settings & {
  * @returns The translated content or version ID
  */
 export declare function sendFiles(files: FileToTranslate[], options: ApiOptions): Promise<{
-    data: any;
-    locales: any;
-    translations: any;
+    data: Record<string, {
+        fileName: string;
+        versionId: string;
+    }>;
+    locales: string[];
+    translations: CompletedFileTranslationData[];
 }>;
-export {};

package/dist/api/sendFiles.js

@@ -1,6 +1,6 @@
 import chalk from 'chalk';
 import { createSpinner, logMessage, logSuccess } from '../console/logging.js';
-import { getAuthHeaders } from '../utils/headers.js';
+import { gt } from '../utils/gt.js';
 /**
  * Sends multiple files for translation to the API
  * @param files - Array of file objects to translate
@@ -12,38 +12,16 @@ export async function sendFiles(files, options) {
         '\n' +
         files.map((file) => `  - ${chalk.bold(file.fileName)}`).join('\n'));
     const spinner = createSpinner('dots');
-    spinner.start(`Sending ${files.length} file${files.length > 1 ? 's' : ''} to General Translation API...`);
+    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);
-            formData.append(`fileName${index}`, file.fileName);
+        // Send the files to the API
+        const responseData = await gt.enqueueFiles(files, {
+            publish: options.publish,
+            description: options.description,
+            sourceLocale: options.defaultLocale,
+            targetLocales: options.locales,
+            _versionId: options._versionId,
         });
-        // 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: {
-                ...getAuthHeaders(options.projectId, options.apiKey),
-            },
-            body: formData,
-        });
-        if (!response.ok) {
-            spinner.stop(chalk.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.green('Files for translation uploaded successfully'));

package/dist/api/sendUpdates.d.ts

@@ -1,19 +1,19 @@
 import { Settings, SupportedLibraries, Updates } from '../types/index.js';
 import { DataFormat } from '../types/data.js';
-type ApiOptions = Settings & {
+export type ApiOptions = Settings & {
     timeout: string;
     dataFormat: DataFormat;
     description?: string;
     requireApproval?: boolean;
 };
+export type SendUpdatesResult = {
+    versionId: string;
+    locales: string[];
+};
 /**
  * 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 {};
+export declare function sendUpdates(updates: Updates, options: ApiOptions, library: SupportedLibraries): Promise<SendUpdatesResult>;

package/dist/api/sendUpdates.js

@@ -1,8 +1,8 @@
 import chalk from 'chalk';
-import { createSpinner, logSuccess, logWarning } from '../console/logging.js';
+import { createSpinner, logSuccess, logWarning, } from '../console/logging.js';
 import updateConfig from '../fs/config/updateConfig.js';
 import { isUsingLocalTranslations } from '../config/utils.js';
-import { getAuthHeaders } from '../utils/headers.js';
+import { gt } from '../utils/gt.js';
 /**
  * Sends updates to the API
  * @param updates - The updates to send
@@ -10,41 +10,18 @@ import { getAuthHeaders } from '../utils/headers.js';
  * @returns The versionId of the updated project
  */
 export async function sendUpdates(updates, options, library) {
-    const { apiKey, projectId, defaultLocale, dataFormat } = options;
-    const globalMetadata = {
-        ...(projectId && { projectId }),
-        ...(defaultLocale && { sourceLocale: defaultLocale }),
-    };
-    // If additionalLocales is provided, additionalLocales + project.current_locales will be translated
-    // If not, then options.locales will be translated
-    // If neither, then project.current_locales will be translated
-    const body = {
-        updates,
-        ...(options.locales && { locales: options.locales }),
-        metadata: globalMetadata,
-        ...(dataFormat && { dataFormat }),
-        ...(options.version && { versionId: options.version }),
-        ...(options.description && { description: options.description }),
-        ...(options.requireApproval && {
-            requireApproval: options.requireApproval,
-        }),
-    };
     const spinner = createSpinner('dots');
     spinner.start(`Sending ${library} updates to General Translation API...`);
     try {
-        const response = await fetch(`${options.baseUrl}/v1/project/translations/update`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...getAuthHeaders(options.projectId, options.apiKey),
-            },
-            body: JSON.stringify(body),
+        const responseData = await gt.enqueueEntries(updates, {
+            sourceLocale: options.defaultLocale,
+            targetLocales: options.locales,
+            dataFormat: options.dataFormat,
+            version: options.version,
+            description: options.description,
+            requireApproval: options.requireApproval,
         });
-        if (!response.ok) {
-            spinner.stop(chalk.red(await response.text()));
-            process.exit(1);
-        }
-        const { versionId, message, locales, projectSettings } = await response.json();
+        const { versionId, message, locales, projectSettings } = responseData;
         spinner.stop(chalk.green('Sent updates'));
         logSuccess(message);
         if (isUsingLocalTranslations(options) && projectSettings.cdnEnabled) {

package/dist/api/waitForUpdates.d.ts

@@ -1,11 +1,9 @@
 /**
  * Waits for translations to be deployed to the General Translation API
- * @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
  * @returns True if all translations are deployed, false otherwise
  */
-export declare const waitForUpdates: (projectId: string, apiKey: string, baseUrl: string, versionId: string, startTime: number, timeoutDuration: number) => Promise<boolean>;
+export declare const waitForUpdates: (versionId: string, startTime: number, timeoutDuration: number) => Promise<boolean>;