@crowdin/app-project-module 0.75.0 → 0.76.0

package/out/app-test/integration/update-crowdin.js

@@ -108,6 +108,8 @@ const updateCrowdinTest = ({ appConfig, integrationTestConfig, }) => __awaiter(v
                 type: types_1.JobClientType.MANUAL,
                 fetchTranslation: jest.fn(),
                 translationUploaded: jest.fn(),
+                markFilesAsUnsynced: jest.fn(),
+                unmarkFilesAsUnsynced: jest.fn(),
             },
         });
     }, 'Fail to run method updateCrowdin()');

package/out/app-test/integration/update-integration.js

@@ -65,6 +65,8 @@ const updateIntegrationTest = ({ appConfig, integrationTestConfig, }) => __await
                 type: types_1.JobClientType.MANUAL,
                 fetchTranslation: jest.fn(),
                 translationUploaded: jest.fn(),
+                markFilesAsUnsynced: jest.fn(),
+                unmarkFilesAsUnsynced: jest.fn(),
             },
         });
     }, 'Fail to run method updateIntegration()');

package/out/modules/integration/handlers/crowdin-files.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const util_1 = require("../../../util");
 const defaults_1 = require("../util/defaults");
 const logger_1 = require("../../../util/logger");
+const files_1 = require("../util/files");
 function handle(config, integration) {
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
         req.logInfo('Loading crowdin files');
@@ -19,9 +20,18 @@ function handle(config, integration) {
             const rootFolder = yield (0, defaults_1.getRootFolder)(config, integration, req.crowdinApiClient, req.crowdinContext.jwtPayload.context.project_id);
             req.logInfo(`Loading files ${rootFolder ? `from folder ${rootFolder.id}` : 'from root'}`);
             try {
-                const files = integration.getCrowdinFiles
+                let files = integration.getCrowdinFiles
                     ? yield integration.getCrowdinFiles(req.crowdinContext.jwtPayload.context.project_id, req.crowdinApiClient, rootFolder, req.integrationSettings)
                     : [];
+                req.logInfo('Marking files as unsynced');
+                if (files.length > 0) {
+                    files = yield (0, files_1.markUnsyncedFiles)({
+                        integrationId: req.crowdinContext.clientId,
+                        crowdinId: req.crowdinContext.crowdinId,
+                        client: req.crowdinApiClient,
+                        files,
+                    });
+                }
                 req.logInfo(`Returning ${files.length} files`);
                 res.send(files);
             }

package/out/modules/integration/handlers/user-errors.js

@@ -15,10 +15,7 @@ const logger_1 = require("../../../util/logger");
 function handle() {
     return (0, util_1.runAsyncWrapper)((req, res) => __awaiter(this, void 0, void 0, function* () {
         var _a;
-        let userTimezone = (yield req.crowdinApiClient.usersApi.getAuthenticatedUser()).data.timezone;
-        if (!userTimezone) {
-            userTimezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-        }
+        const userTimezone = (yield req.crowdinApiClient.usersApi.getAuthenticatedUser()).data.timezone;
         req.logInfo(`Loading user errors for crowdinId ${req.crowdinContext.crowdinId} and integrationId ${req.crowdinContext.clientId}`);
         const userErrors = (_a = (yield (0, storage_1.getStorage)().getAllUserErrors(req.crowdinContext.crowdinId, req.crowdinContext.clientId))) === null || _a === void 0 ? void 0 : _a.map((userError) => {
             if (!(0, util_1.isJson)(userError.data)) {
@@ -28,16 +25,7 @@ function handle() {
                 });
             }
             const date = new Date(+userError.createdAt);
-            // Format the date as 'MMM DD, YYYY HH:mm'
-            const formattedDate = new Intl.DateTimeFormat('en-US', {
-                year: 'numeric',
-                month: 'short',
-                day: 'numeric',
-                hour: '2-digit',
-                minute: '2-digit',
-                hour12: false,
-                timeZone: userTimezone,
-            }).format(date);
+            const formattedDate = (0, util_1.getFormattedDate)({ date, userTimezone });
             return Object.assign(Object.assign({}, userError), { formattedDate });
         });
         req.logInfo(`Returning ${userErrors === null || userErrors === void 0 ? void 0 : userErrors.length} user errors`);

package/out/modules/integration/types.d.ts

@@ -289,7 +289,8 @@ export interface File {
     parentId?: string;
     nodeType?: IntegrationTreeElementType;
     customContent?: string;
-    labels?: LabelTreeElement;
+    labels?: LabelTreeElement[];
+    failed?: boolean;
 }
 export interface Folder {
     id: string;
@@ -297,7 +298,7 @@ export interface Folder {
     parentId?: string;
     nodeType?: IntegrationTreeElementType;
     customContent?: string;
-    labels?: LabelTreeElement;
+    labels?: LabelTreeElement[];
 }
 export type TreeItem = File | Folder;
 /**
@@ -390,6 +391,7 @@ type LabelTreeElementType = 'primary' | 'secondary' | 'success' | 'warning' | 'i
 export interface LabelTreeElement {
     text: string;
     type?: LabelTreeElementType;
+    tooltip?: string;
     color?: string;
 }
 export declare enum Provider {

package/out/modules/integration/util/files.d.ts

@@ -1,5 +1,12 @@
 import { ExtendedResult, IntegrationFile, IntegrationLogic, IntegrationRequest, SkipIntegrationNodes, TreeItem } from '../types';
 import { JobClient } from './types';
+import Crowdin from '@crowdin/crowdin-api-client';
 export declare function skipFilesByRegex(files: TreeItem[] | undefined, skipIntegrationNodes?: SkipIntegrationNodes): TreeItem[];
 export declare function expandFilesTree(nodes: IntegrationFile[], req: IntegrationRequest, integration: IntegrationLogic, job?: JobClient): Promise<IntegrationFile[]>;
 export declare function isExtendedResultType<T>(data?: T | ExtendedResult<T>): data is ExtendedResult<T>;
+export declare function markUnsyncedFiles({ integrationId, crowdinId, client, files, }: {
+    integrationId: string;
+    crowdinId: string;
+    client: Crowdin;
+    files?: TreeItem[];
+}): Promise<TreeItem[]>;

package/out/modules/integration/util/files.js

@@ -9,8 +9,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isExtendedResultType = exports.expandFilesTree = exports.skipFilesByRegex = void 0;
+exports.markUnsyncedFiles = exports.isExtendedResultType = exports.expandFilesTree = exports.skipFilesByRegex = void 0;
 const types_1 = require("./types");
+const storage_1 = require("../../../storage");
+const util_1 = require("../../../util");
 function skipFilesByRegex(files, skipIntegrationNodes) {
     if (!Array.isArray(files)) {
         return [];
@@ -55,3 +57,44 @@ function isExtendedResultType(data) {
     return !!dataTyped && !Array.isArray(dataTyped);
 }
 exports.isExtendedResultType = isExtendedResultType;
+function isFileLeaf(file) {
+    return file.nodeType === '1' || !!file.type;
+}
+function markUnsyncedFiles({ integrationId, crowdinId, client, files, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!Array.isArray(files)) {
+            return [];
+        }
+        const unsyncedFilesData = yield (0, storage_1.getStorage)().getUnsyncedFiles({ integrationId, crowdinId });
+        let unsyncedFiles = (unsyncedFilesData === null || unsyncedFilesData === void 0 ? void 0 : unsyncedFilesData.files)
+            ? JSON.parse(unsyncedFilesData === null || unsyncedFilesData === void 0 ? void 0 : unsyncedFilesData.files)
+            : [];
+        const fileIds = files.filter((file) => isFileLeaf(file)).map((file) => `${file.id}`);
+        const idsToRemove = unsyncedFiles.filter((file) => !fileIds.includes(file.id)).map((file) => file.id);
+        unsyncedFiles = unsyncedFiles.filter((file) => !idsToRemove.includes(file.id));
+        const userTimezone = (yield client.usersApi.getAuthenticatedUser()).data.timezone;
+        yield (0, storage_1.getStorage)().updateUnsyncedFiles({
+            integrationId,
+            crowdinId,
+            files: JSON.stringify(unsyncedFiles),
+        });
+        files = files.map((file) => {
+            const unsynced = unsyncedFiles.find((unsyncedFile) => unsyncedFile.id === file.id);
+            if (unsynced && isFileLeaf(file)) {
+                const formattedDate = (0, util_1.getFormattedDate)({ date: new Date(+unsynced.updatedAt), userTimezone });
+                file.labels = [
+                    {
+                        text: `Sync failed ${formattedDate}`,
+                        type: 'warning',
+                        tooltip: unsynced === null || unsynced === void 0 ? void 0 : unsynced.message,
+                    },
+                    ...(file.labels ? file.labels : []),
+                ];
+                file.failed = true;
+            }
+            return file;
+        });
+        return files;
+    });
+}
+exports.markUnsyncedFiles = markUnsyncedFiles;

package/out/modules/integration/util/job.js

@@ -149,7 +149,6 @@ function runAsJob({ integrationId, crowdinId, type, title, payload, res, project
                 }
                 return translation;
             }),
-            // translationUploaded: async ({ fileId, languageId, etag }) => {
             translationUploaded: ({ fileId, translationParams }) => __awaiter(this, void 0, void 0, function* () {
                 if (!isDbStore) {
                     translationParams.forEach(({ languageId, etag }) => (store[integrationId][crowdinId][fileId][languageId] = { etag }));
@@ -176,6 +175,39 @@ function runAsJob({ integrationId, crowdinId, type, title, payload, res, project
                 }
                 yield Promise.all([...updates, ...inserts]);
             }),
+            markFilesAsUnsynced: ({ files }) => __awaiter(this, void 0, void 0, function* () {
+                const unsyncedFilesData = yield storage.getUnsyncedFiles({ integrationId, crowdinId });
+                const updatedFileRecords = files.map((file) => ({
+                    id: file.fileId,
+                    message: file.error,
+                    updatedAt: `${Date.now()}`,
+                }));
+                if (unsyncedFilesData) {
+                    const existingUnsyncedFiles = (unsyncedFilesData === null || unsyncedFilesData === void 0 ? void 0 : unsyncedFilesData.files) ? JSON.parse(unsyncedFilesData.files) : [];
+                    const uniqueFilesMap = new Map([...existingUnsyncedFiles, ...updatedFileRecords].map((file) => [file.id, file]));
+                    const uniqueFiles = Array.from(uniqueFilesMap.values());
+                    yield storage.updateUnsyncedFiles({ integrationId, crowdinId, files: JSON.stringify(uniqueFiles) });
+                }
+                else {
+                    yield storage.saveUnsyncedFiles({
+                        integrationId,
+                        crowdinId,
+                        files: JSON.stringify(updatedFileRecords),
+                    });
+                }
+            }),
+            unmarkFilesAsUnsynced: ({ files }) => __awaiter(this, void 0, void 0, function* () {
+                const unsyncedFilesData = yield storage.getUnsyncedFiles({ integrationId, crowdinId });
+                if (unsyncedFilesData) {
+                    const existingUnsyncedFiles = (unsyncedFilesData === null || unsyncedFilesData === void 0 ? void 0 : unsyncedFilesData.files) ? JSON.parse(unsyncedFilesData.files) : [];
+                    const updatedFiles = existingUnsyncedFiles.filter((file) => !files.some((unmarkFile) => unmarkFile.fileId === file.id));
+                    yield storage.updateUnsyncedFiles({
+                        integrationId,
+                        crowdinId,
+                        files: JSON.stringify(updatedFiles),
+                    });
+                }
+            }),
         };
         try {
             const data = yield jobCallback(job);

package/out/modules/integration/util/types.d.ts

@@ -3,6 +3,8 @@ import { Config } from '../../../types';
 import { IntegrationLogic, IntegrationSyncSettings } from '../types';
 import { ResponseObject } from '@crowdin/crowdin-api-client/out/core';
 import { TranslationsModel } from '@crowdin/crowdin-api-client/out/translations';
+import { AxiosError } from 'axios';
+import { AppModuleError, AppUserModuleError } from '../../../util/logger';
 export declare enum JobType {
     UPDATE_TO_CROWDIN = "updateCrowdin",
     UPDATE_TO_INTEGRATION = "updateIntegration",
@@ -56,6 +58,8 @@ export type JobClient = {
     type: JobClientType;
     translationUploaded: SaveUploadedFileTranslation;
     fetchTranslation: FetchTranslation;
+    markFilesAsUnsynced: MarkUnsyncedFiles;
+    unmarkFilesAsUnsynced: UnmarkUnsyncedFiles;
 };
 export type UpdateJobProgress = ({ progress, status, info, data, attempt, }: Omit<UpdateJobParams, 'id'>) => Promise<{
     isCanceled: boolean;
@@ -92,3 +96,20 @@ export interface TranslationCache {
 export type GetFileTranslationCache = Pick<TranslationCache, 'integrationId' | 'crowdinId' | 'fileId'>;
 export type GetFileTranslationCacheByLanguageParams = Pick<TranslationCache, 'integrationId' | 'crowdinId' | 'fileId' | 'languageId'>;
 export type UpdateTranslationCacheParams = Pick<TranslationCache, 'integrationId' | 'crowdinId' | 'fileId' | 'languageId' | 'etag'>;
+export type MarkUnsyncedFiles = ({ files, }: {
+    files: {
+        fileId: number;
+        error: AxiosError | AppModuleError | AppUserModuleError | Error | string;
+    }[];
+}) => Promise<void>;
+export type UnmarkUnsyncedFiles = ({ files }: {
+    files: {
+        fileId: number;
+    }[];
+}) => Promise<void>;
+export interface UnsyncedFiles {
+    integrationId: string;
+    crowdinId: string;
+    files: string;
+}
+export type GetUnsyncedFiles = Pick<UnsyncedFiles, 'integrationId' | 'crowdinId'>;

package/out/storage/index.d.ts

@@ -1,8 +1,22 @@
 import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks, Provider } from '../modules/integration/types';
 import { Config, CrowdinCredentials, UnauthorizedConfig } from '../types';
-import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache } from '../modules/integration/util/types';
+import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache, UnsyncedFiles, GetUnsyncedFiles } from '../modules/integration/util/types';
 import { UserErrors } from './types';
+declare const TABLES: {
+    crowdin_credentials: string;
+    integration_credentials: string;
+    sync_settings: string;
+    app_metadata: string;
+    files_snapshot: string;
+    webhooks: string;
+    user_errors: string;
+    integration_settings: string;
+    job: string;
+    translation_file_cache: string;
+    unsynced_files: string;
+};
 export interface Storage {
+    tables: typeof TABLES;
     migrate(): Promise<void>;
     saveCrowdinCredentials(credentials: CrowdinCredentials): Promise<void>;
     updateCrowdinCredentials(credentials: CrowdinCredentials): Promise<void>;
@@ -51,6 +65,10 @@ export interface Storage {
     getFileTranslationCache(params: GetFileTranslationCache): Promise<TranslationCache[] | undefined>;
     getFileTranslationCacheByLanguage(params: GetFileTranslationCacheByLanguageParams): Promise<TranslationCache | undefined>;
     updateTranslationCache(params: UpdateTranslationCacheParams): Promise<void>;
+    saveUnsyncedFiles(params: UnsyncedFiles): Promise<void>;
+    getUnsyncedFiles(params: GetUnsyncedFiles): Promise<UnsyncedFiles | undefined>;
+    updateUnsyncedFiles(params: UnsyncedFiles): Promise<void>;
 }
 export declare function initialize(config: Config | UnauthorizedConfig): Promise<void>;
 export declare function getStorage(): Storage;
+export {};

package/out/storage/index.js

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable @typescript-eslint/camelcase */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -45,6 +46,19 @@ const path_1 = __importStar(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
 const util = __importStar(require("node:util"));
+const TABLES = {
+    crowdin_credentials: 'crowdin_credentials',
+    integration_credentials: 'integration_credentials',
+    sync_settings: 'sync_settings',
+    app_metadata: 'app_metadata',
+    files_snapshot: 'files_snapshot',
+    webhooks: 'webhooks',
+    user_errors: 'user_errors',
+    integration_settings: 'integration_settings',
+    job: 'job',
+    translation_file_cache: 'translation_file_cache',
+    unsynced_files: 'unsynced_files',
+};
 let storage;
 function initialize(config) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -83,46 +97,36 @@ exports.getStorage = getStorage;
 function createDumpForMigration(config) {
     const sqliteFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE);
     const backupFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE_BACKUP);
-    const dumpFilePath = (0, path_1.join)(config.dbFolder, 'dump_sqlite.sql');
     if (!fs_1.default.existsSync(sqliteFilePath)) {
         (0, logger_1.log)('SQLite database not found, skipping migration dump creation');
         return;
     }
     (0, logger_1.log)('Creating dump for migration from SQLite to PostgreSQL');
-    (0, child_process_1.execSync)(`sqlite3 ${sqliteFilePath} .dump > ${dumpFilePath}`);
+    for (const tableName in TABLES) {
+        (0, logger_1.log)(`Creating dump for table ${tableName}`);
+        const dumpFileName = util.format(types_1.storageFiles.DUMP, tableName);
+        const dumpFilePath = path_1.default.join(config.dbFolder, dumpFileName);
+        (0, child_process_1.execSync)(`sqlite3 ${sqliteFilePath} ".output ${dumpFilePath}" ".dump ${tableName}" ".output stdout"`);
+        let modifiedContent = fs_1.default.readFileSync(dumpFilePath).toString();
+        // 1. Remove SQLite-specific PRAGMA statements
+        modifiedContent = modifiedContent.replace(/PRAGMA foreign_keys=OFF;\n/g, '');
+        // 2. Adjust transaction syntax for PostgreSQL
+        modifiedContent = modifiedContent.replace(/BEGIN TRANSACTION;\n/g, '');
+        modifiedContent = modifiedContent.replace(/COMMIT TRANSACTION;\n/g, '');
+        // 3. Ensure tables are only created if they don't already exist
+        modifiedContent = modifiedContent
+            .replace(/CREATE TABLE IF NOT EXISTS/g, 'CREATE TABLE') // Remove duplicate IF NOT EXISTS
+            .replace(/CREATE TABLE/g, 'CREATE TABLE IF NOT EXISTS'); // Add IF NOT EXISTS if missing
+        // 4. Add `ON CONFLICT DO NOTHING` to INSERT statements to handle conflicts gracefully
+        modifiedContent = modifiedContent.replace(/(INSERT INTO [^;]+)(;)/g, '$1 ON CONFLICT DO NOTHING;');
+        // 5. Convert SQLite-specific data types to PostgreSQL equivalents
+        modifiedContent = modifiedContent.replace(/integer not null primary key autoincrement/gi, 'serial primary key');
+        modifiedContent = modifiedContent.replace(/varchar not null primary key/gi, 'varchar primary key');
+        // 6. Remove SQLite-specific function replace()
+        modifiedContent = modifiedContent.replace(/replace\s*\('([^']+?)',\s*'?\\[rn]'?\s*,\s*char\s*\([0-9]+\)\s*\)/gi, "'$1'");
+        fs_1.default.writeFileSync(dumpFilePath, modifiedContent, { encoding: 'utf8', flag: 'w' });
+    }
     fs_1.default.renameSync(sqliteFilePath, backupFilePath);
-    let modifiedContent = fs_1.default.readFileSync(dumpFilePath).toString();
-    // 1. Remove SQLite-specific PRAGMA statements
-    modifiedContent = modifiedContent.replace(/PRAGMA foreign_keys=OFF;\n/g, '');
-    // 2. Adjust transaction syntax for PostgreSQL
-    modifiedContent = modifiedContent.replace(/BEGIN TRANSACTION;\n/g, '');
-    modifiedContent = modifiedContent.replace(/COMMIT TRANSACTION;\n/g, '');
-    // 3. Ensure tables are only created if they don't already exist
-    modifiedContent = modifiedContent
-        .replace(/CREATE TABLE IF NOT EXISTS/g, 'CREATE TABLE') // Remove duplicate IF NOT EXISTS
-        .replace(/CREATE TABLE/g, 'CREATE TABLE IF NOT EXISTS'); // Add IF NOT EXISTS if missing
-    // 4. Add `ON CONFLICT DO NOTHING` to INSERT statements to handle conflicts gracefully
-    modifiedContent = modifiedContent.replace(/(INSERT INTO [^;]+)(;)/g, '$1 ON CONFLICT DO NOTHING;');
-    // 5. Convert SQLite-specific data types to PostgreSQL equivalents
-    modifiedContent = modifiedContent.replace(/integer not null primary key autoincrement/gi, 'serial primary key');
-    modifiedContent = modifiedContent.replace(/varchar not null primary key/gi, 'varchar primary key');
-    // 6. Remove SQLite-specific function replace()
-    modifiedContent = modifiedContent.replace(/replace\s*\('([^']+?)',\s*'?\\[rn]'?\s*,\s*char\s*\([0-9]+\)\s*\)/gi, "'$1'");
-    // 7. Remove SQLite-specific sequences
-    modifiedContent = modifiedContent.replace(/DELETE FROM sqlite_sequence;\n/g, '');
-    modifiedContent = modifiedContent.replace(/INSERT INTO sqlite_sequence .*;\n/g, '');
-    // 8. Split the dump into separate statements
-    const tables = modifiedContent.split(/(?=CREATE TABLE)/g);
-    tables.forEach((tableSql, index) => {
-        const match = tableSql.match(/CREATE TABLE IF NOT EXISTS (\w+)/);
-        if (match) {
-            const dumpFileName = util.format(types_1.storageFiles.DUMP_CHUNK, index);
-            (0, logger_1.log)(`Creating dump chunk ${dumpFileName} file for table ${match[1]}`);
-            const outputFilePath = path_1.default.join(config.dbFolder, dumpFileName);
-            fs_1.default.writeFileSync(outputFilePath, tableSql);
-        }
-    });
-    fs_1.default.unlinkSync(dumpFilePath);
 }
 function getSqLiteFileFromBackup(config) {
     const sqliteFilePath = (0, path_1.join)(config.dbFolder, types_1.storageFiles.SQLITE);

package/out/storage/mysql.d.ts

@@ -1,6 +1,6 @@
 import { Storage } from '.';
 import { CrowdinCredentials } from '../types';
-import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache } from '../modules/integration/util/types';
+import { CreateJobParams, GetActiveJobsParams, GetJobParams, GetFileTranslationCacheByLanguageParams, Job, TranslationCache, UpdateJobParams, UpdateTranslationCacheParams, GetFileTranslationCache, UnsyncedFiles, GetUnsyncedFiles } from '../modules/integration/util/types';
 import { IntegrationConfig, IntegrationCredentials, IntegrationFilesSnapshot, IntegrationSyncSettings, IntegrationWebhooks } from '../modules/integration/types';
 import { UserErrors } from './types';
 export interface MySQLStorageConfig {
@@ -17,6 +17,19 @@ export declare class MySQLStorage implements Storage {
     private _rej?;
     private dbPromise;
     private config;
+    tables: {
+        crowdin_credentials: string;
+        integration_credentials: string;
+        sync_settings: string;
+        app_metadata: string;
+        files_snapshot: string;
+        webhooks: string;
+        user_errors: string;
+        integration_settings: string;
+        job: string;
+        translation_file_cache: string;
+        unsynced_files: string;
+    };
     constructor(config: MySQLStorageConfig);
     executeQuery<T>(command: (connection: any) => Promise<T>): Promise<T>;
     migrate(): Promise<void>;
@@ -68,4 +81,7 @@ export declare class MySQLStorage implements Storage {
     getFileTranslationCache({ integrationId, crowdinId, fileId, }: GetFileTranslationCache): Promise<TranslationCache[] | undefined>;
     getFileTranslationCacheByLanguage({ integrationId, crowdinId, fileId, languageId, }: GetFileTranslationCacheByLanguageParams): Promise<TranslationCache | undefined>;
     updateTranslationCache({ integrationId, crowdinId, fileId, languageId, etag, }: UpdateTranslationCacheParams): Promise<void>;
+    saveUnsyncedFiles({ integrationId, crowdinId, files }: UnsyncedFiles): Promise<void>;
+    updateUnsyncedFiles({ integrationId, crowdinId, files }: UnsyncedFiles): Promise<void>;
+    getUnsyncedFiles({ integrationId, crowdinId }: GetUnsyncedFiles): Promise<UnsyncedFiles | undefined>;
 }