@njdamstra/appwrite-utils-cli 1.8.9

package/dist/utils/configMigration.js

@@ -0,0 +1,261 @@
+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

@@ -0,0 +1,31 @@
+import { type AppwriteConfig } from "@njdamstra/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

@@ -0,0 +1,321 @@
+import fs from "fs/promises";
+import path from "path";
+import {} from "@njdamstra/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: "@njdamstra/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

@@ -0,0 +1,46 @@
+import { type AttributeMappings } from "@njdamstra/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;