appwrite-utils-cli 1.9.6 → 1.11.0

package/dist/utils/configMigration.js

@@ -1,261 +0,0 @@
-import { promises as fs } from "fs";
-import path from "path";
-import { existsSync } from "fs";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-import { ConfirmationDialogs } from "../shared/confirmationDialogs.js";
-import yaml from "js-yaml";
-export async function migrateConfig(workingDir) {
-    try {
-        // Look for appwriteConfig.ts files in the working directory and subdirectories
-        const configFiles = await findAppwriteConfigFiles(workingDir);
-        if (configFiles.length === 0) {
-            MessageFormatter.info("No appwriteConfig.ts files found to migrate", { prefix: "Migration" });
-            return;
-        }
-        MessageFormatter.info(`Found ${configFiles.length} appwriteConfig.ts file(s) to migrate`, { prefix: "Migration" });
-        for (const configFile of configFiles) {
-            await migrateConfigFile(configFile, workingDir);
-        }
-        MessageFormatter.success("Migration completed successfully", { prefix: "Migration" });
-    }
-    catch (error) {
-        MessageFormatter.error("Migration failed", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-        throw error;
-    }
-}
-async function findAppwriteConfigFiles(dir) {
-    const configFiles = [];
-    const checkDir = async (currentDir) => {
-        try {
-            const entries = await fs.readdir(currentDir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(currentDir, entry.name);
-                if (entry.isDirectory() && !entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                    await checkDir(fullPath);
-                }
-                else if (entry.isFile() && entry.name === 'appwriteConfig.ts') {
-                    configFiles.push(fullPath);
-                }
-            }
-        }
-        catch (error) {
-            // Ignore directory access errors
-        }
-    };
-    await checkDir(dir);
-    return configFiles;
-}
-async function migrateConfigFile(configFilePath, workingDir) {
-    const configDir = path.dirname(configFilePath);
-    const appwriteDir = path.join(path.dirname(configDir), '.appwrite');
-    MessageFormatter.info(`Migrating ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
-    // Check if .appwrite directory already exists
-    if (existsSync(appwriteDir)) {
-        const shouldOverwrite = await ConfirmationDialogs.confirmOverwrite(`.appwrite directory already exists at ${path.relative(workingDir, appwriteDir)}`);
-        if (!shouldOverwrite) {
-            MessageFormatter.info("Skipping migration for this config", { prefix: "Migration" });
-            return;
-        }
-    }
-    // Load and parse the TypeScript config
-    const config = await parseTypeScriptConfig(configFilePath);
-    // Create .appwrite directory
-    await fs.mkdir(appwriteDir, { recursive: true });
-    // Convert config to YAML and save
-    const yamlConfig = convertToYAMLConfig(config);
-    const yamlContent = yaml.dump(yamlConfig, {
-        indent: 2,
-        lineWidth: 120,
-        noRefs: true
-    });
-    await fs.writeFile(path.join(appwriteDir, 'config.yaml'), yamlContent);
-    // Copy all directories except collections and schemas (we handle collections separately, skip schemas entirely)
-    const entries = await fs.readdir(configDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (entry.isDirectory() && entry.name !== 'collections' && entry.name !== 'schemas') {
-            const sourcePath = path.join(configDir, entry.name);
-            const targetPath = path.join(appwriteDir, entry.name);
-            await fs.cp(sourcePath, targetPath, { recursive: true });
-            MessageFormatter.info(`Copied ${entry.name}/ to .appwrite/${entry.name}/`, { prefix: "Migration" });
-        }
-    }
-    // Convert TypeScript collections to YAML collections
-    const collectionsPath = path.join(configDir, 'collections');
-    if (existsSync(collectionsPath)) {
-        const targetCollectionsPath = path.join(appwriteDir, 'collections');
-        await fs.mkdir(targetCollectionsPath, { recursive: true });
-        const collectionFiles = await fs.readdir(collectionsPath);
-        for (const file of collectionFiles) {
-            if (file.endsWith('.ts')) {
-                await convertCollectionToYaml(path.join(collectionsPath, file), targetCollectionsPath);
-            }
-        }
-        MessageFormatter.info(`Converted TypeScript collections to YAML in .appwrite/collections/`, { prefix: "Migration" });
-    }
-    // Keep original config file in place (no backup needed since we're not deleting it)
-    MessageFormatter.success(`Migration completed for ${path.relative(workingDir, configFilePath)}`, { prefix: "Migration" });
-}
-async function parseTypeScriptConfig(configFilePath) {
-    try {
-        // Use tsx to import the TypeScript config file directly
-        const { register } = await import("tsx/esm/api");
-        const { pathToFileURL } = await import("node:url");
-        const unregister = register();
-        try {
-            const configUrl = pathToFileURL(configFilePath).href;
-            const configModule = await import(configUrl);
-            const config = configModule.default?.default || configModule.default || configModule;
-            if (!config) {
-                throw new Error("Failed to load config from TypeScript file");
-            }
-            return config;
-        }
-        finally {
-            unregister();
-        }
-    }
-    catch (error) {
-        MessageFormatter.error("Could not load TypeScript config", error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-        throw new Error('Failed to load TypeScript configuration file. Please ensure it exports a valid config object.');
-    }
-}
-function convertToYAMLConfig(config) {
-    // Convert the config to the nested YAML structure
-    const yamlConfig = {
-        appwrite: {
-            endpoint: config.appwriteEndpoint,
-            project: config.appwriteProject,
-            key: config.appwriteKey
-        },
-        logging: {
-            enabled: config.logging?.enabled ?? false,
-            level: config.logging?.level ?? "info",
-            console: config.logging?.console ?? false,
-            logDirectory: "./logs"
-        },
-        backups: {
-            enabled: config.enableBackups ?? false,
-            interval: config.backupInterval ?? 3600,
-            retention: config.backupRetention ?? 30,
-            cleanup: config.enableBackupCleanup ?? false
-        },
-        data: {
-            enableMockData: config.enableMockData ?? false,
-            documentBucketId: config.documentBucketId ?? "documents",
-            usersCollectionName: config.usersCollectionName ?? "Users",
-            importDirectory: "importData"
-        },
-        schemas: {
-            outputDirectory: "schemas",
-            yamlSchemaDirectory: ".yaml_schemas"
-        },
-        migrations: {
-            enabled: true
-        },
-        databases: (config.databases || []).map(db => ({
-            id: db.$id,
-            name: db.name,
-            collections: [] // Collections will be handled separately
-        })),
-        buckets: (config.buckets || []).map(bucket => ({
-            id: bucket.$id,
-            name: bucket.name,
-            permissions: bucket.$permissions?.map((p) => ({
-                permission: p.permission,
-                target: p.target
-            })) || [],
-            fileSecurity: bucket.fileSecurity ?? false,
-            enabled: bucket.enabled ?? true,
-            maximumFileSize: bucket.maximumFileSize ?? 30000000,
-            allowedFileExtensions: bucket.allowedFileExtensions || [],
-            compression: bucket.compression || "gzip",
-            encryption: bucket.encryption ?? false,
-            antivirus: bucket.antivirus ?? false
-        })),
-        functions: (config.functions || []).map((func) => ({
-            id: func.$id,
-            name: func.name,
-            runtime: func.runtime,
-            execute: func.execute || [],
-            events: func.events || [],
-            schedule: func.schedule || "",
-            timeout: func.timeout ?? 15,
-            enabled: func.enabled ?? true,
-            logging: func.logging ?? false,
-            entrypoint: func.entrypoint || "src/main.js",
-            commands: func.commands || "",
-            scopes: func.scopes || [],
-            specification: func.specification || "s-1vcpu-512mb"
-        }))
-    };
-    return yamlConfig;
-}
-async function convertCollectionToYaml(tsFilePath, targetDir) {
-    try {
-        // Load the TypeScript collection using tsx
-        const { register } = await import("tsx/esm/api");
-        const { pathToFileURL } = await import("node:url");
-        const unregister = register();
-        try {
-            const configUrl = pathToFileURL(tsFilePath).href;
-            const collectionModule = await import(configUrl);
-            const collection = collectionModule.default?.default || collectionModule.default || collectionModule;
-            if (!collection) {
-                throw new Error("Failed to load collection from TypeScript file");
-            }
-            // Convert collection to YAML format
-            const yamlCollection = {
-                name: collection.name,
-                id: collection.$id,
-                documentSecurity: collection.documentSecurity ?? false,
-                enabled: collection.enabled ?? true,
-                permissions: (collection.permissions || collection.$permissions || []).map((p) => ({
-                    permission: p.permission,
-                    target: p.target
-                })),
-                attributes: (collection.attributes || []).map((attr) => ({
-                    key: attr.key,
-                    type: attr.type,
-                    size: attr.size,
-                    required: attr.required ?? false,
-                    array: attr.array,
-                    default: attr.xdefault || attr.default,
-                    min: attr.min,
-                    max: attr.max,
-                    elements: attr.elements,
-                    relatedCollection: attr.relatedCollection,
-                    relationType: attr.relationType,
-                    twoWay: attr.twoWay,
-                    twoWayKey: attr.twoWayKey,
-                    onDelete: attr.onDelete,
-                    side: attr.side
-                })),
-                indexes: (collection.indexes || []).map((idx) => ({
-                    key: idx.key,
-                    type: idx.type,
-                    attributes: idx.attributes,
-                    orders: idx.orders
-                })),
-                importDefs: collection.importDefs || []
-            };
-            // Remove undefined values
-            const cleanYamlCollection = JSON.parse(JSON.stringify(yamlCollection, (key, value) => value === undefined ? undefined : value));
-            // Write YAML file
-            const fileName = path.basename(tsFilePath, '.ts') + '.yaml';
-            const targetPath = path.join(targetDir, fileName);
-            const yamlContent = yaml.dump(cleanYamlCollection, {
-                indent: 2,
-                lineWidth: 120,
-                noRefs: true
-            });
-            await fs.writeFile(targetPath, yamlContent);
-            MessageFormatter.info(`Converted ${path.basename(tsFilePath)} to ${fileName}`, { prefix: "Migration" });
-        }
-        finally {
-            unregister();
-        }
-    }
-    catch (error) {
-        MessageFormatter.error(`Failed to convert collection ${path.basename(tsFilePath)}`, error instanceof Error ? error : new Error(String(error)), { prefix: "Migration" });
-    }
-}

package/dist/utils/constantsGenerator.d.ts

@@ -1,31 +0,0 @@
-import { type AppwriteConfig } from "appwrite-utils";
-export type SupportedLanguage = "typescript" | "javascript" | "python" | "php" | "dart" | "json" | "env";
-interface Constants {
-    databases: Record<string, string>;
-    collections: Record<string, string>;
-    buckets: Record<string, string>;
-    functions: Record<string, string>;
-}
-export declare class ConstantsGenerator {
-    private config;
-    private constants;
-    constructor(config: AppwriteConfig);
-    private extractConstants;
-    private toConstantName;
-    private toCamelCase;
-    private toSnakeCase;
-    generateTypeScript(constantsOverride?: Constants): string;
-    generateJavaScript(constantsOverride?: Constants): string;
-    generatePython(constantsOverride?: Constants): string;
-    generatePHP(constantsOverride?: Constants): string;
-    generateDart(constantsOverride?: Constants): string;
-    generateJSON(constantsOverride?: Constants): string;
-    generateEnv(constantsOverride?: Constants): string;
-    generateFiles(languages: SupportedLanguage[], outputDir: string, include?: {
-        databases?: boolean;
-        collections?: boolean;
-        buckets?: boolean;
-        functions?: boolean;
-    }): Promise<void>;
-}
-export {};

package/dist/utils/constantsGenerator.js

@@ -1,321 +0,0 @@
-import fs from "fs/promises";
-import path from "path";
-import {} from "appwrite-utils";
-import { MessageFormatter } from "../shared/messageFormatter.js";
-export class ConstantsGenerator {
-    config;
-    constants;
-    constructor(config) {
-        this.config = config;
-        this.constants = this.extractConstants();
-    }
-    extractConstants() {
-        const constants = {
-            databases: {},
-            collections: {},
-            buckets: {},
-            functions: {}
-        };
-        // Extract database IDs
-        this.config.databases?.forEach(db => {
-            if (db.$id) {
-                const key = this.toConstantName(db.name || db.$id);
-                constants.databases[key] = db.$id;
-            }
-        });
-        // Extract collection IDs
-        this.config.collections?.forEach(collection => {
-            if (collection.$id) {
-                const key = this.toConstantName(collection.name || collection.$id);
-                constants.collections[key] = collection.$id;
-            }
-        });
-        // Extract bucket IDs
-        this.config.buckets?.forEach(bucket => {
-            if (bucket.$id) {
-                const key = this.toConstantName(bucket.name || bucket.$id);
-                constants.buckets[key] = bucket.$id;
-            }
-        });
-        // Extract function IDs
-        this.config.functions?.forEach(func => {
-            if (func.$id) {
-                const key = this.toConstantName(func.name || func.$id);
-                constants.functions[key] = func.$id;
-            }
-        });
-        return constants;
-    }
-    toConstantName(name) {
-        return name
-            .replace(/[^a-zA-Z0-9]/g, '_')
-            .replace(/_+/g, '_')
-            .replace(/^_|_$/g, '')
-            .toUpperCase();
-    }
-    toCamelCase(name) {
-        return name
-            .toLowerCase()
-            .replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
-    }
-    toSnakeCase(name) {
-        return name.toLowerCase();
-    }
-    generateTypeScript(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-export const DATABASE_IDS = {
-${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-export const COLLECTION_IDS = {
-${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-export const BUCKET_IDS = {
-${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-export const FUNCTION_IDS = {
-${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-} as const;
-
-// Type helpers
-export type DatabaseId = typeof DATABASE_IDS[keyof typeof DATABASE_IDS];
-export type CollectionId = typeof COLLECTION_IDS[keyof typeof COLLECTION_IDS];
-export type BucketId = typeof BUCKET_IDS[keyof typeof BUCKET_IDS];
-export type FunctionId = typeof FUNCTION_IDS[keyof typeof FUNCTION_IDS];
-
-// Helper objects for runtime use
-export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
-export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
-export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
-export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
-`;
-    }
-    generateJavaScript(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-export const DATABASE_IDS = {
-${Object.entries(databases).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-export const COLLECTION_IDS = {
-${Object.entries(collections).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-export const BUCKET_IDS = {
-${Object.entries(buckets).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-export const FUNCTION_IDS = {
-${Object.entries(functions).map(([key, value]) => `  ${key}: "${value}"`).join(',\n')}
-};
-
-// Helper arrays for runtime use
-export const ALL_DATABASE_IDS = Object.values(DATABASE_IDS);
-export const ALL_COLLECTION_IDS = Object.values(COLLECTION_IDS);
-export const ALL_BUCKET_IDS = Object.values(BUCKET_IDS);
-export const ALL_FUNCTION_IDS = Object.values(FUNCTION_IDS);
-`;
-    }
-    generatePython(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `# Auto-generated Appwrite constants
-# Generated on ${new Date().toISOString()}
-
-class DatabaseIds:
-    """Database ID constants"""
-${Object.entries(databases).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-class CollectionIds:
-    """Collection ID constants"""
-${Object.entries(collections).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-class BucketIds:
-    """Bucket ID constants"""
-${Object.entries(buckets).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-class FunctionIds:
-    """Function ID constants"""
-${Object.entries(functions).map(([key, value]) => `    ${key} = "${value}"`).join('\n')}
-
-# Helper dictionaries for runtime use
-DATABASE_ID_MAP = {
-${Object.entries(databases).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-
-COLLECTION_ID_MAP = {
-${Object.entries(collections).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-
-BUCKET_ID_MAP = {
-${Object.entries(buckets).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-
-FUNCTION_ID_MAP = {
-${Object.entries(functions).map(([key, value]) => `    "${this.toSnakeCase(key)}": "${value}"`).join(',\n')}
-}
-`;
-    }
-    generatePHP(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `<?php
-// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-class AppwriteConstants {
-    
-    const DATABASE_IDS = [
-${Object.entries(databases).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    const COLLECTION_IDS = [
-${Object.entries(collections).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    const BUCKET_IDS = [
-${Object.entries(buckets).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    const FUNCTION_IDS = [
-${Object.entries(functions).map(([key, value]) => `        '${key}' => '${value}'`).join(',\n')}
-    ];
-    
-    /**
-     * Get all database IDs as array
-     */
-    public static function getAllDatabaseIds(): array {
-        return array_values(self::DATABASE_IDS);
-    }
-    
-    /**
-     * Get all collection IDs as array
-     */
-    public static function getAllCollectionIds(): array {
-        return array_values(self::COLLECTION_IDS);
-    }
-    
-    /**
-     * Get all bucket IDs as array
-     */
-    public static function getAllBucketIds(): array {
-        return array_values(self::BUCKET_IDS);
-    }
-    
-    /**
-     * Get all function IDs as array
-     */
-    public static function getAllFunctionIds(): array {
-        return array_values(self::FUNCTION_IDS);
-    }
-}
-`;
-    }
-    generateDart(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        return `// Auto-generated Appwrite constants
-// Generated on ${new Date().toISOString()}
-
-class AppwriteConstants {
-  
-  static const Map<String, String> databaseIds = {
-${Object.entries(databases).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  static const Map<String, String> collectionIds = {
-${Object.entries(collections).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  static const Map<String, String> bucketIds = {
-${Object.entries(buckets).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  static const Map<String, String> functionIds = {
-${Object.entries(functions).map(([key, value]) => `    '${this.toCamelCase(key)}': '${value}'`).join(',\n')}
-  };
-  
-  // Helper getters for individual IDs
-${Object.entries(databases).map(([key, value]) => `  static String get ${this.toCamelCase(key)}DatabaseId => '${value}';`).join('\n')}
-  
-${Object.entries(collections).map(([key, value]) => `  static String get ${this.toCamelCase(key)}CollectionId => '${value}';`).join('\n')}
-  
-${Object.entries(buckets).map(([key, value]) => `  static String get ${this.toCamelCase(key)}BucketId => '${value}';`).join('\n')}
-  
-${Object.entries(functions).map(([key, value]) => `  static String get ${this.toCamelCase(key)}FunctionId => '${value}';`).join('\n')}
-}
-`;
-    }
-    generateJSON(constantsOverride) {
-        const c = constantsOverride || this.constants;
-        return JSON.stringify({
-            meta: {
-                generated: new Date().toISOString(),
-                generator: "appwrite-utils-cli"
-            },
-            databases: c.databases,
-            collections: c.collections,
-            buckets: c.buckets,
-            functions: c.functions
-        }, null, 2);
-    }
-    generateEnv(constantsOverride) {
-        const { databases, collections, buckets, functions } = constantsOverride || this.constants;
-        const lines = [
-            "# Auto-generated Appwrite constants",
-            `# Generated on ${new Date().toISOString()}`,
-            "",
-            "# Database IDs",
-            ...Object.entries(databases).map(([key, value]) => `DATABASE_${key}=${value}`),
-            "",
-            "# Collection IDs",
-            ...Object.entries(collections).map(([key, value]) => `COLLECTION_${key}=${value}`),
-            "",
-            "# Bucket IDs",
-            ...Object.entries(buckets).map(([key, value]) => `BUCKET_${key}=${value}`),
-            "",
-            "# Function IDs",
-            ...Object.entries(functions).map(([key, value]) => `FUNCTION_${key}=${value}`)
-        ];
-        return lines.join('\n');
-    }
-    async generateFiles(languages, outputDir, include) {
-        await fs.mkdir(outputDir, { recursive: true });
-        const filterConstants = () => {
-            if (!include)
-                return this.constants;
-            return {
-                databases: include.databases === false ? {} : this.constants.databases,
-                collections: include.collections === false ? {} : this.constants.collections,
-                buckets: include.buckets === false ? {} : this.constants.buckets,
-                functions: include.functions === false ? {} : this.constants.functions,
-            };
-        };
-        const subset = filterConstants();
-        const generators = {
-            typescript: () => ({ content: this.generateTypeScript(subset), filename: "appwrite-constants.ts" }),
-            javascript: () => ({ content: this.generateJavaScript(subset), filename: "appwrite-constants.js" }),
-            python: () => ({ content: this.generatePython(subset), filename: "appwrite_constants.py" }),
-            php: () => ({ content: this.generatePHP(subset), filename: "AppwriteConstants.php" }),
-            dart: () => ({ content: this.generateDart(subset), filename: "appwrite_constants.dart" }),
-            json: () => ({ content: this.generateJSON(subset), filename: "appwrite-constants.json" }),
-            env: () => ({ content: this.generateEnv(subset), filename: ".env.appwrite" })
-        };
-        for (const language of languages) {
-            const generator = generators[language];
-            if (generator) {
-                const { content, filename } = generator();
-                const filePath = path.join(outputDir, filename);
-                await fs.writeFile(filePath, content, 'utf-8');
-                MessageFormatter.success(`Generated ${language} constants: ${filePath}`, { prefix: "Constants" });
-            }
-            else {
-                MessageFormatter.error(`Unsupported language: ${language}`, undefined, { prefix: "Constants" });
-            }
-        }
-    }
-}

package/dist/utils/dataConverters.d.ts

@@ -1,46 +0,0 @@
-import { type AttributeMappings } from "appwrite-utils";
-/**
- * Deeply converts all properties of an object (or array) to strings.
- * @param data The input data to convert.
- * @returns The data with all its properties converted to strings.
- */
-export declare const deepAnyToString: (data: any) => any;
-/**
- * Performs a deep conversion of all values in a nested structure to the specified type.
- * Uses a conversion function like anyToString, anyToNumber, etc.
- * @param data The data to convert.
- * @param convertFn The conversion function to apply.
- * @returns The converted data.
- */
-export declare const deepConvert: <T>(data: any, convertFn: (value: any) => T) => any;
-/**
- * Converts an entire object's properties to different types based on a provided schema.
- * @param obj The object to convert.
- * @param schema A mapping of object keys to conversion functions.
- * @returns The converted object.
- */
-export declare const convertObjectBySchema: (obj: Record<string, any>, schema: Record<string, (value: any) => any>) => Record<string, any>;
-/**
- * Converts the keys of an object based on a provided attributeMappings.
- * Each key in the object is checked against attributeMappings; if a matching entry is found,
- * the key is renamed to the targetKey specified in attributeMappings.
- *
- * @param obj The object to convert.
- * @param attributeMappings The attributeMappings defining how keys in the object should be converted.
- * @returns The converted object with keys renamed according to attributeMappings.
- */
-export declare const convertObjectByAttributeMappings: (obj: Record<string, any>, attributeMappings: AttributeMappings) => Record<string, any>;
-/**
- * Ensures data conversion without mutating the original input.
- * @param data The data to convert.
- * @param convertFn The conversion function to apply.
- * @returns The converted data.
- */
-export declare const immutableConvert: <T>(data: any, convertFn: (value: any) => T) => T;
-/**
- * Validates a string against a regular expression and returns the string if valid, or null.
- * @param value The string to validate.
- * @param pattern The regex pattern to validate against.
- * @returns The original string if valid, otherwise null.
- */
-export declare const validateString: (value: string, pattern: RegExp) => string | null;