appwrite-utils-cli 1.9.7 → 1.12.0

package/dist/utils/projectConfig.js

@@ -1,206 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, dirname, resolve, isAbsolute } from "node:path";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-/**
- * Find appwrite.json or appwrite.config.json in current directory or parents
- */
-export function findAppwriteProjectConfig(startDir = process.cwd()) {
-    const configNames = ["appwrite.json", "appwrite.config.json"];
-    let currentDir = startDir;
-    // Search up to 5 levels up the directory tree
-    for (let i = 0; i < 5; i++) {
-        for (const configName of configNames) {
-            const configPath = join(currentDir, configName);
-            if (existsSync(configPath)) {
-                return configPath;
-            }
-        }
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir) {
-            break; // Reached filesystem root
-        }
-        currentDir = parentDir;
-    }
-    return null;
-}
-/**
- * Load and parse appwrite project configuration
- */
-export function loadAppwriteProjectConfig(configPath) {
-    let actualConfigPath = configPath;
-    if (!actualConfigPath) {
-        actualConfigPath = findAppwriteProjectConfig() || undefined;
-    }
-    if (!actualConfigPath || !existsSync(actualConfigPath)) {
-        return null;
-    }
-    try {
-        const configContent = readFileSync(actualConfigPath, "utf-8");
-        const config = JSON.parse(configContent);
-        // Validate required fields
-        if (!config.projectId) {
-            MessageFormatter.warning(`Appwrite project config missing required 'projectId' field: ${actualConfigPath}`, { prefix: "ProjectConfig" });
-            return null;
-        }
-        return config;
-    }
-    catch (error) {
-        MessageFormatter.error(`Failed to parse Appwrite project config: ${actualConfigPath}`, error instanceof Error ? error : new Error(String(error)), { prefix: "ProjectConfig" });
-        return null;
-    }
-}
-/**
- * Detect API mode from project configuration
- */
-export function detectApiModeFromProject(projectConfig) {
-    // If both are present, prefer TablesDB (newer)
-    if (projectConfig.tablesDB && projectConfig.tables) {
-        return "tablesdb";
-    }
-    // If only legacy structure is present
-    if (projectConfig.databases && projectConfig.collections) {
-        return "legacy";
-    }
-    // If only TablesDB structure is present
-    if (projectConfig.tablesDB && projectConfig.tables) {
-        return "tablesdb";
-    }
-    // Default to auto-detection
-    return "auto";
-}
-/**
- * Convert project config to AppwriteConfig format
- * @param projectConfig The project config to convert
- * @param configPath Optional path to the config file (for resolving relative paths)
- * @param existingConfig Optional existing config to merge with
- */
-export function projectConfigToAppwriteConfig(projectConfig, configPath, existingConfig) {
-    const apiMode = detectApiModeFromProject(projectConfig);
-    const configDir = configPath ? dirname(configPath) : process.cwd();
-    const baseConfig = {
-        ...existingConfig,
-        appwriteProject: projectConfig.projectId,
-        apiMode,
-    };
-    // Set endpoint if provided in project config
-    if (projectConfig.endpoint) {
-        baseConfig.appwriteEndpoint = projectConfig.endpoint;
-    }
-    // Merge databases and tablesDB arrays (modern Appwrite may have both)
-    const allDatabases = [
-        ...(projectConfig.databases || []),
-        ...(projectConfig.tablesDB || [])
-    ];
-    // Remove duplicates by $id
-    const uniqueDatabasesMap = new Map();
-    for (const db of allDatabases) {
-        if (!uniqueDatabasesMap.has(db.$id)) {
-            uniqueDatabasesMap.set(db.$id, db);
-        }
-    }
-    if (uniqueDatabasesMap.size > 0) {
-        baseConfig.databases = Array.from(uniqueDatabasesMap.values()).map(db => ({
-            $id: db.$id,
-            name: db.name,
-            // Add basic bucket configuration if not exists
-            bucket: {
-                $id: `${db.$id}_bucket`,
-                name: `${db.name} Bucket`,
-                enabled: true,
-                maximumFileSize: 30000000,
-                allowedFileExtensions: [],
-                encryption: true,
-                antivirus: true,
-            },
-        }));
-    }
-    // Convert buckets if present
-    if (projectConfig.buckets) {
-        baseConfig.buckets = projectConfig.buckets.map(bucket => ({
-            $id: (bucket.bucketId || bucket.$id || `bucket_${Date.now()}`),
-            name: bucket.name,
-            enabled: true,
-            maximumFileSize: bucket.maximumFileSize || 30000000,
-            allowedFileExtensions: bucket.allowedFileExtensions || [],
-            encryption: bucket.encryption ?? true,
-            antivirus: bucket.antiVirus ?? false,
-        }));
-    }
-    // Convert functions with path normalization
-    if (projectConfig.functions) {
-        baseConfig.functions = projectConfig.functions.map(func => {
-            const normalizedFunc = {
-                $id: func.$id,
-                name: func.name,
-                runtime: func.runtime,
-                entrypoint: func.entrypoint,
-                commands: func.commands,
-                events: func.events,
-            };
-            // Convert path to dirPath and make absolute
-            if (func.path) {
-                const expandedPath = func.path;
-                normalizedFunc.dirPath = isAbsolute(expandedPath)
-                    ? expandedPath
-                    : resolve(configDir, expandedPath);
-            }
-            return normalizedFunc;
-        });
-    }
-    return baseConfig;
-}
-/**
- * Get collection/table definitions from project config
- */
-export function getCollectionsFromProject(projectConfig) {
-    if (projectConfig.tables) {
-        // Convert TablesDB tables to collection format
-        return projectConfig.tables.map(table => ({
-            name: table.name,
-            $id: table.$id,
-            $permissions: table.$permissions || [],
-            documentSecurity: table.rowSecurity || false,
-            enabled: table.enabled !== false,
-            // Convert columns to attributes for compatibility
-            attributes: table.columns.map(col => ({
-                key: col.key,
-                type: col.type,
-                required: col.required,
-                array: col.array,
-                size: col.size,
-                default: col.default,
-                encrypt: col.encrypt,
-                unique: col.unique,
-            })),
-            indexes: table.indexes || [],
-            // Mark as coming from TablesDB for processing
-            _isFromTablesDir: true,
-        }));
-    }
-    if (projectConfig.collections) {
-        // Legacy collections format
-        return projectConfig.collections.map(collection => ({
-            name: collection.name,
-            $id: collection.$id,
-            $permissions: collection.$permissions || [],
-            documentSecurity: collection.documentSecurity || false,
-            enabled: collection.enabled !== false,
-            attributes: collection.attributes,
-            indexes: collection.indexes || [],
-            _isFromTablesDir: false,
-        }));
-    }
-    return [];
-}
-/**
- * Check if project config indicates TablesDB usage
- */
-export function isTablesDBProject(projectConfig) {
-    return !!(projectConfig.tablesDB && projectConfig.tables);
-}
-/**
- * Get the appropriate directory name based on project config
- */
-export function getProjectDirectoryName(projectConfig) {
-    return isTablesDBProject(projectConfig) ? "tables" : "collections";
-}

package/dist/utils/retryFailedPromises.d.ts

@@ -1,2 +0,0 @@
-import type { Models } from "node-appwrite";
-export declare const retryFailedPromises: (batch: Promise<Models.Document>[], maxRetries?: number) => Promise<PromiseSettledResult<Models.Document>[]>;

package/dist/utils/retryFailedPromises.js

@@ -1,23 +0,0 @@
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { logger } from "../shared/logging.js";
-export const retryFailedPromises = async (batch, maxRetries = 3) => {
-    const results = await Promise.allSettled(batch);
-    const toRetry = [];
-    results.forEach((result, index) => {
-        if (result.status === "rejected") {
-            logger.error("Promise rejected with reason:", { reason: result.reason });
-            if (maxRetries > 0) {
-                toRetry.push(batch[index]);
-            }
-        }
-    });
-    if (toRetry.length > 0) {
-        MessageFormatter.info(`Retrying ${toRetry.length} promises`, { prefix: "Retry" });
-        return retryFailedPromises(toRetry, maxRetries - 1);
-    }
-    else {
-        return results
-            .filter((result) => result.status === "fulfilled")
-            .map((result) => result);
-    }
-};

package/dist/utils/sessionAuth.d.ts

@@ -1,48 +0,0 @@
-export interface AppwriteSessionPrefs {
-    [projectId: string]: {
-        endpoint: string;
-        email: string;
-        cookie: string;
-    };
-}
-export interface SessionAuthInfo {
-    projectId: string;
-    endpoint: string;
-    sessionCookie: string;
-    email?: string;
-}
-/**
- * Load session preferences from ~/.appwrite/prefs.json
- */
-export declare function loadSessionPrefs(): AppwriteSessionPrefs | null;
-/**
- * Get session authentication info for a specific project
- */
-export declare function getSessionAuth(projectId: string): SessionAuthInfo | null;
-/**
- * Check if a session cookie appears to be valid (enhanced validation)
- */
-export declare function isValidSessionCookie(cookie: string): boolean;
-/**
- * Get all available sessions from prefs
- */
-export declare function getAvailableSessions(): SessionAuthInfo[];
-/**
- * Find session by endpoint and project combination
- */
-export declare function findSessionByEndpointAndProject(endpoint: string, projectId: string): SessionAuthInfo | null;
-/**
- * Check if session authentication is available for a project configuration
- */
-export declare function hasSessionAuth(endpoint: string, projectId: string): boolean;
-/**
- * Get detailed authentication status for debugging and error reporting
- */
-export declare function getAuthenticationStatus(endpoint: string, projectId: string): {
-    hasValidSession: boolean;
-    sessionExists: boolean;
-    endpointMatches: boolean;
-    cookieValid: boolean;
-    sessionInfo?: SessionAuthInfo;
-    message: string;
-};

package/dist/utils/sessionAuth.js

@@ -1,164 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-/**
- * Normalizes an endpoint URL by removing trailing slashes and converting to lowercase
- */
-function normalizeEndpoint(url) {
-    return url.replace(/\/+$/, "").toLowerCase();
-}
-/**
- * Load session preferences from ~/.appwrite/prefs.json
- */
-export function loadSessionPrefs() {
-    try {
-        const prefsPath = join(homedir(), ".appwrite", "prefs.json");
-        if (!existsSync(prefsPath)) {
-            return null;
-        }
-        const prefsContent = readFileSync(prefsPath, "utf-8");
-        const prefs = JSON.parse(prefsContent);
-        return prefs;
-    }
-    catch (error) {
-        MessageFormatter.warning("Failed to load Appwrite session preferences", { prefix: "Session" });
-        return null;
-    }
-}
-/**
- * Get session authentication info for a specific project
- */
-export function getSessionAuth(projectId) {
-    const prefs = loadSessionPrefs();
-    if (!prefs || !prefs[projectId]) {
-        return null;
-    }
-    const sessionData = prefs[projectId];
-    // Validate session data structure
-    if (!sessionData.endpoint || !sessionData.cookie) {
-        MessageFormatter.warning(`Invalid session data for project ${projectId}`, { prefix: "Session" });
-        return null;
-    }
-    return {
-        projectId,
-        endpoint: sessionData.endpoint,
-        sessionCookie: sessionData.cookie,
-        email: sessionData.email,
-    };
-}
-/**
- * Check if a session cookie appears to be valid (enhanced validation)
- */
-export function isValidSessionCookie(cookie) {
-    if (!cookie || typeof cookie !== "string") {
-        return false;
-    }
-    // Trim whitespace
-    cookie = cookie.trim();
-    // Basic length check
-    if (cookie.length < 10) {
-        return false;
-    }
-    // Basic validation - Appwrite session cookies are typically JWT-like
-    // They should contain dots and be reasonably long
-    if (!cookie.includes(".")) {
-        return false;
-    }
-    // Check for obviously expired or malformed tokens
-    // JWT tokens typically have 3 parts separated by dots
-    const parts = cookie.split('.');
-    if (parts.length < 2) {
-        return false;
-    }
-    // Additional validation - ensure it's not obviously corrupted
-    // Should contain alphanumeric characters and common JWT characters
-    const validChars = /^[A-Za-z0-9._-]+$/;
-    if (!validChars.test(cookie)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Get all available sessions from prefs
- */
-export function getAvailableSessions() {
-    const prefs = loadSessionPrefs();
-    if (!prefs) {
-        return [];
-    }
-    const sessions = [];
-    for (const [projectId, sessionData] of Object.entries(prefs)) {
-        if (sessionData.endpoint && sessionData.cookie && isValidSessionCookie(sessionData.cookie)) {
-            sessions.push({
-                projectId,
-                endpoint: sessionData.endpoint,
-                sessionCookie: sessionData.cookie,
-                email: sessionData.email,
-            });
-        }
-    }
-    return sessions;
-}
-/**
- * Find session by endpoint and project combination
- */
-export function findSessionByEndpointAndProject(endpoint, projectId) {
-    const sessionAuth = getSessionAuth(projectId);
-    if (!sessionAuth) {
-        MessageFormatter.debug(`No session found for project ${projectId}`, { prefix: "Session" });
-        return null;
-    }
-    // Normalize endpoints for comparison (remove trailing slashes, etc.)
-    if (normalizeEndpoint(sessionAuth.endpoint) !== normalizeEndpoint(endpoint)) {
-        MessageFormatter.warning(`Session endpoint mismatch for project ${projectId}:\n` +
-            `  Session endpoint: ${sessionAuth.endpoint}\n` +
-            `  Config endpoint:  ${endpoint}\n` +
-            `  Tip: Run 'appwrite login' to update session for this endpoint`, { prefix: "Session" });
-        return null;
-    }
-    return sessionAuth;
-}
-/**
- * Check if session authentication is available for a project configuration
- */
-export function hasSessionAuth(endpoint, projectId) {
-    const sessionAuth = findSessionByEndpointAndProject(endpoint, projectId);
-    return sessionAuth !== null && isValidSessionCookie(sessionAuth.sessionCookie);
-}
-/**
- * Get detailed authentication status for debugging and error reporting
- */
-export function getAuthenticationStatus(endpoint, projectId) {
-    const sessionAuth = getSessionAuth(projectId);
-    if (!sessionAuth) {
-        return {
-            hasValidSession: false,
-            sessionExists: false,
-            endpointMatches: false,
-            cookieValid: false,
-            message: `No session found for project ${projectId}. Run 'appwrite login' to authenticate.`
-        };
-    }
-    const endpointMatches = normalizeEndpoint(sessionAuth.endpoint) === normalizeEndpoint(endpoint);
-    const cookieValid = isValidSessionCookie(sessionAuth.sessionCookie);
-    const hasValidSession = endpointMatches && cookieValid;
-    let message = "";
-    if (!endpointMatches) {
-        message = `Session endpoint mismatch. Expected: ${endpoint}, Found: ${sessionAuth.endpoint}`;
-    }
-    else if (!cookieValid) {
-        message = `Session cookie is invalid or expired for project ${projectId}`;
-    }
-    else {
-        message = `Valid session found for ${sessionAuth.email || 'unknown user'}`;
-    }
-    return {
-        hasValidSession,
-        sessionExists: true,
-        endpointMatches,
-        cookieValid,
-        sessionInfo: sessionAuth,
-        message
-    };
-}

package/dist/utils/typeGuards.d.ts

@@ -1,35 +0,0 @@
-import type { Databases } from "node-appwrite";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-/**
- * Type guard and validation utilities
- */
-/**
- * Type guard to check if object is a DatabaseAdapter
- * @param db - Object to check
- * @returns True if object is DatabaseAdapter
- */
-export declare function isDatabaseAdapter(db: Databases | DatabaseAdapter): db is DatabaseAdapter;
-/**
- * Type guard to check if object is legacy Databases instance
- * @param db - Object to check
- * @returns True if object is Databases (not DatabaseAdapter)
- */
-export declare function isLegacyDatabases(db: Databases | DatabaseAdapter): db is Databases;
-/**
- * Checks if object has metadata property
- * @param obj - Object to check
- * @returns True if object has metadata
- */
-export declare function hasMetadata(obj: any): boolean;
-/**
- * Type guard for collection create objects
- * @param obj - Object to check
- * @returns True if object looks like CollectionCreate
- */
-export declare function isCollectionCreate(obj: any): boolean;
-/**
- * Type guard for table create objects
- * @param obj - Object to check
- * @returns True if object looks like TableCreate
- */
-export declare function isTableCreate(obj: any): boolean;

package/dist/utils/typeGuards.js

@@ -1,57 +0,0 @@
-import { logger } from "../shared/logging.js";
-/**
- * Type guard and validation utilities
- */
-/**
- * Type guard to check if object is a DatabaseAdapter
- * @param db - Object to check
- * @returns True if object is DatabaseAdapter
- */
-export function isDatabaseAdapter(db) {
-    const isAdapter = 'getMetadata' in db && typeof db.getMetadata === 'function';
-    logger.debug('Adapter type detection', {
-        isAdapter,
-        hasGetMetadata: 'getMetadata' in db,
-        getMetadataType: typeof db.getMetadata,
-        operation: 'isDatabaseAdapter'
-    });
-    return isAdapter;
-}
-/**
- * Type guard to check if object is legacy Databases instance
- * @param db - Object to check
- * @returns True if object is Databases (not DatabaseAdapter)
- */
-export function isLegacyDatabases(db) {
-    return !isDatabaseAdapter(db);
-}
-/**
- * Checks if object has metadata property
- * @param obj - Object to check
- * @returns True if object has metadata
- */
-export function hasMetadata(obj) {
-    return obj && typeof obj === 'object' && 'metadata' in obj;
-}
-/**
- * Type guard for collection create objects
- * @param obj - Object to check
- * @returns True if object looks like CollectionCreate
- */
-export function isCollectionCreate(obj) {
-    return obj &&
-        typeof obj === 'object' &&
-        'name' in obj &&
-        ('$id' in obj || 'collectionId' in obj);
-}
-/**
- * Type guard for table create objects
- * @param obj - Object to check
- * @returns True if object looks like TableCreate
- */
-export function isTableCreate(obj) {
-    return obj &&
-        typeof obj === 'object' &&
-        'name' in obj &&
-        ('tableId' in obj || '$id' in obj);
-}

package/dist/utils/validationRules.d.ts

@@ -1,43 +0,0 @@
-export interface ValidationRules {
-    [key: string]: (value: any, ...args: any[]) => boolean;
-}
-export declare const validationRules: {
-    isNumber: (value: any) => boolean;
-    isString: (value: any) => boolean;
-    isBoolean: (value: any) => boolean;
-    isArray: (value: any) => boolean;
-    isObject: (value: any) => boolean;
-    isNull: (value: any) => boolean;
-    isValidEmail: (value: string) => boolean;
-    isValidPhone: (value: string) => boolean;
-    isValidPassword: (value: string) => boolean;
-    isValidUrl: (value: string) => boolean;
-    isValidHex: (value: string) => boolean;
-    isValidHexColor: (value: string) => boolean;
-    isValidHexAlpha: (value: string) => boolean;
-    isValidDate: (value: string) => boolean;
-    isValidTime: (value: string) => boolean;
-    isNullish: (value: any) => boolean;
-    isUndefined: (value: any) => boolean;
-    isDefined: (value: any) => boolean;
-    isDate: (value: any) => boolean;
-    isEmpty: (value: any) => boolean;
-    isInteger: (value: any) => boolean;
-    isFloat: (value: any) => boolean;
-    isArrayLike: (value: any) => boolean;
-    isArrayLikeObject: (value: any) => boolean;
-    isFunction: (value: any) => boolean;
-    isLength: (value: any) => boolean;
-    isMap: (value: any) => boolean;
-    isSet: (value: any) => boolean;
-    isRegExp: (value: any) => boolean;
-    isSymbol: (value: any) => boolean;
-    isObjectLike: (value: any) => boolean;
-    isPlainObject: (value: any) => boolean;
-    isSafeInteger: (value: any) => boolean;
-    isTypedArray: (value: any) => boolean;
-    isEqual: (value: any, other: any) => boolean;
-    isMatch: (object: any, source: any) => boolean;
-    has: (object: any, path: string) => boolean;
-    get: (object: any, path: string, defaultValue: any) => any;
-};

package/dist/utils/validationRules.js

@@ -1,42 +0,0 @@
-import { isNumber, isString, isBoolean, isArray, isPlainObject, isNull, isUndefined, isDate, isEmpty, isInteger, isArrayLike, isArrayLikeObject, isFunction, isLength, isMap, isSet, isRegExp, isSymbol, isObjectLike, isSafeInteger, isTypedArray, isEqual, isMatch, has, get, } from "es-toolkit/compat";
-export const validationRules = {
-    isNumber: (value) => isNumber(value),
-    isString: (value) => isString(value),
-    isBoolean: (value) => isBoolean(value),
-    isArray: (value) => isArray(value),
-    isObject: (value) => isPlainObject(value) && !isArray(value) && !isFunction(value),
-    isNull: (value) => isNull(value),
-    isValidEmail: (value) => value.match(/^[\w\-\.]+@([\w-]+\.)+[\w-]{2,}$/) !== null,
-    isValidPhone: (value) => value.match(/^[+]?[(]?[0-9]{3}[)]?[-\s.]?[0-9]{3}[-\s.]?[0-9]{4,6}$/im) !==
-        null,
-    isValidPassword: (value) => value.match(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*#?&])[A-Za-z\d@$!%*#?&]{8,}$/) !== null,
-    isValidUrl: (value) => value.match(/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/) !== null,
-    isValidHex: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
-    isValidHexColor: (value) => value.match(/^#([a-f0-9]{6}|[a-f0-9]{3})$/i) !== null,
-    isValidHexAlpha: (value) => value.match(/^#([a-f0-9]{8}|[a-f0-9]{4})$/i) !== null,
-    isValidDate: (value) => value.match(/^\d{4}-\d{2}-\d{2}$/) !== null,
-    isValidTime: (value) => value.match(/^\d{2}:\d{2}(:\d{2})?$/) !== null,
-    isNullish: (value) => isNull(value) || isUndefined(value),
-    isUndefined: (value) => isUndefined(value),
-    isDefined: (value) => !isUndefined(value) && !isNull(value) && !isEmpty(value),
-    isDate: (value) => isDate(value),
-    isEmpty: (value) => isEmpty(value),
-    isInteger: (value) => isInteger(value),
-    isFloat: (value) => isNumber(value) && !isInteger(value), // Note: Works for double precision numbers
-    isArrayLike: (value) => isArrayLike(value),
-    isArrayLikeObject: (value) => isArrayLikeObject(value),
-    isFunction: (value) => isFunction(value),
-    isLength: (value) => isLength(value),
-    isMap: (value) => isMap(value),
-    isSet: (value) => isSet(value),
-    isRegExp: (value) => isRegExp(value),
-    isSymbol: (value) => isSymbol(value),
-    isObjectLike: (value) => isObjectLike(value),
-    isPlainObject: (value) => isPlainObject(value),
-    isSafeInteger: (value) => isSafeInteger(value),
-    isTypedArray: (value) => isTypedArray(value),
-    isEqual: (value, other) => isEqual(value, other),
-    isMatch: (object, source) => isMatch(object, source),
-    has: (object, path) => has(object, path),
-    get: (object, path, defaultValue) => get(object, path, defaultValue),
-};

package/dist/utils/versionDetection.d.ts

@@ -1,58 +0,0 @@
-/**
- * Version Detection Utility for Appwrite API Compatibility
- *
- * This module provides functions to detect whether an Appwrite instance
- * supports the new TablesDB API or uses the legacy Databases API.
- *
- * Detection Strategy:
- * 1. Primary: Test TablesDB-specific endpoint availability
- * 2. Secondary: Health endpoint version check
- * 3. Fallback: Default to legacy mode for safety
- */
-export type ApiMode = 'legacy' | 'tablesdb';
-export interface VersionDetectionResult {
-    apiMode: ApiMode;
-    detectionMethod: 'endpoint_probe' | 'health_check' | 'fallback';
-    serverVersion?: string;
-    confidence: 'high' | 'medium' | 'low';
-}
-/**
- * Detects Appwrite API version and TablesDB support
- *
- * @param endpoint - Appwrite server endpoint URL
- * @param project - Project ID
- * @param apiKey - API key for authentication
- * @returns Promise resolving to version detection result
- */
-export declare function detectAppwriteVersion(endpoint: string, project: string, apiKey: string): Promise<VersionDetectionResult>;
-/**
- * Cached version detection with automatic cache management
- *
- * @param endpoint - Appwrite server endpoint URL
- * @param project - Project ID
- * @param apiKey - API key for authentication
- * @param forceRefresh - Skip cache and force fresh detection
- * @returns Promise resolving to version detection result
- */
-export declare function detectAppwriteVersionCached(endpoint: string, project: string, apiKey: string, forceRefresh?: boolean): Promise<VersionDetectionResult>;
-/**
- * Quick check for cloud.appwrite.io instances (likely have TablesDB)
- *
- * @param endpoint - Appwrite server endpoint URL
- * @returns boolean indicating if endpoint is likely cloud-hosted
- */
-export declare function isCloudAppwriteEndpoint(endpoint: string): boolean;
-/**
- * SDK feature detection as a fallback method
- * Attempts to dynamically import TablesDB to check availability
- */
-/**
- * Clear version detection cache (useful for testing)
- */
-export declare function clearVersionDetectionCache(): void;
-/**
- * Fetch server version from /health/version (no auth required)
- */
-export declare function fetchServerVersion(endpoint: string): Promise<string | null>;
-/** Compare semantic versions (basic) */
-export declare function isVersionAtLeast(current: string | undefined, target: string): boolean;