/**
 * Schema Manager
 *
 * Manages database schema operations by generating and applying migrations.
 * All schema changes are tracked through migrations for:
 * - Traceability: Every change is recorded
 * - Reversibility: All changes can be rolled back
 * - Environment consistency: Same migrations run across all environments
 * - Platform independence: Migrations work across all database types
 */
import { IMigration, IMigrationOperation, IFieldDefinition, ICreateCollectionMigration, ICreateIndexMigration, IConstraintDefinition, IIndexFieldDefinition, IMigrationResult, IRawOperationMigration } from '../types/migration.interface';
import { ITableSchema, IIndexInfo } from '../types/schema.interface';
import { BaseAdapter } from '../adapters/base.adapter';
import { MigrationEngine } from '../migrations/migration-engine';
/**
 * Options for schema operations
 */
export interface ISchemaOperationOptions {
    /** Auto-apply the migration immediately */
    autoApply?: boolean;
    /** User/system applying the change */
    appliedBy?: string;
    /** Custom migration tag (auto-generated if not provided) */
    migrationTag?: string;
    /** Migration description */
    description?: string;
}
/**
 * Result of a schema operation
 */
export interface ISchemaOperationResult {
    /** Generated migration */
    migration: IMigration;
    /** Result if auto-applied */
    result?: IMigrationResult;
}
/**
 * Schema Manager for database schema operations
 * Generates migrations for all schema changes
 */
export declare class SchemaManager {
    private adapter;
    private migrationEngine;
    private databaseType;
    private pendingMigrations;
    constructor(adapter: BaseAdapter);
    /**
     * Create a new collection/table
     * Generates a migration and optionally applies it
     */
    createCollection(name: string, fields: IFieldDefinition[], options?: ISchemaOperationOptions & {
        ifNotExists?: boolean;
        indexes?: Array<{
            name: string;
            fields: IIndexFieldDefinition[];
            unique?: boolean;
        }>;
        sqlOptions?: ICreateCollectionMigration['sqlOptions'];
        mongoOptions?: ICreateCollectionMigration['mongoOptions'];
        dynamoOptions?: ICreateCollectionMigration['dynamoOptions'];
        cassandraOptions?: ICreateCollectionMigration['cassandraOptions'];
    }): Promise<ISchemaOperationResult>;
    /**
     * Drop a collection/table
     */
    dropCollection(name: string, options?: ISchemaOperationOptions & {
        ifExists?: boolean;
        cascade?: boolean;
        /** Original definition for rollback (required for reversible migration) */
        originalDefinition?: {
            fields: IFieldDefinition[];
            indexes?: Array<{
                name: string;
                fields: IIndexFieldDefinition[];
                unique?: boolean;
            }>;
        };
    }): Promise<ISchemaOperationResult>;
    /**
     * Rename a collection/table
     */
    renameCollection(oldName: string, newName: string, options?: ISchemaOperationOptions): Promise<ISchemaOperationResult>;
    /**
     * Add a field/column to a collection
     */
    addField(collection: string, field: IFieldDefinition, options?: ISchemaOperationOptions): Promise<ISchemaOperationResult>;
    /**
     * Drop a field/column from a collection
     */
    dropField(collection: string, fieldName: string, options?: ISchemaOperationOptions & {
        cascade?: boolean;
        /** Original field definition for rollback */
        originalField?: IFieldDefinition;
    }): Promise<ISchemaOperationResult>;
    /**
     * Rename a field/column
     */
    renameField(collection: string, oldName: string, newName: string, options?: ISchemaOperationOptions): Promise<ISchemaOperationResult>;
    /**
     * Modify a field/column definition
     */
    modifyField(collection: string, fieldName: string, changes: Partial<IFieldDefinition>, options?: ISchemaOperationOptions & {
        /** Original field definition for rollback */
        originalField?: Partial<IFieldDefinition>;
    }): Promise<ISchemaOperationResult>;
    /**
     * Create an index
     */
    createIndex(collection: string, indexName: string, fields: IIndexFieldDefinition[], options?: ISchemaOperationOptions & {
        unique?: boolean;
        sparse?: boolean;
        ifNotExists?: boolean;
        sqlOptions?: ICreateIndexMigration['sqlOptions'];
        mongoOptions?: ICreateIndexMigration['mongoOptions'];
        cassandraOptions?: ICreateIndexMigration['cassandraOptions'];
    }): Promise<ISchemaOperationResult>;
    /**
     * Drop an index
     */
    dropIndex(collection: string, indexName: string, options?: ISchemaOperationOptions & {
        ifExists?: boolean;
        concurrent?: boolean;
        /** Original index definition for rollback */
        originalIndex?: {
            fields: IIndexFieldDefinition[];
            unique?: boolean;
        };
    }): Promise<ISchemaOperationResult>;
    /**
     * Add a constraint (SQL databases only)
     */
    addConstraint(collection: string, constraint: IConstraintDefinition, options?: ISchemaOperationOptions): Promise<ISchemaOperationResult>;
    /**
     * Drop a constraint (SQL databases only)
     */
    dropConstraint(collection: string, constraintName: string, options?: ISchemaOperationOptions & {
        cascade?: boolean;
        /** Original constraint for rollback */
        originalConstraint?: IConstraintDefinition;
    }): Promise<ISchemaOperationResult>;
    /**
     * Create a migration with multiple operations
     */
    createMigration(name: string, upOperations: IMigrationOperation[], downOperations: IMigrationOperation[], options?: {
        tag?: string;
        description?: string;
        dependencies?: string[];
    }): IMigration;
    /**
     * Add a migration to the pending queue
     */
    queueMigration(migration: IMigration): void;
    /**
     * Apply all pending migrations
     */
    applyPendingMigrations(appliedBy?: string): Promise<Map<string, IMigrationResult>>;
    /**
     * Get pending migrations
     */
    getPendingMigrations(): IMigration[];
    /**
     * Clear pending migrations without applying
     */
    clearPendingMigrations(): void;
    /**
     * Check if a collection/table exists
     */
    collectionExists(name: string): Promise<boolean>;
    /**
     * List all collections/tables
     */
    listCollections(_schema?: string): Promise<string[]>;
    /**
     * Get collection/table schema information
     */
    getCollectionSchema(name: string): Promise<ITableSchema>;
    /**
     * List indexes on a collection
     */
    listIndexes(collection: string): Promise<IIndexInfo[]>;
    /**
     * Get the migration engine for direct access
     */
    getMigrationEngine(): MigrationEngine;
    /**
     * Apply a migration directly
     */
    applyMigration(migration: IMigration, appliedBy?: string): Promise<IMigrationResult>;
    /**
     * Rollback migrations
     */
    rollback(migrations: IMigration[], count?: number): Promise<Map<string, IMigrationResult>>;
    private handleMigration;
    private generateMigrationTag;
}
/**
 * Migration Builder for fluent migration creation
 */
export declare class MigrationBuilder {
    private name;
    private tag?;
    private description?;
    private upOperations;
    private downOperations;
    private deps;
    /**
     * Set migration name
     */
    setName(name: string): this;
    /**
     * Set migration tag
     */
    setTag(tag: string): this;
    /**
     * Set migration description
     */
    setDescription(description: string): this;
    /**
     * Add dependency
     */
    dependsOn(migrationTag: string): this;
    /**
     * Add create collection operation
     */
    createCollection(name: string, fields: IFieldDefinition[], options?: Omit<ICreateCollectionMigration, 'type' | 'name' | 'fields'>): this;
    /**
     * Add drop collection operation
     */
    dropCollection(name: string, originalFields?: IFieldDefinition[]): this;
    /**
     * Add field operation
     */
    addField(collection: string, field: IFieldDefinition): this;
    /**
     * Drop field operation
     */
    dropField(collection: string, fieldName: string, originalField?: IFieldDefinition): this;
    /**
     * Add index operation
     */
    createIndex(collection: string, name: string, fields: IIndexFieldDefinition[], options?: {
        unique?: boolean;
        sparse?: boolean;
    }): this;
    /**
     * Add raw operation
     */
    raw(upOperation: IRawOperationMigration, downOperation?: IRawOperationMigration): this;
    /**
     * Build the migration
     */
    build(): IMigration;
    private generateTag;
}
/**
 * Create a new migration builder
 */
export declare function migration(): MigrationBuilder;