/**
 * DuckLake Service - Lakehouse metadata layer for DuckDB
 * Provides ACID transactions, time travel, and versioning on top of Parquet files
 * Similar to Delta Lake but optimized for DuckDB
 */
import { DuckDBService } from '../duckdb/service.js';
import { z } from 'zod';
export declare const DuckLakeOptionsSchema: z.ZodObject<{
    format: z.ZodDefault<z.ZodEnum<{
        DELTA: "DELTA";
        ICEBERG: "ICEBERG";
    }>>;
    versioning: z.ZodDefault<z.ZodBoolean>;
    multiTenant: z.ZodDefault<z.ZodBoolean>;
    compressionType: z.ZodDefault<z.ZodEnum<{
        ZSTD: "ZSTD";
        SNAPPY: "SNAPPY";
        LZ4: "LZ4";
        GZIP: "GZIP";
        NONE: "NONE";
    }>>;
    enableTimeTravel: z.ZodDefault<z.ZodBoolean>;
    retentionDays: z.ZodDefault<z.ZodNumber>;
}, z.core.$strip>;
export type DuckLakeOptions = z.infer<typeof DuckLakeOptionsSchema>;
export declare const DeltaLogEntrySchema: z.ZodObject<{
    version: z.ZodNumber;
    timestamp: z.ZodDate;
    operation: z.ZodEnum<{
        CREATE: "CREATE";
        UPDATE: "UPDATE";
        DELETE: "DELETE";
        APPEND: "APPEND";
        MERGE: "MERGE";
        OPTIMIZE: "OPTIMIZE";
    }>;
    operationParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
    files: z.ZodArray<z.ZodObject<{
        path: z.ZodString;
        size: z.ZodNumber;
        modificationTime: z.ZodDate;
        dataChange: z.ZodBoolean;
        stats: z.ZodOptional<z.ZodObject<{
            numRecords: z.ZodNumber;
            minValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
            maxValues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
            nullCounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
        }, z.core.$strip>>;
    }, z.core.$strip>>;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
}, z.core.$strip>;
export type DeltaLogEntry = z.infer<typeof DeltaLogEntrySchema>;
export interface ChangeSet {
    additions: string[];
    deletions: string[];
    metadata?: Record<string, any>;
}
export declare class DuckLakeService {
    private duckdb;
    private catalogs;
    constructor(duckdb: DuckDBService);
    /**
     * Create a new DuckLake catalog
     * A catalog is a collection of tables managed by DuckLake
     */
    createCatalog(name: string, location: string, options?: Partial<DuckLakeOptions>): Promise<DuckLakeCatalog>;
    /**
     * Get an existing catalog
     */
    getCatalog(name: string): Promise<DuckLakeCatalog | undefined>;
    /**
     * List all available catalogs
     */
    listCatalogs(): Promise<string[]>;
}
/**
 * DuckLake Catalog - Manages a collection of tables with ACID properties
 */
export declare class DuckLakeCatalog {
    readonly name: string;
    readonly location: string;
    readonly options: DuckLakeOptions;
    private duckdb;
    constructor(name: string, location: string, options: DuckLakeOptions, duckdb: DuckDBService);
    /**
     * Create a managed table in the catalog
     */
    createTable(tableName: string, schema: string, partitionBy?: string[]): Promise<void>;
    /**
     * Time travel query - query data at a specific point in time
     */
    timeTravel(tableName: string, timestamp: Date | number): Promise<any[]>;
    /**
     * Get the current version of a table
     */
    getTableVersion(tableName: string): Promise<number>;
    /**
     * Commit a transaction with ACID guarantees
     */
    commitTransaction(tableName: string, changes: ChangeSet, operation?: DeltaLogEntry['operation']): Promise<number>;
    /**
     * Get delta log entry for a specific version
     */
    getDeltaLog(tableName: string, version?: number): Promise<DeltaLogEntry | null>;
    /**
     * Optimize table by compacting small files
     */
    optimizeTable(tableName: string): Promise<void>;
    /**
     * Vacuum old versions based on retention policy
     */
    vacuum(tableName: string): Promise<void>;
}
//# sourceMappingURL=ducklake.d.ts.map