@njdamstra/appwrite-utils-cli 1.8.9 → 1.10.1

package/dist/shared/schemaGenerator.js

@@ -1,556 +0,0 @@
-import { toCamelCase, toPascalCase } from "../utils/index.js";
-import { getVersionAwareDirectory, resolveDirectoryForApiMode, getDualDirectoryPaths } from "@njdamstra/appwrite-utils";
-import { z } from "zod";
-import fs from "fs";
-import path from "path";
-import { dump } from "js-yaml";
-import { getDatabaseFromConfig } from "../migrations/afterImportActions.js";
-import { ulid } from "ulidx";
-import { JsonSchemaGenerator } from "./jsonSchemaGenerator.js";
-import { collectionToYaml, getCollectionYamlFilename } from "../utils/yamlConverter.js";
-import { extractTwoWayRelationships, resolveCollectionName } from "./relationshipExtractor.js";
-import { resolveSchemaDir } from "../utils/pathResolvers.js";
-import { MessageFormatter } from "./messageFormatter.js";
-export class SchemaGenerator {
-    relationshipMap = new Map();
-    config;
-    appwriteFolderPath;
-    constructor(config, appwriteFolderPath) {
-        this.config = config;
-        this.appwriteFolderPath = appwriteFolderPath;
-        this.extractRelationships();
-    }
-    resolveCollectionName = (idOrName) => {
-        return resolveCollectionName(this.config, idOrName);
-    };
-    updateYamlCollections() {
-        const collections = this.config.collections;
-        delete this.config.collections;
-        // Determine output directory based on API mode/version detection
-        const outputDir = this.getVersionAwareCollectionsDirectory();
-        const collectionsDir = path.join(this.appwriteFolderPath, outputDir);
-        if (!fs.existsSync(collectionsDir)) {
-            fs.mkdirSync(collectionsDir, { recursive: true });
-        }
-        collections?.forEach((collection) => {
-            // Determine schema path based on config and output directory
-            const schemaDir = this.config.schemaConfig?.yamlSchemaDirectory || ".yaml_schemas";
-            const isTablesMode = outputDir === "tables";
-            const schemaPath = isTablesMode
-                ? `../${schemaDir}/table.schema.json`
-                : `../${schemaDir}/collection.schema.json`;
-            const yamlConfig = {
-                useTableTerminology: isTablesMode,
-                entityType: isTablesMode ? 'table' : 'collection',
-                schemaPath
-            };
-            const yamlContent = collectionToYaml(collection, yamlConfig);
-            const filename = getCollectionYamlFilename(collection);
-            const filePath = path.join(collectionsDir, filename);
-            fs.writeFileSync(filePath, yamlContent, { encoding: "utf-8" });
-            MessageFormatter.success(`${outputDir === "tables" ? "Table" : "Collection"} YAML written to ${filePath}`, { prefix: "Schema" });
-        });
-    }
-    updateTsSchemas() {
-        const collections = this.config.collections;
-        const functions = this.config.functions || [];
-        delete this.config.collections;
-        delete this.config.functions;
-        const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
-        const configContent = `import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
-  
-  const appwriteConfig: AppwriteConfig = {
-    appwriteEndpoint: "${this.config.appwriteEndpoint}",
-    appwriteProject: "${this.config.appwriteProject}",
-    appwriteKey: "${this.config.appwriteKey}",
-    enableBackups: ${this.config.enableBackups},
-    backupInterval: ${this.config.backupInterval},
-    backupRetention: ${this.config.backupRetention},
-    enableBackupCleanup: ${this.config.enableBackupCleanup},
-    enableMockData: ${this.config.enableMockData},
-    documentBucketId: "${this.config.documentBucketId}",
-    usersCollectionName: "${this.config.usersCollectionName}",
-    databases: ${JSON.stringify(this.config.databases, null, 4)},
-    buckets: ${JSON.stringify(this.config.buckets, null, 4)},
-    functions: ${JSON.stringify(functions.map((func) => ({
-            functionId: func.$id || ulid(),
-            name: func.name,
-            runtime: func.runtime,
-            path: func.dirPath || `functions/${func.name}`,
-            entrypoint: func.entrypoint || "src/index.ts",
-            execute: func.execute,
-            events: func.events || [],
-            schedule: func.schedule || "",
-            timeout: func.timeout || 15,
-            enabled: func.enabled !== false,
-            logging: func.logging !== false,
-            commands: func.commands || "npm install",
-            scopes: func.scopes || [],
-            installationId: func.installationId,
-            providerRepositoryId: func.providerRepositoryId,
-            providerBranch: func.providerBranch,
-            providerSilentMode: func.providerSilentMode,
-            providerRootDirectory: func.providerRootDirectory,
-            specification: func.specification,
-            ...(func.predeployCommands
-                ? { predeployCommands: func.predeployCommands }
-                : {}),
-            ...(func.deployDir ? { deployDir: func.deployDir } : {}),
-        })), null, 4)}
-  };
-  
-  export default appwriteConfig;
-  `;
-        fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
-        // Determine output directory based on API mode/version detection
-        const outputDir = this.getVersionAwareCollectionsDirectory();
-        const collectionsFolderPath = path.join(this.appwriteFolderPath, outputDir);
-        if (!fs.existsSync(collectionsFolderPath)) {
-            fs.mkdirSync(collectionsFolderPath, { recursive: true });
-        }
-        collections?.forEach((collection) => {
-            const { databaseId, ...collectionWithoutDbId } = collection; // Destructure to exclude databaseId
-            const collectionFilePath = path.join(collectionsFolderPath, `${collection.name}.ts`);
-            // Determine if we're in tables mode for terminology
-            const isTablesMode = outputDir === "tables";
-            const securityField = isTablesMode ? "rowSecurity" : "documentSecurity";
-            const collectionContent = `import { type CollectionCreate } from "@njdamstra/appwrite-utils";
-
-  const ${collection.name}Config: Partial<CollectionCreate> = {
-    name: "${collection.name}",
-    $id: "${collection.$id}",
-    enabled: ${collection.enabled},
-    ${securityField}: ${collection.documentSecurity},
-    $permissions: [
-      ${collection.$permissions
-                .map((permission) => `{ permission: "${permission.permission}", target: "${permission.target}" }`)
-                .join(",\n    ")}
-    ],
-    attributes: [
-      ${collection.attributes
-                .map((attr) => {
-                return `{ ${Object.entries(attr)
-                    .map(([key, value]) => {
-                    // Handle table vs collection terminology for related fields
-                    let outputKey = key;
-                    let outputValue = value;
-                    if (isTablesMode) {
-                        // Convert collection terminology to table terminology
-                        if (key === "relatedCollection") {
-                            outputKey = "relatedTable";
-                        }
-                    }
-                    // Check the type of the value and format it accordingly
-                    if (typeof outputValue === "string") {
-                        // If the value is a string, wrap it in quotes
-                        return `${outputKey}: "${outputValue.replace(/"/g, '\\"')}"`; // Escape existing quotes in the string
-                    }
-                    else if (Array.isArray(outputValue)) {
-                        // If the value is an array, join it with commas
-                        if (outputValue.length > 0) {
-                            return `${outputKey}: [${outputValue
-                                .map((item) => `"${item}"`)
-                                .join(", ")}]`;
-                        }
-                        else {
-                            return `${outputKey}: []`;
-                        }
-                    }
-                    else {
-                        // If the value is not a string (e.g., boolean or number), output it directly
-                        return `${outputKey}: ${outputValue}`;
-                    }
-                })
-                    .join(", ")} }`;
-            })
-                .join(",\n    ")}
-    ],
-    indexes: [
-      ${(collection.indexes?.map((index) => {
-                // Use appropriate terminology for index attributes/columns
-                const indexField = isTablesMode ? "columns" : "attributes";
-                const formattedAttributes = index.attributes.map((attr) => `"${attr}"`).join(", ") ?? "";
-                return `{ key: "${index.key}", type: "${index.type}", ${indexField}: [${formattedAttributes}], orders: [${index.orders
-                    ?.filter((order) => order !== null)
-                    .map((order) => `"${order}"`)
-                    .join(", ") ?? ""}] }`;
-            }) ?? []).join(",\n    ")}
-    ]
-  };
-
-  export default ${collection.name}Config;
-  `;
-            fs.writeFileSync(collectionFilePath, collectionContent, {
-                encoding: "utf-8",
-            });
-            MessageFormatter.success(`${outputDir === "tables" ? "Table" : "Collection"} schema written to ${collectionFilePath}`, { prefix: "Schema" });
-        });
-    }
-    /**
-     * Determines the appropriate directory for collections/tables based on API mode
-     * Uses version detection or config hints to choose between 'collections' and 'tables'
-     */
-    getVersionAwareCollectionsDirectory() {
-        return getVersionAwareDirectory(this.config, this.appwriteFolderPath);
-    }
-    /**
-     * Get directory for a specific API mode (legacy or tablesdb)
-     * @param apiMode - The API mode to get directory for
-     * @returns The directory name for the specified API mode
-     */
-    getDirectoryForApiMode(apiMode) {
-        return resolveDirectoryForApiMode(this.config, apiMode, this.appwriteFolderPath);
-    }
-    /**
-     * Get both directory paths for dual API support
-     * @returns Object with both collectionsDirectory and tablesDirectory paths
-     */
-    getDualDirectoryConfiguration() {
-        return getDualDirectoryPaths(this.config);
-    }
-    async updateConfig(config, isYamlConfig = false) {
-        if (isYamlConfig) {
-            // User has YAML config - find the config file and update it + generate individual collection files
-            const { findYamlConfig } = await import("../config/yamlConfig.js");
-            const yamlConfigPath = findYamlConfig(this.appwriteFolderPath);
-            if (yamlConfigPath) {
-                await this.updateYamlConfig(config, yamlConfigPath);
-            }
-            else {
-                MessageFormatter.warning("YAML config expected but not found, falling back to TypeScript", { prefix: "Schema" });
-                this.updateTypeScriptConfig(config);
-            }
-        }
-        else {
-            // User has TypeScript config - update the TS file
-            this.updateTypeScriptConfig(config);
-        }
-    }
-    async updateYamlConfig(config, yamlConfigPath) {
-        try {
-            const { writeYamlConfig } = await import("../config/yamlConfig.js");
-            // Write the main YAML config (without collections)
-            await writeYamlConfig(yamlConfigPath, config);
-            // Generate individual collection YAML files
-            this.updateYamlCollections();
-            MessageFormatter.success("Updated YAML configuration and collection files", { prefix: "Schema" });
-        }
-        catch (error) {
-            MessageFormatter.error("Error updating YAML config", error, { prefix: "Schema" });
-            throw error;
-        }
-    }
-    updateTypeScriptConfig(config) {
-        const configPath = path.join(this.appwriteFolderPath, "appwriteConfig.ts");
-        const configContent = `import { type AppwriteConfig } from "@njdamstra/appwrite-utils";
-
-const appwriteConfig: AppwriteConfig = {
-  appwriteEndpoint: "${config.appwriteEndpoint}",
-  appwriteProject: "${config.appwriteProject}",
-  appwriteKey: "${config.appwriteKey}",
-  enableBackups: ${config.enableBackups},
-  backupInterval: ${config.backupInterval},
-  backupRetention: ${config.backupRetention},
-  enableBackupCleanup: ${config.enableBackupCleanup},
-  enableMockData: ${config.enableMockData},
-  documentBucketId: "${config.documentBucketId}",
-  usersCollectionName: "${config.usersCollectionName}",
-  databases: ${JSON.stringify(config.databases, null, 4)},
-  buckets: ${JSON.stringify(config.buckets, null, 4)},
-  functions: ${JSON.stringify(config.functions?.map((func) => ({
-            $id: func.$id || ulid(),
-            name: func.name,
-            runtime: func.runtime,
-            dirPath: func.dirPath || "functions/" + func.name,
-            entrypoint: func.entrypoint || "src/index.ts",
-            execute: func.execute || [],
-            events: func.events || [],
-            schedule: func.schedule || "",
-            timeout: func.timeout || 15,
-            enabled: func.enabled !== false,
-            logging: func.logging !== false,
-            commands: func.commands || "npm install",
-            scopes: func.scopes || [],
-            installationId: func.installationId,
-            providerRepositoryId: func.providerRepositoryId,
-            providerBranch: func.providerBranch,
-            providerSilentMode: func.providerSilentMode,
-            providerRootDirectory: func.providerRootDirectory,
-            specification: func.specification,
-        })), null, 4)},
-  collections: ${JSON.stringify(config.collections, null, 4)}
-};
-
-export default appwriteConfig;
-`;
-        fs.writeFileSync(configPath, configContent, { encoding: "utf-8" });
-        MessageFormatter.success("Updated TypeScript configuration file", { prefix: "Schema" });
-    }
-    extractRelationships() {
-        this.relationshipMap = extractTwoWayRelationships(this.config);
-    }
-    async generateSchemas(options = {}) {
-        const { format = "both", verbose = false, outputDir } = options;
-        if (!this.config.collections) {
-            return;
-        }
-        // Create schemas directory using config setting
-        const configuredDir = outputDir || this.config.schemaConfig?.outputDirectory || "schemas";
-        let schemasPath;
-        if (path.isAbsolute(configuredDir)) {
-            schemasPath = configuredDir;
-        }
-        else if (configuredDir === "schemas") {
-            schemasPath = resolveSchemaDir(this.appwriteFolderPath);
-        }
-        else {
-            schemasPath = path.join(this.appwriteFolderPath, configuredDir);
-        }
-        if (!fs.existsSync(schemasPath)) {
-            fs.mkdirSync(schemasPath, { recursive: true });
-        }
-        // Generate Zod schemas (TypeScript)
-        if (format === "zod" || format === "both" || format === "all") {
-            this.config.collections.forEach((collection) => {
-                const schemaString = this.createSchemaStringV4(collection.name, collection.attributes || []);
-                const camelCaseName = toCamelCase(collection.name);
-                const schemaPath = path.join(schemasPath, `${camelCaseName}.ts`);
-                fs.writeFileSync(schemaPath, schemaString, { encoding: "utf-8" });
-                if (verbose) {
-                    MessageFormatter.success(`Zod schema written to ${schemaPath}`, { prefix: "Schema" });
-                }
-            });
-        }
-        // Generate JSON schemas (all at once)
-        if (format === "json" || format === "both" || format === "all") {
-            const jsonSchemaGenerator = new JsonSchemaGenerator(this.config, this.appwriteFolderPath);
-            jsonSchemaGenerator.generateJsonSchemas({
-                outputFormat: format === "json" ? "json" : "both",
-                outputDirectory: configuredDir,
-                verbose: verbose
-            });
-        }
-        // Generate Python Pydantic models
-        if (format === "pydantic" || format === "all") {
-            const mod = await import("./pydanticModelGenerator.js");
-            const pgen = new mod.PydanticModelGenerator(this.config, this.appwriteFolderPath);
-            pgen.generatePydanticModels({ baseOutputDirectory: schemasPath, verbose });
-        }
-        if (verbose) {
-            MessageFormatter.success(`Schema generation completed (format: ${format})`, { prefix: "Schema" });
-        }
-    }
-    // Zod v4 recursive getter-based schemas
-    createSchemaStringV4 = (name, attributes) => {
-        const pascalName = toPascalCase(name);
-        let imports = `import { z } from "zod";\n`;
-        // Use the relationshipMap to find related collections
-        const relationshipDetails = this.relationshipMap.get(name) || [];
-        let relatedCollections = relationshipDetails
-            .filter((detail, index, self) => {
-            const uniqueKey = `${detail.parentCollection}-${detail.childCollection}-${detail.parentKey}-${detail.childKey}`;
-            return (index ===
-                self.findIndex((obj) => `${obj.parentCollection}-${obj.childCollection}-${obj.parentKey}-${obj.childKey}` ===
-                    uniqueKey));
-        })
-            .map((detail) => {
-            const relatedCollectionName = detail.isChild
-                ? detail.parentCollection
-                : detail.childCollection;
-            const key = detail.isChild ? detail.childKey : detail.parentKey;
-            const isArray = detail.isArray ? "array" : "";
-            return [relatedCollectionName, key, isArray];
-        });
-        // Include one-way relationship attributes directly (no twoWayKey)
-        const oneWayRels = [];
-        for (const attr of attributes) {
-            if (attr.type === "relationship" && attr.relatedCollection) {
-                const relatedName = this.resolveCollectionName(attr.relatedCollection);
-                const isArray = attr.relationType === "oneToMany" || attr.relationType === "manyToMany"
-                    ? "array"
-                    : "";
-                oneWayRels.push([relatedName, attr.key, isArray]);
-            }
-        }
-        // Merge and dedupe (by relatedName+key)
-        relatedCollections = [...relatedCollections, ...oneWayRels].filter((item, idx, self) => idx === self.findIndex((o) => `${o[0]}::${o[1]}` === `${item[0]}::${item[1]}`));
-        const hasRelationships = relatedCollections.length > 0;
-        // Build imports for related collections
-        if (hasRelationships) {
-            const importLines = relatedCollections.map((rel) => {
-                const relatedPascalName = toPascalCase(rel[0]);
-                const relatedCamelName = toCamelCase(rel[0]);
-                return `import { ${relatedPascalName}Schema } from "./${relatedCamelName}";`;
-            });
-            const unique = Array.from(new Set(importLines));
-            imports += unique.join("\n") + (unique.length ? "\n" : "");
-        }
-        let schemaString = `${imports}\n`;
-        // Single object schema with recursive getters (Zod v4)
-        schemaString += `export const ${pascalName}Schema = z.object({\n`;
-        schemaString += `  $id: z.string(),\n`;
-        schemaString += `  $createdAt: z.string(),\n`;
-        schemaString += `  $updatedAt: z.string(),\n`;
-        schemaString += `  $permissions: z.array(z.string()),\n`;
-        for (const attribute of attributes) {
-            if (attribute.type === "relationship")
-                continue;
-            schemaString += `  ${attribute.key}: ${this.typeToZod(attribute)},\n`;
-        }
-        // Add recursive getters for relationships (respect required flag)
-        relatedCollections.forEach((rel) => {
-            const relatedPascalName = toPascalCase(rel[0]);
-            const isArray = rel[2] === "array";
-            const key = String(rel[1]);
-            const attrMeta = attributes.find(a => a.key === key && a.type === "relationship");
-            const isRequired = !!attrMeta?.required;
-            let getterBody = "";
-            if (isArray) {
-                getterBody = isRequired
-                    ? `${relatedPascalName}Schema.array()`
-                    : `${relatedPascalName}Schema.array().nullish()`;
-            }
-            else {
-                getterBody = isRequired
-                    ? `${relatedPascalName}Schema`
-                    : `${relatedPascalName}Schema.nullish()`;
-            }
-            schemaString += `  get ${key}(){\n    return ${getterBody}\n  },\n`;
-        });
-        schemaString += `});\n\n`;
-        schemaString += `export type ${pascalName} = z.infer<typeof ${pascalName}Schema>;\n\n`;
-        return schemaString;
-    };
-    typeToZod = (attribute) => {
-        let baseSchemaCode = "";
-        const finalAttribute = (attribute.type === "string" &&
-            attribute.format &&
-            attribute.format === "enum" &&
-            attribute.type === "string"
-            ? { ...attribute, type: attribute.format }
-            : attribute);
-        switch (finalAttribute.type) {
-            case "string":
-                baseSchemaCode = "z.string()";
-                if (finalAttribute.size) {
-                    baseSchemaCode += `.max(${finalAttribute.size}, "Maximum length of ${finalAttribute.size} characters exceeded")`;
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!attribute.required && !attribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "integer":
-                baseSchemaCode = "z.number().int()";
-                if (finalAttribute.min !== undefined) {
-                    if (BigInt(finalAttribute.min) === BigInt(-9223372036854776000)) {
-                        finalAttribute.min = undefined;
-                    }
-                    else {
-                        baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
-                    }
-                }
-                if (finalAttribute.max !== undefined) {
-                    if (BigInt(finalAttribute.max) === BigInt(9223372036854776000)) {
-                        finalAttribute.max = undefined;
-                    }
-                    else {
-                        baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
-                    }
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "double":
-            case "float": // Backward compatibility
-                baseSchemaCode = "z.number()";
-                if (finalAttribute.min !== undefined) {
-                    baseSchemaCode += `.min(${finalAttribute.min}, "Minimum value of ${finalAttribute.min} not met")`;
-                }
-                if (finalAttribute.max !== undefined) {
-                    baseSchemaCode += `.max(${finalAttribute.max}, "Maximum value of ${finalAttribute.max} exceeded")`;
-                }
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "boolean":
-                baseSchemaCode = "z.boolean()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(${finalAttribute.xdefault})`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "datetime":
-                baseSchemaCode = "z.date()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default(new Date("${finalAttribute.xdefault}"))`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "email":
-                baseSchemaCode = "z.string().email()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "ip":
-                baseSchemaCode = "z.string()"; // Add custom validation as needed
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "url":
-                baseSchemaCode = "z.string().url()";
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!finalAttribute.required && !finalAttribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "enum":
-                baseSchemaCode = `z.enum([${finalAttribute.elements
-                    .map((element) => `"${element}"`)
-                    .join(", ")}])`;
-                if (finalAttribute.xdefault !== undefined) {
-                    baseSchemaCode += `.default("${finalAttribute.xdefault}")`;
-                }
-                if (!attribute.required && !attribute.array) {
-                    baseSchemaCode += ".nullish()";
-                }
-                break;
-            case "relationship":
-                break;
-            default:
-                baseSchemaCode = "z.any()";
-        }
-        // Handle arrays
-        if (attribute.array) {
-            baseSchemaCode = `z.array(${baseSchemaCode})`;
-        }
-        if (attribute.array && !attribute.required) {
-            baseSchemaCode += ".nullish()";
-        }
-        return baseSchemaCode;
-    };
-}

package/dist/utils/ClientFactory.d.ts

@@ -1,87 +0,0 @@
-import { Client } from "node-appwrite";
-import type { AppwriteConfig } from "@njdamstra/appwrite-utils";
-import type { DatabaseAdapter } from "../adapters/DatabaseAdapter.js";
-/**
- * Factory for creating authenticated Appwrite clients and database adapters.
- *
- * This factory provides a clean separation of concerns by taking pre-configured
- * AppwriteConfig objects (with authentication already resolved by ConfigManager)
- * and creating the necessary client and adapter instances.
- *
- * Key features:
- * - Takes pre-authenticated config from ConfigManager
- * - Creates client with appropriate authentication method
- * - Creates adapter with automatic version detection
- * - Leverages AdapterFactory's internal caching for performance
- *
- * @example
- * ```typescript
- * const configManager = ConfigManager.getInstance();
- * const config = await configManager.loadConfig();
- *
- * // Config already has session or API key resolved
- * const { client, adapter } = await ClientFactory.createFromConfig(config);
- * ```
- */
-export declare class ClientFactory {
-    /**
-     * Create authenticated client and database adapter from configuration.
-     *
-     * This method expects the config to have authentication already resolved:
-     * - Either `sessionCookie` is set (from ConfigManager's session loading)
-     * - Or `appwriteKey` is set (from config file or CLI overrides)
-     *
-     * The ConfigManager handles all session discovery and authentication priority,
-     * so this factory simply applies the resolved authentication to the client.
-     *
-     * @param config - AppwriteConfig with resolved authentication
-     * @returns Object containing authenticated client and database adapter
-     * @throws Error if no authentication method is available in config
-     *
-     * @example
-     * ```typescript
-     * const config = await ConfigManager.getInstance().loadConfig();
-     * const { client, adapter } = await ClientFactory.createFromConfig(config);
-     *
-     * // Client is now authenticated and ready to use
-     * const databases = new Databases(client);
-     * const collections = await adapter.listCollections(databaseId);
-     * ```
-     */
-    static createFromConfig(config: AppwriteConfig): Promise<{
-        client: Client;
-        adapter: DatabaseAdapter;
-    }>;
-    /**
-     * Create client and adapter from individual parameters.
-     *
-     * This is a lower-level method for cases where you don't have a full
-     * AppwriteConfig object. For most use cases, prefer createFromConfig().
-     *
-     * @param endpoint - Appwrite endpoint URL
-     * @param project - Appwrite project ID
-     * @param options - Authentication and API mode options
-     * @returns Object containing authenticated client and database adapter
-     * @throws Error if no authentication method is provided
-     *
-     * @example
-     * ```typescript
-     * const { client, adapter } = await ClientFactory.create(
-     *   "https://cloud.appwrite.io/v1",
-     *   "my-project-id",
-     *   {
-     *     apiKey: "my-api-key",
-     *     apiMode: "auto"
-     *   }
-     * );
-     * ```
-     */
-    static create(endpoint: string, project: string, options?: {
-        apiKey?: string;
-        sessionCookie?: string;
-        apiMode?: "auto" | "legacy" | "tablesdb";
-    }): Promise<{
-        client: Client;
-        adapter: DatabaseAdapter;
-    }>;
-}