appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/main.js

@@ -5,22 +5,18 @@ import { hideBin } from "yargs/helpers";
 import { InteractiveCLI } from "./interactiveCLI.js";
 import { UtilsController } from "./utilsController.js";
 import { Databases, Storage } from "node-appwrite";
-import { getClient } from "./utils/getClientFromConfig.js";
+import { getClient } from "appwrite-utils-helpers";
 import { fetchAllDatabases } from "./databases/methods.js";
 import { setupDirsFiles } from "./utils/setupFiles.js";
 import { fetchAllCollections } from "./collections/methods.js";
 import chalk from "chalk";
 import { listSpecifications } from "./functions/methods.js";
-import { MessageFormatter } from "./shared/messageFormatter.js";
+import { MessageFormatter, logger, AuthenticationError } from "appwrite-utils-helpers";
 import { ConfirmationDialogs } from "./shared/confirmationDialogs.js";
 import { SelectionDialogs } from "./shared/selectionDialogs.js";
-import { logger } from "./shared/logging.js";
 import path from "path";
 import fs from "fs";
 import { createRequire } from "node:module";
-import { loadAppwriteProjectConfig, findAppwriteProjectConfig, projectConfigToAppwriteConfig, } from "./utils/projectConfig.js";
-import { hasSessionAuth, getAvailableSessions, getAuthenticationStatus, } from "./utils/sessionAuth.js";
-import { findYamlConfig, loadYamlConfigWithSession, } from "./config/yamlConfig.js";
 const require = createRequire(import.meta.url);
 if (!globalThis.require) {
     globalThis.require = require;
@@ -443,137 +439,85 @@ const argv = yargs(hideBin(process.argv))
     .option("sessionCookie", {
     type: "string",
     description: "Explicit session cookie to use for authentication",
+})
+    .option("importFile", {
+    alias: ["import-file"],
+    type: "string",
+    description: "Import a CSV or JSON file directly into a table (no config needed)",
+})
+    .option("targetDb", {
+    alias: ["target-db"],
+    type: "string",
+    description: "Target database ID for --importFile (prompted if omitted)",
+})
+    .option("targetTable", {
+    alias: ["target-table"],
+    type: "string",
+    description: "Target table ID for --importFile (prompted if omitted)",
 })
     .parse();
 async function main() {
     const startTime = Date.now();
     const operationStats = {};
-    // Early session detection for better user guidance
-    const availableSessions = getAvailableSessions();
-    let hasAnyValidSessions = availableSessions.length > 0;
     if (argv.it) {
-        const cli = new InteractiveCLI(process.cwd());
+        const cli = new InteractiveCLI(process.cwd(), {
+            useSession: argv.useSession,
+            sessionCookie: argv.sessionCookie
+        });
         await cli.run();
     }
     else {
-        // Enhanced config creation with session and project file support
-        let directConfig = undefined;
-        // Show authentication status on startup if no config provided
-        if (!argv.config &&
-            !argv.endpoint &&
-            !argv.projectId &&
-            !argv.apiKey &&
-            !argv.useSession &&
-            !argv.sessionCookie) {
-            if (hasAnyValidSessions) {
-                MessageFormatter.info(`Found ${availableSessions.length} available session(s)`, { prefix: "Auth" });
-                availableSessions.forEach((session) => {
-                    MessageFormatter.info(`  \u2022 ${session.projectId} (${session.email || "unknown"}) at ${session.endpoint}`, { prefix: "Auth" });
-                });
-                MessageFormatter.info("Use --session to enable session authentication", { prefix: "Auth" });
-            }
-            else {
-                MessageFormatter.info("No active Appwrite sessions found", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("\u2022 Run 'appwrite login' to authenticate with session", { prefix: "Auth" });
-                MessageFormatter.info("\u2022 Or provide --apiKey for API key authentication", { prefix: "Auth" });
-            }
-        }
-        // Priority 1: Check for appwrite.json project configuration
-        const projectConfigPath = findAppwriteProjectConfig(process.cwd());
-        if (projectConfigPath) {
-            const projectConfig = loadAppwriteProjectConfig(projectConfigPath);
-            if (projectConfig) {
-                directConfig = projectConfigToAppwriteConfig(projectConfig);
-                MessageFormatter.info(`Loaded project configuration from ${projectConfigPath}`, { prefix: "CLI" });
-            }
-        }
-        // Priority 2: CLI arguments override project config
-        if (argv.endpoint ||
-            argv.projectId ||
-            argv.apiKey ||
-            argv.useSession ||
-            argv.sessionCookie) {
-            directConfig = {
-                ...directConfig,
-                appwriteEndpoint: argv.endpoint || directConfig?.appwriteEndpoint,
-                appwriteProject: argv.projectId || directConfig?.appwriteProject,
-                appwriteKey: argv.apiKey || directConfig?.appwriteKey,
+        // Non-interactive mode - pass auth flags through to controller
+        // ConfigManager will handle config discovery and auth decisions
+        // Users can provide credentials via CLI flags even without a config file
+        const controller = UtilsController.getInstance(process.cwd());
+        // Build init options from CLI flags
+        const initOptions = {
+            useSession: argv.useSession,
+            sessionCookie: argv.sessionCookie,
+            preferJson: argv.appwriteConfig,
+        };
+        // Add CLI overrides if provided - these can work even without a config file
+        if (argv.endpoint || argv.projectId || argv.apiKey) {
+            initOptions.overrides = {
+                appwriteEndpoint: argv.endpoint,
+                appwriteProject: argv.projectId,
+                appwriteKey: argv.apiKey,
             };
         }
-        // Priority 3: Session authentication support with improved detection
-        let sessionAuthAvailable = false;
-        if (directConfig?.appwriteEndpoint && directConfig?.appwriteProject) {
-            sessionAuthAvailable = hasSessionAuth(directConfig.appwriteEndpoint, directConfig.appwriteProject);
+        try {
+            await controller.init(initOptions);
         }
-        if (argv.useSession || argv.sessionCookie) {
-            if (argv.sessionCookie) {
-                // Explicit session cookie provided
-                MessageFormatter.info("Using explicit session cookie for authentication", { prefix: "Auth" });
-            }
-            else if (sessionAuthAvailable) {
-                MessageFormatter.info("Session authentication detected and will be used", { prefix: "Auth" });
-            }
-            else {
-                MessageFormatter.warning("Session authentication requested but no valid session found", { prefix: "Auth" });
-                const availableSessions = getAvailableSessions();
-                if (availableSessions.length > 0) {
-                    MessageFormatter.info(`Available sessions: ${availableSessions
-                        .map((s) => `${s.projectId} (${s.email || "unknown"})`)
-                        .join(", ")}`, { prefix: "Auth" });
-                    MessageFormatter.info("Use --session flag to enable session authentication", { prefix: "Auth" });
-                }
-                else {
-                    MessageFormatter.warning("No Appwrite CLI sessions found. Please run 'appwrite login' first.", { prefix: "Auth" });
-                }
-                MessageFormatter.error("Session authentication requested but not available", undefined, { prefix: "Auth" });
-                return; // Exit early if session auth was requested but not available
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                MessageFormatter.error(error.getFormattedMessage(), undefined, { prefix: "Auth" });
+                process.exit(1);
             }
+            // Re-throw other errors
+            throw error;
         }
-        else if (sessionAuthAvailable && !argv.apiKey) {
-            // Auto-detect session authentication when no API key is provided
-            MessageFormatter.info("Session authentication detected - no API key required", { prefix: "Auth" });
-            MessageFormatter.info("Use --session flag to explicitly enable session authentication", { prefix: "Auth" });
-        }
-        // Enhanced session authentication support:
-        // 1. If session auth is explicitly requested via flags, use it
-        // 2. If no API key is provided but sessions are available, offer to use session auth
-        // 3. Auto-detect session authentication when possible
-        let finalDirectConfig = directConfig;
-        if ((argv.useSession || argv.sessionCookie) &&
-            (!directConfig ||
-                !directConfig.appwriteEndpoint ||
-                !directConfig.appwriteProject)) {
-            // Don't pass incomplete directConfig - let UtilsController load YAML config normally
-            finalDirectConfig = null;
+        // After init, check if we have a valid config (from file OR CLI overrides)
+        if (!controller.config) {
+            MessageFormatter.error("No Appwrite configuration available", undefined, { prefix: "CLI" });
+            MessageFormatter.info("Provide credentials via CLI flags (--endpoint, --projectId, --apiKey or --session)", { prefix: "CLI" });
+            MessageFormatter.info("Or create a config file using --setup", { prefix: "CLI" });
+            return;
         }
-        else if (finalDirectConfig &&
-            !finalDirectConfig.appwriteKey &&
-            !argv.useSession &&
-            !argv.sessionCookie) {
-            // Auto-detect session authentication when no API key provided
-            if (sessionAuthAvailable) {
-                MessageFormatter.info("No API key provided, but session authentication is available", { prefix: "Auth" });
-                MessageFormatter.info("Automatically using session authentication (add --session to suppress this message)", { prefix: "Auth" });
-                // Implicitly enable session authentication
-                argv.useSession = true;
+        const parsedArgv = argv;
+        if (argv.importFile) {
+            const { importFileFromPath, importFilePromptMissing } = await import("./cli/commands/importFileCommands.js");
+            if (!controller.adapter) {
+                MessageFormatter.error("No adapter available — check your credentials", undefined, { prefix: "Import" });
+                return;
             }
-        }
-        // Create controller with session authentication support using singleton
-        const controller = UtilsController.getInstance(process.cwd(), finalDirectConfig);
-        // Pass session authentication and config options to the controller
-        const initOptions = {};
-        if (argv.useSession || argv.sessionCookie) {
-            initOptions.useSession = true;
-            if (argv.sessionCookie) {
-                initOptions.sessionCookie = argv.sessionCookie;
+            if (parsedArgv.targetDb && parsedArgv.targetTable) {
+                await importFileFromPath(controller.adapter, argv.importFile, parsedArgv.targetDb, parsedArgv.targetTable);
             }
+            else {
+                await importFilePromptMissing(controller.adapter, controller.database, argv.importFile, parsedArgv.targetDb, parsedArgv.targetTable);
+            }
+            return;
         }
-        if (argv.appwriteConfig) {
-            initOptions.preferJson = true;
-        }
-        await controller.init(initOptions);
         if (argv.setup) {
             await setupDirsFiles(false, process.cwd());
             return;
@@ -584,7 +528,7 @@ async function main() {
             return;
         }
         if (argv.generateConstants) {
-            const { ConstantsGenerator } = await import("./utils/constantsGenerator.js");
+            const { ConstantsGenerator } = await import("appwrite-utils-helpers");
             if (!controller.config) {
                 MessageFormatter.error("No Appwrite configuration found", undefined, {
                     prefix: "Constants",
@@ -650,7 +594,7 @@ async function main() {
                     MessageFormatter.info("  • tables/ folder must not exist or be empty", { prefix: "Migration" });
                     return;
                 }
-                const { migrateCollectionsToTables } = await import("./config/configMigration.js");
+                const { migrateCollectionsToTables } = await import("appwrite-utils-helpers");
                 MessageFormatter.info("Starting collections to tables migration...", {
                     prefix: "Migration",
                 });
@@ -674,41 +618,9 @@ async function main() {
             }
             return;
         }
-        if (!controller.config) {
-            // Provide better guidance based on available authentication methods
-            const availableSessions = getAvailableSessions();
-            if (availableSessions.length > 0) {
-                MessageFormatter.error("No Appwrite configuration found", undefined, {
-                    prefix: "CLI",
-                });
-                MessageFormatter.info("Available authentication options:", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("• Session authentication: Add --session flag", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("• API key authentication: Add --apiKey YOUR_API_KEY", { prefix: "Auth" });
-                MessageFormatter.info(`• Available sessions: ${availableSessions
-                    .map((s) => `${s.projectId} (${s.email || "unknown"})`)
-                    .join(", ")}`, { prefix: "Auth" });
-            }
-            else {
-                MessageFormatter.error("No Appwrite configuration found", undefined, {
-                    prefix: "CLI",
-                });
-                MessageFormatter.info("Authentication options:", { prefix: "Auth" });
-                MessageFormatter.info("• Login with Appwrite CLI: Run 'appwrite login' then use --session flag", { prefix: "Auth" });
-                MessageFormatter.info("• Use API key: Add --apiKey YOUR_API_KEY", {
-                    prefix: "Auth",
-                });
-                MessageFormatter.info("• Create config file: Run with --setup to initialize project configuration", { prefix: "Auth" });
-            }
-            return;
-        }
-        const parsedArgv = argv;
         // List backups if requested
         if (parsedArgv.listBackups) {
-            const { AdapterFactory } = await import("./adapters/AdapterFactory.js");
+            const { AdapterFactory } = await import("appwrite-utils-helpers");
             const { listBackups } = await import("./shared/backupTracking.js");
             if (!controller.config) {
                 MessageFormatter.error("No Appwrite configuration found", undefined, {
@@ -797,7 +709,7 @@ async function main() {
         // Comprehensive backup (all databases + all buckets)
         if (parsedArgv.comprehensiveBackup) {
             const { comprehensiveBackup } = await import("./backups/operations/comprehensiveBackup.js");
-            const { AdapterFactory } = await import("./adapters/AdapterFactory.js");
+            const { AdapterFactory } = await import("appwrite-utils-helpers");
             // Get tracking database ID (interactive prompt if not specified)
             let trackingDatabaseId = parsedArgv.trackingDatabaseId;
             if (!trackingDatabaseId) {
@@ -971,7 +883,10 @@ async function main() {
             }
             // Build DatabaseSelection[] with tableIds per DB
             const databaseSelections = [];
-            const allConfigItems = controller.config.collections || controller.config.tables || [];
+            const allConfigItems = [
+                ...(controller.config.collections || []),
+                ...(controller.config.tables || [])
+            ];
             let lastSelectedTableIds = null;
             for (const dbId of selectedDbIds) {
                 const db = availableDatabases.find(d => d.$id === dbId);
@@ -987,8 +902,16 @@ async function main() {
                         return one === dbId;
                     return true; // eligible everywhere if unspecified
                 });
-                // Fetch available tables from remote for selection context
+                // Fetch available tables from remote for status/context
                 const availableTables = await fetchAllCollections(dbId, controller.database);
+                const remoteTableIds = new Set(availableTables.map(table => table.$id));
+                const localItems = eligibleConfigItems;
+                const localItemIds = localItems.map(item => item.$id || item.id || item.tableId || item.name);
+                const localNewItems = localItems.filter(item => {
+                    const itemId = item.$id || item.id || item.tableId || item.name;
+                    return !remoteTableIds.has(itemId);
+                });
+                const localNewIds = localNewItems.map(item => item.$id || item.id || item.tableId || item.name);
                 // Determine selected table IDs
                 let selectedTableIds = [];
                 if (parsedArgv.collectionIds) {
@@ -996,35 +919,57 @@ async function main() {
                     selectedTableIds = parsedArgv.collectionIds.split(/[\,\s]+/).filter(Boolean);
                 }
                 else {
-                    // If we have a previous selection, offer to reuse it
+                    const inquirer = (await import("inquirer")).default;
+                    const choices = [];
                     if (lastSelectedTableIds && lastSelectedTableIds.length > 0) {
-                        const inquirer = (await import("inquirer")).default;
-                        const { reuseMode } = await inquirer.prompt([
-                            {
-                                type: "list",
-                                name: "reuseMode",
-                                message: `How do you want to select tables for ${db.name}?`,
-                                choices: [
-                                    { name: `Use same selection as previous (${lastSelectedTableIds.length} items)`, value: "same" },
-                                    { name: `Filter by this database (manual select)`, value: "filter" },
-                                    { name: `Show all available in this database (manual select)`, value: "all" }
-                                ],
-                                default: "same"
-                            }
-                        ]);
-                        if (reuseMode === "same") {
-                            selectedTableIds = [...lastSelectedTableIds];
+                        choices.push({
+                            name: `Use same selection as previous (${lastSelectedTableIds.length} items)`,
+                            value: "same"
+                        });
+                    }
+                    if (localItemIds.length > 0) {
+                        choices.push({
+                            name: `Select all local items for ${db.name} (${localItemIds.length} items)`,
+                            value: "all_local"
+                        });
+                    }
+                    if (localNewIds.length > 0) {
+                        choices.push({
+                            name: `Select only new local items (not on remote) (${localNewIds.length} items)`,
+                            value: "new_only"
+                        });
+                    }
+                    choices.push({
+                        name: "Manual selection",
+                        value: "manual"
+                    });
+                    const { selectionMode } = await inquirer.prompt([
+                        {
+                            type: "list",
+                            name: "selectionMode",
+                            message: `How do you want to select tables for ${db.name}?`,
+                            choices,
+                            default: choices[0]?.value || "manual"
                         }
-                        else if (reuseMode === "all") {
-                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, allConfigItems, { showSelectAll: false, allowNewOnly: false, defaultSelected: lastSelectedTableIds });
+                    ]);
+                    if (selectionMode === "same") {
+                        selectedTableIds = [...(lastSelectedTableIds || [])];
+                    }
+                    else if (selectionMode === "all_local") {
+                        selectedTableIds = [...localItemIds];
+                    }
+                    else if (selectionMode === "new_only") {
+                        selectedTableIds = [...localNewIds];
+                    }
+                    else {
+                        if (localItems.length === 0) {
+                            MessageFormatter.warning(`No local tables/collections available for ${db.name}`, { prefix: "Push" });
+                            selectedTableIds = [];
                         }
                         else {
-                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: lastSelectedTableIds });
+                            selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, localItems, availableTables, { showSelectAll: localItems.length > 1, allowNewOnly: false, defaultSelected: lastSelectedTableIds || [] });
                         }
                     }
-                    else {
-                        selectedTableIds = await SelectionDialogs.selectTablesForDatabase(dbId, db.name, availableTables, eligibleConfigItems, { showSelectAll: false, allowNewOnly: true, defaultSelected: [] });
-                    }
                 }
                 databaseSelections.push({
                     databaseId: db.$id,

package/dist/migrations/afterImportActions.js

@@ -3,10 +3,9 @@ import { InputFile } from "node-appwrite/file";
 import path from "path";
 import fs from "fs";
 import os from "os";
-import { logger } from "../shared/logging.js";
+import { logger, MessageFormatter } from "appwrite-utils-helpers";
 import { tryAwaitWithRetry, } from "appwrite-utils";
-import { getClientFromConfig } from "../utils/getClientFromConfig.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { getClientFromConfig } from "appwrite-utils-helpers";
 export const getDatabaseFromConfig = (config) => {
     getClientFromConfig(config); // Sets config.appwriteClient if missing
     return new Databases(config.appwriteClient);

package/dist/migrations/appwriteToX.d.ts

@@ -1,6 +1,6 @@
 import { Storage, type Models } from "node-appwrite";
 import { type AppwriteConfig } from "appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
+import type { DatabaseAdapter } from "appwrite-utils-helpers";
 import type { DatabaseSelection, BucketSelection } from "../shared/selectionDialogs.js";
 export declare class AppwriteToX {
     config: AppwriteConfig;

package/dist/migrations/appwriteToX.js

@@ -1,15 +1,14 @@
-import { SchemaGenerator } from "../shared/schemaGenerator.js";
-import { findYamlConfig } from "../config/yamlConfig.js";
+import { SchemaGenerator, findYamlConfig } from "appwrite-utils-helpers";
 import { Client, Compression, Databases, Query, Storage, } from "node-appwrite";
 import { fetchAllCollections } from "../collections/methods.js";
 import { fetchAllDatabases } from "../databases/methods.js";
 import { CollectionSchema, attributeSchema, AppwriteConfigSchema, permissionsSchema, attributesSchema, indexesSchema, parseAttribute, } from "appwrite-utils";
 import { getDatabaseFromConfig } from "./afterImportActions.js";
-import { getAdapterFromConfig } from "../utils/getClientFromConfig.js";
+import { getAdapterFromConfig } from "appwrite-utils-helpers";
 import { listBuckets } from "../storage/methods.js";
 import { listFunctions, listFunctionDeployments, getFunction } from "../functions/methods.js";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { isLegacyDatabases } from "../utils/typeGuards.js";
+import { MessageFormatter } from "appwrite-utils-helpers";
+import { isLegacyDatabases } from "appwrite-utils-helpers";
 /**
  * Convert between collection and table terminology based on data structure
  */
@@ -80,8 +79,11 @@ export class AppwriteToX {
             const client = new Client();
             client
                 .setEndpoint(this.config.appwriteEndpoint)
-                .setProject(this.config.appwriteProject)
-                .setKey(this.config.appwriteKey);
+                .setProject(this.config.appwriteProject);
+            // Only set API key if provided (session auth is alternative)
+            if (this.config.appwriteKey) {
+                client.setKey(this.config.appwriteKey);
+            }
             this.config.appwriteClient = client;
         }
     }
@@ -441,7 +443,7 @@ export class AppwriteToX {
             timeout: func.timeout || 15,
             enabled: func.enabled !== false,
             logging: func.logging !== false,
-            entrypoint: func.entrypoint || "src/index.ts",
+            entrypoint: func.entrypoint || "src/main.ts",
             commands: func.commands || "npm install",
             scopes: Array.isArray(func.scopes) ? func.scopes : [],
             dirPath: `functions/${func.name}`,

package/dist/migrations/comprehensiveTransfer.js

@@ -1,10 +1,9 @@
 import { converterFunctions, tryAwaitWithRetry, parseAttribute, objectNeedsUpdate, } from "appwrite-utils";
 import { Client, Databases, Storage, Users, Functions, Teams, Query, AppwriteException, } from "node-appwrite";
 import { InputFile } from "node-appwrite/file";
-import { MessageFormatter } from "../shared/messageFormatter.js";
+import { MessageFormatter, getClient } from "appwrite-utils-helpers";
 import { processQueue, queuedOperations } from "../shared/operationQueue.js";
 import { ProgressManager } from "../shared/progressManager.js";
-import { getClient } from "../utils/getClientFromConfig.js";
 import { transferDatabaseLocalToLocal, transferDatabaseLocalToRemote, transferStorageLocalToLocal, transferStorageLocalToRemote, transferUsersLocalToRemote, } from "./transfer.js";
 import { deployLocalFunction } from "../functions/deployments.js";
 import { listFunctions, downloadLatestFunctionDeployment, } from "../functions/methods.js";
@@ -12,8 +11,7 @@ import pLimit from "p-limit";
 import chalk from "chalk";
 import { join } from "node:path";
 import fs from "node:fs";
-import { getAdapter } from "../utils/getClientFromConfig.js";
-import { mapToCreateAttributeParams } from "../shared/attributeMapper.js";
+import { getAdapter, mapToCreateAttributeParams } from "appwrite-utils-helpers";
 export class ComprehensiveTransfer {
     options;
     sourceClient;
@@ -714,7 +712,7 @@ export class ComprehensiveTransfer {
                         specification: func.specification,
                         dirPath: functionPath,
                     };
-                    await deployLocalFunction(this.targetClient, func.name, functionConfig);
+                    await deployLocalFunction(this.targetClient, func.name, functionConfig, undefined, this.tempDir);
                     this.results.functions.transferred++;
                     MessageFormatter.success(`Function ${func.name} transferred successfully`, { prefix: "Transfer" });
                 }

package/dist/migrations/dataLoader.d.ts

@@ -606,6 +606,8 @@ export declare class DataLoader {
     private userIdSet;
     userExistsMap: Map<string, boolean>;
     private shouldWriteFile;
+    private _adapter;
+    private getAdapter;
     constructor(appwriteFolderPath: string, importDataActions: ImportDataActions, database: Databases, config: AppwriteConfig, shouldWriteFile?: boolean);
     getCollectionKey(name: string): string;
     /**
@@ -633,9 +635,9 @@ export declare class DataLoader {
      * @returns The transformed item.
      */
     transformData(item: any, attributeMappings: AttributeMappings): any;
-    setupMaps(dbId: string): Promise<void>;
+    setupMaps(dbId: string, specificCollections?: string[]): Promise<void>;
     getAllUsers(): Promise<import("node-appwrite").Models.User<import("node-appwrite").Models.Preferences>[]>;
-    start(dbId: string): Promise<void>;
+    start(dbId: string, specificCollections?: string[]): Promise<void>;
     /**
      * Deals with merged users by iterating through all collections in the configuration.
      * We have merged users if there are duplicate emails or phones in the import data.