appwrite-utils-cli 1.8.9 → 1.9.2

package/dist/config/services/ConfigDiscoveryService.js

@@ -1,20 +1,20 @@
 import fs from "fs";
 import path from "path";
+import { findUp } from "find-up";
 import { MessageFormatter } from "../../shared/messageFormatter.js";
 import { shouldIgnoreDirectory } from "../../utils/directoryUtils.js";
 /**
  * Service for discovering Appwrite configuration files and collection/table definitions.
  *
+ * Uses find-up for intelligent searching with git repository boundary detection:
+ * 1. Finds .git directory to establish repo root boundary
+ * 2. Searches UP from current directory to repo root
+ * 3. Searches DOWN recursively within repo root
+ *
  * Search Priority:
  * 1. YAML configs (.appwrite/config.yaml, .appwrite/config.yml, etc.)
- * 2. TypeScript configs (appwriteConfig.ts)
- * 3. JSON configs (appwrite.json, appwrite.config.json)
- *
- * Features:
- * - Searches up directory tree (max 5 levels)
- * - Ignores common directories (node_modules, .git, etc.)
- * - Discovers both collections/ and tables/ directories
- * - Recursive subdirectory scanning for .appwrite folders
+ * 2. JSON configs (appwrite.config.json, appwrite.json)
+ * 3. TypeScript configs (appwriteConfig.ts)
  */
 export class ConfigDiscoveryService {
     /**
@@ -28,184 +28,156 @@ export class ConfigDiscoveryService {
         "appwrite.yaml",
         "appwrite.yml",
     ];
-    /**
-     * TypeScript configuration file names to search for
-     */
-    TS_FILENAMES = ["appwriteConfig.ts"];
     /**
      * JSON configuration file names to search for
      */
-    JSON_FILENAMES = ["appwrite.json", "appwrite.config.json"];
+    JSON_FILENAMES = ["appwrite.config.json", "appwrite.json"];
     /**
-     * Maximum levels to search up the directory tree
-     */
-    MAX_SEARCH_DEPTH = 5;
-    /**
-     * Finds any configuration file with priority: YAML → TypeScript → JSON
-     * @param startDir The directory to start searching from
-     * @returns Path to the configuration file or null if not found
+     * TypeScript configuration file names to search for
      */
-    findConfig(startDir) {
-        // Try YAML first (highest priority)
-        const yamlConfig = this.findYamlConfig(startDir);
-        if (yamlConfig) {
-            return yamlConfig;
-        }
-        // Try TypeScript second
-        const tsConfig = this.findTypeScriptConfig(startDir);
-        if (tsConfig) {
-            return tsConfig;
-        }
-        // Try JSON last (lowest priority)
-        const jsonConfig = this.findProjectConfig(startDir);
-        if (jsonConfig) {
-            return jsonConfig;
-        }
-        return null;
-    }
+    TS_FILENAMES = ["appwriteConfig.ts"];
     /**
-     * Finds YAML configuration files
-     * Searches current directory, subdirectories, and parent directory
+     * Finds the git repository root directory
      * @param startDir The directory to start searching from
-     * @returns Path to the YAML config file or null if not found
+     * @returns Path to the repository root, or startDir if no .git found
      */
-    findYamlConfig(startDir) {
-        // First check current directory for YAML configs
-        for (const fileName of this.YAML_FILENAMES) {
-            const configPath = path.join(startDir, fileName);
-            if (fs.existsSync(configPath)) {
-                return configPath;
-            }
-        }
-        // Recursively search subdirectories for .appwrite folders
-        const yamlConfigInSubdirs = this.findYamlConfigRecursive(startDir);
-        if (yamlConfigInSubdirs) {
-            return yamlConfigInSubdirs;
-        }
-        // Check one level up to avoid infinite traversal
-        const parentDir = path.dirname(startDir);
-        if (parentDir !== startDir && path.basename(parentDir) !== "node_modules") {
-            for (const fileName of this.YAML_FILENAMES) {
-                const configPath = path.join(parentDir, fileName);
-                if (fs.existsSync(configPath)) {
-                    return configPath;
-                }
-            }
-        }
-        return null;
+    async findRepoRoot(startDir) {
+        const gitDir = await findUp(".git", {
+            cwd: startDir,
+            type: "directory",
+        });
+        return gitDir ? path.dirname(gitDir) : startDir;
     }
     /**
-     * Recursively searches for YAML configs in .appwrite subdirectories
-     * @param dir The directory to search
-     * @param depth Current search depth
-     * @returns Path to YAML config or null
+     * Recursively searches downward for files matching patterns
+     * @param dir Directory to search in
+     * @param patterns File patterns to match
+     * @param maxDepth Maximum depth to search
+     * @param currentDepth Current recursion depth
+     * @returns First matching file path or null
      */
-    findYamlConfigRecursive(dir, depth = 0) {
-        // Limit search depth to prevent infinite recursion
-        if (depth > this.MAX_SEARCH_DEPTH) {
+    async searchDownward(dir, patterns, maxDepth = 5, currentDepth = 0) {
+        if (currentDepth > maxDepth)
             return null;
-        }
-        if (shouldIgnoreDirectory(path.basename(dir))) {
+        if (shouldIgnoreDirectory(path.basename(dir)))
             return null;
-        }
         try {
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+            // Check current directory for matches
+            for (const pattern of patterns) {
+                const fullPath = path.join(dir, pattern);
+                if (fs.existsSync(fullPath)) {
+                    return fullPath;
+                }
+            }
+            // Recurse into subdirectories
             for (const entry of entries) {
                 if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
-                    const fullPath = path.join(dir, entry.name);
-                    // Check if this is an .appwrite directory
-                    if (entry.name === ".appwrite") {
-                        const configPaths = [
-                            path.join(fullPath, "config.yaml"),
-                            path.join(fullPath, "config.yml"),
-                            path.join(fullPath, "appwriteConfig.yaml"),
-                            path.join(fullPath, "appwriteConfig.yml"),
-                        ];
-                        for (const configPath of configPaths) {
-                            if (fs.existsSync(configPath)) {
-                                return configPath;
-                            }
-                        }
-                    }
-                    // Recurse into other directories with increased depth
-                    const result = this.findYamlConfigRecursive(fullPath, depth + 1);
+                    const result = await this.searchDownward(path.join(dir, entry.name), patterns, maxDepth, currentDepth + 1);
                     if (result)
                         return result;
                 }
             }
         }
         catch (error) {
-            // Ignore directory access errors
+            // Ignore permission errors
         }
         return null;
     }
     /**
-     * Finds TypeScript configuration files (appwriteConfig.ts)
+     * Finds any configuration file with configurable priority
      * @param startDir The directory to start searching from
-     * @returns Path to the TypeScript config file or null if not found
-     */
-    findTypeScriptConfig(startDir) {
-        return this.findTypeScriptConfigRecursive(startDir);
-    }
-    /**
-     * Recursively searches for TypeScript configuration files
-     * @param dir The directory to search
-     * @param depth Current search depth
-     * @returns Path to TypeScript config or null
+     * @param preferJson If true, prioritizes appwrite.config.json over YAML (default: false)
+     * @returns Path to the configuration file or null if not found
+     *
+     * Default priority: YAML → JSON → TypeScript
+     * With preferJson=true: JSON → YAML → TypeScript
      */
-    findTypeScriptConfigRecursive(dir, depth = 0) {
-        // Limit search depth to prevent infinite recursion
-        if (depth > 10) {
-            return null;
+    async findConfig(startDir, preferJson = false) {
+        // Find repo root to establish boundary
+        const repoRoot = await this.findRepoRoot(startDir);
+        if (preferJson) {
+            // Try JSON first when --appwrite-config flag is used
+            const jsonConfig = await this.findProjectConfig(startDir, repoRoot);
+            if (jsonConfig)
+                return jsonConfig;
+            // Try YAML second
+            const yamlConfig = await this.findYamlConfig(startDir, repoRoot);
+            if (yamlConfig)
+                return yamlConfig;
+            // Try TypeScript last (lowest priority)
+            const tsConfig = await this.findTypeScriptConfig(startDir, repoRoot);
+            if (tsConfig)
+                return tsConfig;
         }
-        if (shouldIgnoreDirectory(path.basename(dir))) {
-            return null;
-        }
-        try {
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-            // First check current directory for appwriteConfig.ts
-            for (const entry of entries) {
-                if (entry.isFile() && this.TS_FILENAMES.includes(entry.name)) {
-                    return path.join(dir, entry.name);
-                }
-            }
-            // Then search subdirectories
-            for (const entry of entries) {
-                if (entry.isDirectory() && !shouldIgnoreDirectory(entry.name)) {
-                    const result = this.findTypeScriptConfigRecursive(path.join(dir, entry.name), depth + 1);
-                    if (result)
-                        return result;
-                }
-            }
-        }
-        catch (error) {
-            // Ignore directory access errors
+        else {
+            // Default priority: YAML → JSON → TypeScript
+            const yamlConfig = await this.findYamlConfig(startDir, repoRoot);
+            if (yamlConfig)
+                return yamlConfig;
+            const jsonConfig = await this.findProjectConfig(startDir, repoRoot);
+            if (jsonConfig)
+                return jsonConfig;
+            const tsConfig = await this.findTypeScriptConfig(startDir, repoRoot);
+            if (tsConfig)
+                return tsConfig;
         }
         return null;
     }
     /**
-     * Finds project configuration JSON files (appwrite.json, appwrite.config.json)
-     * Searches up to 5 levels up the directory tree
+     * Finds YAML configuration files
+     * Searches UP to repo root, then DOWN from repo root
+     * @param startDir The directory to start searching from
+     * @param repoRoot The repository root boundary
+     * @returns Path to the YAML config file or null if not found
+     */
+    async findYamlConfig(startDir, repoRoot) {
+        const boundary = repoRoot || (await this.findRepoRoot(startDir));
+        // Search UP to repo root
+        const upwardResult = await findUp(this.YAML_FILENAMES, {
+            cwd: startDir,
+            stopAt: boundary,
+        });
+        if (upwardResult)
+            return upwardResult;
+        // Search DOWN from repo root
+        return await this.searchDownward(boundary, this.YAML_FILENAMES);
+    }
+    /**
+     * Finds JSON project configuration files (appwrite.config.json, appwrite.json)
      * @param startDir The directory to start searching from
+     * @param repoRoot The repository root boundary
      * @returns Path to the JSON config file or null if not found
      */
-    findProjectConfig(startDir = process.cwd()) {
-        let currentDir = startDir;
-        // Search up to MAX_SEARCH_DEPTH levels up the directory tree
-        for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {
-            for (const configName of this.JSON_FILENAMES) {
-                const configPath = path.join(currentDir, configName);
-                if (fs.existsSync(configPath)) {
-                    return configPath;
-                }
-            }
-            const parentDir = path.dirname(currentDir);
-            if (parentDir === currentDir) {
-                break; // Reached filesystem root
-            }
-            currentDir = parentDir;
-        }
-        return null;
+    async findProjectConfig(startDir, repoRoot) {
+        const boundary = repoRoot || (await this.findRepoRoot(startDir));
+        // Search UP to repo root
+        const upwardResult = await findUp(this.JSON_FILENAMES, {
+            cwd: startDir,
+            stopAt: boundary,
+        });
+        if (upwardResult)
+            return upwardResult;
+        // Search DOWN from repo root
+        return await this.searchDownward(boundary, this.JSON_FILENAMES);
+    }
+    /**
+     * Finds TypeScript configuration files (appwriteConfig.ts)
+     * @param startDir The directory to start searching from
+     * @param repoRoot The repository root boundary
+     * @returns Path to the TypeScript config file or null if not found
+     */
+    async findTypeScriptConfig(startDir, repoRoot) {
+        const boundary = repoRoot || (await this.findRepoRoot(startDir));
+        // Search UP to repo root
+        const upwardResult = await findUp(this.TS_FILENAMES, {
+            cwd: startDir,
+            stopAt: boundary,
+        });
+        if (upwardResult)
+            return upwardResult;
+        // Search DOWN from repo root
+        return await this.searchDownward(boundary, this.TS_FILENAMES);
     }
     /**
      * Discovers collection YAML files in a collections/ directory
@@ -298,62 +270,36 @@ export class ConfigDiscoveryService {
      * @param startDir The directory to start searching from
      * @returns Path to .appwrite directory or null if not found
      */
-    findAppwriteDirectory(startDir) {
-        let currentDir = startDir;
-        // Search up to MAX_SEARCH_DEPTH levels up the directory tree
-        for (let i = 0; i < this.MAX_SEARCH_DEPTH; i++) {
-            const appwriteDir = path.join(currentDir, ".appwrite");
-            if (fs.existsSync(appwriteDir) && fs.statSync(appwriteDir).isDirectory()) {
-                return appwriteDir;
-            }
-            const parentDir = path.dirname(currentDir);
-            if (parentDir === currentDir) {
-                break; // Reached filesystem root
-            }
-            currentDir = parentDir;
-        }
-        return null;
+    async findAppwriteDirectory(startDir) {
+        const repoRoot = await this.findRepoRoot(startDir);
+        // Search UP to repo root
+        const upwardResult = await findUp(".appwrite", {
+            cwd: startDir,
+            type: "directory",
+            stopAt: repoRoot,
+        });
+        if (upwardResult)
+            return upwardResult;
+        // Search DOWN from repo root
+        return await this.searchDownward(repoRoot, [".appwrite"]);
     }
     /**
      * Finds the functions directory
      * @param startDir The directory to start searching from
      * @returns Path to functions directory or null if not found
      */
-    findFunctionsDirectory(startDir) {
-        return this.findFunctionsDirectoryRecursive(startDir);
-    }
-    /**
-     * Recursively searches for the functions directory
-     * @param dir The directory to search
-     * @param depth Current search depth
-     * @returns Path to functions directory or null
-     */
-    findFunctionsDirectoryRecursive(dir, depth = 0) {
-        // Limit search depth to prevent infinite recursion
-        if (depth > this.MAX_SEARCH_DEPTH) {
-            return null;
-        }
-        if (shouldIgnoreDirectory(path.basename(dir))) {
-            return null;
-        }
-        try {
-            const files = fs.readdirSync(dir, { withFileTypes: true });
-            for (const entry of files) {
-                if (!entry.isDirectory() || shouldIgnoreDirectory(entry.name)) {
-                    continue;
-                }
-                if (entry.name === "functions") {
-                    return path.join(dir, entry.name);
-                }
-                const result = this.findFunctionsDirectoryRecursive(path.join(dir, entry.name), depth + 1);
-                if (result)
-                    return result;
-            }
-        }
-        catch (error) {
-            // Ignore directory access errors
-        }
-        return null;
+    async findFunctionsDirectory(startDir) {
+        const repoRoot = await this.findRepoRoot(startDir);
+        // Search UP to repo root
+        const upwardResult = await findUp("functions", {
+            cwd: startDir,
+            type: "directory",
+            stopAt: repoRoot,
+        });
+        if (upwardResult)
+            return upwardResult;
+        // Search DOWN from repo root
+        return await this.searchDownward(repoRoot, ["functions"]);
     }
     /**
      * Gets a summary of all discoverable configuration files
@@ -361,14 +307,16 @@ export class ConfigDiscoveryService {
      * @param startDir The directory to start searching from
      * @returns Object containing paths to all discovered config types
      */
-    getConfigurationSummary(startDir) {
+    async getConfigurationSummary(startDir) {
+        const repoRoot = await this.findRepoRoot(startDir);
         return {
-            yaml: this.findYamlConfig(startDir),
-            typescript: this.findTypeScriptConfig(startDir),
-            json: this.findProjectConfig(startDir),
-            appwriteDirectory: this.findAppwriteDirectory(startDir),
-            functionsDirectory: this.findFunctionsDirectory(startDir),
-            selectedConfig: this.findConfig(startDir),
+            yaml: await this.findYamlConfig(startDir, repoRoot),
+            typescript: await this.findTypeScriptConfig(startDir, repoRoot),
+            json: await this.findProjectConfig(startDir, repoRoot),
+            appwriteDirectory: await this.findAppwriteDirectory(startDir),
+            functionsDirectory: await this.findFunctionsDirectory(startDir),
+            selectedConfig: await this.findConfig(startDir),
+            repoRoot,
         };
     }
 }

package/dist/config/services/ConfigLoaderService.js

@@ -244,18 +244,13 @@ export class ConfigLoaderService {
             if (!projectConfig) {
                 throw new Error(`Failed to load project config from: ${jsonPath}`);
             }
-            // Convert project config to AppwriteConfig format
-            const appwriteConfig = projectConfigToAppwriteConfig(projectConfig);
+            // Convert project config to AppwriteConfig format (includes function path normalization)
+            const appwriteConfig = projectConfigToAppwriteConfig(projectConfig, jsonPath);
             // Get collections from project config
             const collections = getCollectionsFromProject(projectConfig);
             if (collections.length > 0) {
                 appwriteConfig.collections = collections;
             }
-            // Normalize function paths
-            const configDir = path.dirname(jsonPath);
-            if (appwriteConfig.functions) {
-                appwriteConfig.functions = appwriteConfig.functions.map(func => this.normalizeFunctionPath(func, configDir));
-            }
             MessageFormatter.success(`Loaded project config from: ${jsonPath}`, {
                 prefix: "Config",
             });

package/dist/config/yamlConfig.d.ts

@@ -288,7 +288,7 @@ export declare const createSessionPreservingYamlConfig: (configPath: string, ses
                 $updatedAt?: string | undefined;
                 error?: string | undefined;
                 xdefault?: string | null | undefined;
-                encrypted?: boolean | undefined;
+                encrypt?: boolean | undefined;
             } | {
                 key: string;
                 required: boolean;
@@ -506,7 +506,7 @@ export declare const createSessionPreservingYamlConfig: (configPath: string, ses
                 $updatedAt?: string | undefined;
                 error?: string | undefined;
                 xdefault?: string | null | undefined;
-                encrypted?: boolean | undefined;
+                encrypt?: boolean | undefined;
             } | {
                 key: string;
                 required: boolean;

package/dist/functions/methods.js

@@ -2,7 +2,7 @@ import { AppwriteException, Client, Functions, Query, Runtime, } from "node-appw
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import fs from "node:fs";
-import {} from "appwrite-utils";
+import { EventTypeSchema, } from "appwrite-utils";
 import chalk from "chalk";
 import { extract as extractTar } from "tar";
 import { MessageFormatter } from "../shared/messageFormatter.js";
@@ -10,6 +10,7 @@ import { expandTildePath, normalizeFunctionName } from "./pathResolution.js";
 /**
  * Validates and filters events array for Appwrite functions
  * - Filters out empty/invalid strings
+ * - Validates against EventTypeSchema
  * - Limits to 100 items maximum (Appwrite limit)
  * - Returns empty array if input is invalid
  */
@@ -17,7 +18,18 @@ const validateEvents = (events) => {
     if (!events || !Array.isArray(events))
         return [];
     return events
-        .filter(event => event && typeof event === 'string' && event.trim().length > 0)
+        .filter(event => {
+        if (!event || typeof event !== 'string' || event.trim().length === 0) {
+            return false;
+        }
+        // Validate against EventTypeSchema
+        const result = EventTypeSchema.safeParse(event);
+        if (!result.success) {
+            MessageFormatter.warning(`Invalid event type "${event}" will be filtered out`, { prefix: "Functions" });
+            return false;
+        }
+        return true;
+    })
         .slice(0, 100);
 };
 export const listFunctions = async (client, queries, search) => {

package/dist/main.js

@@ -217,6 +217,11 @@ const argv = yargs(hideBin(process.argv))
     .option("config", {
     type: "string",
     description: "Path to Appwrite configuration file (appwriteConfig.ts)",
+})
+    .option("appwriteConfig", {
+    alias: ["appwrite-config", "use-appwrite-config"],
+    type: "boolean",
+    description: "Prefer loading from appwrite.config.json instead of config.yaml",
 })
     .option("it", {
     alias: ["interactive", "i"],
@@ -557,7 +562,7 @@ async function main() {
         }
         // Create controller with session authentication support using singleton
         const controller = UtilsController.getInstance(process.cwd(), finalDirectConfig);
-        // Pass session authentication options to the controller
+        // Pass session authentication and config options to the controller
         const initOptions = {};
         if (argv.useSession || argv.sessionCookie) {
             initOptions.useSession = true;
@@ -565,6 +570,9 @@ async function main() {
                 initOptions.sessionCookie = argv.sessionCookie;
             }
         }
+        if (argv.appwriteConfig) {
+            initOptions.preferJson = true;
+        }
         await controller.init(initOptions);
         if (argv.setup) {
             await setupDirsFiles(false, process.cwd());

package/dist/migrations/appwriteToX.d.ts

@@ -20,7 +20,7 @@ export declare class AppwriteToX {
         $updatedAt?: string | undefined;
         error?: string | undefined;
         xdefault?: string | null | undefined;
-        encrypted?: boolean | undefined;
+        encrypt?: boolean | undefined;
     } | {
         key: string;
         required: boolean;

package/dist/migrations/dataLoader.d.ts

@@ -21,7 +21,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             min: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             max: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
             elements: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            encrypted: z.ZodOptional<z.ZodBoolean>;
+            encrypt: z.ZodOptional<z.ZodBoolean>;
             relatedCollection: z.ZodOptional<z.ZodString>;
             relationType: z.ZodOptional<z.ZodString>;
             twoWay: z.ZodOptional<z.ZodBoolean>;
@@ -46,7 +46,7 @@ export declare const CollectionImportDataSchema: z.ZodObject<{
             type: z.ZodLiteral<"string">;
             size: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
             xdefault: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            encrypted: z.ZodOptional<z.ZodBoolean>;
+            encrypt: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>, z.ZodObject<{
             array: z.ZodOptional<z.ZodBoolean>;
             format: z.ZodOptional<z.ZodString>;
@@ -394,7 +394,7 @@ export declare class DataLoader {
                 $updatedAt?: string | undefined;
                 error?: string | undefined;
                 xdefault?: string | null | undefined;
-                encrypted?: boolean | undefined;
+                encrypt?: boolean | undefined;
             } | {
                 key: string;
                 required: boolean;

package/dist/shared/functionManager.js

@@ -1,5 +1,5 @@
 import { Client, Functions, Runtime } from "node-appwrite";
-import {} from "appwrite-utils";
+import { EventTypeSchema } from "appwrite-utils";
 import { join, relative, resolve, basename } from "node:path";
 import fs from "node:fs";
 import chalk from "chalk";
@@ -9,6 +9,7 @@ import { MessageFormatter } from "./messageFormatter.js";
 /**
  * Validates and filters events array for Appwrite functions
  * - Filters out empty/invalid strings
+ * - Validates against EventTypeSchema
  * - Limits to 100 items maximum (Appwrite limit)
  * - Returns empty array if input is invalid
  */
@@ -16,7 +17,18 @@ const validateEvents = (events) => {
     if (!events || !Array.isArray(events))
         return [];
     return events
-        .filter(event => event && typeof event === 'string' && event.trim().length > 0)
+        .filter(event => {
+        if (!event || typeof event !== 'string' || event.trim().length === 0) {
+            return false;
+        }
+        // Validate against EventTypeSchema
+        const result = EventTypeSchema.safeParse(event);
+        if (!result.success) {
+            MessageFormatter.warning(`Invalid event type "${event}" will be filtered out`, { prefix: "Functions" });
+            return false;
+        }
+        return true;
+    })
         .slice(0, 100);
 };
 // Concurrency limits

package/dist/storage/schemas.d.ts

@@ -90,7 +90,7 @@ export declare const getMigrationCollectionSchemas: () => {
                 $updatedAt?: string | undefined;
                 error?: string | undefined;
                 xdefault?: string | null | undefined;
-                encrypted?: boolean | undefined;
+                encrypt?: boolean | undefined;
             } | {
                 key: string;
                 required: boolean;
@@ -307,7 +307,7 @@ export declare const getMigrationCollectionSchemas: () => {
             $updatedAt?: string | undefined;
             error?: string | undefined;
             xdefault?: string | null | undefined;
-            encrypted?: boolean | undefined;
+            encrypt?: boolean | undefined;
         } | {
             key: string;
             required: boolean;
@@ -473,7 +473,7 @@ export declare const getMigrationCollectionSchemas: () => {
                 $updatedAt?: string | undefined;
                 error?: string | undefined;
                 xdefault?: string | null | undefined;
-                encrypted?: boolean | undefined;
+                encrypt?: boolean | undefined;
             } | {
                 key: string;
                 required: boolean;
@@ -690,7 +690,7 @@ export declare const getMigrationCollectionSchemas: () => {
             $updatedAt?: string | undefined;
             error?: string | undefined;
             xdefault?: string | null | undefined;
-            encrypted?: boolean | undefined;
+            encrypt?: boolean | undefined;
         } | {
             key: string;
             required: boolean;