import { z } from 'zod';
export interface Database {
    id: string;
    name: string;
    config: DatabaseConfig;
    collections: Collection[];
    stats: DatabaseStats;
    createdAt: string;
    updatedAt: string;
}
export interface DatabaseConfig {
    id: string;
    name: string;
    region: string;
    replicationRegions: string[];
    encryption: {
        enabled: boolean;
        algorithm: string;
        keyId?: string;
    };
    backup: {
        enabled: boolean;
        frequency: 'hourly' | 'daily' | 'weekly';
        retention: number;
    };
    settings: {
        maxConnections: number;
        queryTimeout: number;
        enableQueryLogging: boolean;
    };
}
export interface Collection {
    name: string;
    database: string;
    schema?: Record<string, unknown>;
    indexes: Index[];
    settings: {
        strict: boolean;
        versioning: boolean;
        encryption: boolean;
        compression: boolean;
    };
    stats: {
        documentCount: number;
        storageSize: number;
        indexSize: number;
        avgDocumentSize: number;
    };
    createdAt: string;
    updatedAt: string;
}
export interface Index {
    name: string;
    fields: IndexField[];
    type: 'btree' | 'hash' | 'vector' | 'fulltext' | 'geo' | 'compound';
    unique: boolean;
    sparse: boolean;
    background: boolean;
    stats: {
        size: number;
        selectivity: number;
        usageCount: number;
    };
    createdAt: string;
}
export interface IndexField {
    field: string;
    direction: 1 | -1;
    textWeight?: number;
}
export interface Document {
    _id: string;
    _collection: string;
    _version: number;
    _createdAt: string;
    _updatedAt: string;
    _deleted?: boolean;
    [key: string]: unknown;
}
export interface Query {
    collection: string;
    filter?: Record<string, unknown>;
    projection?: Record<string, 1 | 0>;
    sort?: Record<string, 1 | -1>;
    limit?: number;
    skip?: number;
    hint?: string;
}
export interface UpdateQuery {
    collection: string;
    filter: Record<string, unknown>;
    update: {
        $set?: Record<string, unknown>;
        $unset?: Record<string, 1>;
        $inc?: Record<string, number>;
        $mul?: Record<string, number>;
        $push?: Record<string, unknown>;
        $pull?: Record<string, unknown>;
        $addToSet?: Record<string, unknown>;
        $rename?: Record<string, string>;
    };
    options?: {
        upsert?: boolean;
        multi?: boolean;
        returnNew?: boolean;
    };
}
export interface DeleteQuery {
    collection: string;
    filter: Record<string, unknown>;
    options?: {
        multi?: boolean;
    };
}
export interface AggregationPipeline {
    collection: string;
    pipeline: PipelineStage[];
    options?: {
        allowDiskUse?: boolean;
        maxTimeMS?: number;
        hint?: string;
    };
}
export type PipelineStage = {
    $match: Record<string, unknown>;
} | {
    $project: Record<string, 1 | 0 | unknown>;
} | {
    $sort: Record<string, 1 | -1>;
} | {
    $limit: number;
} | {
    $skip: number;
} | {
    $group: GroupStage;
} | {
    $unwind: string | UnwindStage;
} | {
    $lookup: LookupStage;
} | {
    $addFields: Record<string, unknown>;
} | {
    $count: string;
};
export interface GroupStage {
    _id: unknown;
    [key: string]: {
        $sum?: unknown;
        $avg?: unknown;
        $min?: unknown;
        $max?: unknown;
        $first?: unknown;
        $last?: unknown;
        $push?: unknown;
        $addToSet?: unknown;
        $count?: Record<string, never>;
    };
}
export interface UnwindStage {
    path: string;
    includeArrayIndex?: string;
    preserveNullAndEmptyArrays?: boolean;
}
export interface LookupStage {
    from: string;
    localField: string;
    foreignField: string;
    as: string;
    pipeline?: PipelineStage[];
}
export interface Transaction {
    id: string;
    operations: TransactionOperation[];
    options?: {
        readConcern?: 'local' | 'majority' | 'snapshot';
        writeConcern?: {
            w: number | 'majority';
            j?: boolean;
            wtimeout?: number;
        };
        maxTimeMS?: number;
    };
}
export interface TransactionOperation {
    type: 'insert' | 'update' | 'delete' | 'find';
    collection: string;
    data?: unknown;
    filter?: Record<string, unknown>;
    update?: Record<string, unknown>;
}
export interface DatabaseStats {
    name: string;
    collections: number;
    documents: number;
    indexes: number;
    storageSize: number;
    dataSize: number;
    indexSize: number;
    avgObjSize: number;
    operations: {
        insert: number;
        query: number;
        update: number;
        delete: number;
    };
    performance: {
        avgQueryTime: number;
        slowQueries: number;
        cacheHitRatio: number;
    };
}
export declare const CreateCollectionSchema: z.ZodObject<{
    name: z.ZodString;
    schema: z.ZodOptional<z.ZodRecord<z.core.$ZodRecordKey, z.core.SomeType>>;
    settings: z.ZodOptional<z.ZodObject<{
        strict: z.ZodDefault<z.ZodBoolean>;
        versioning: z.ZodDefault<z.ZodBoolean>;
        encryption: z.ZodDefault<z.ZodBoolean>;
        compression: z.ZodDefault<z.ZodBoolean>;
    }, z.core.$strip>>;
}, z.core.$strip>;
export declare const CreateIndexSchema: z.ZodObject<{
    name: z.ZodString;
    fields: z.ZodArray<z.ZodObject<{
        field: z.ZodString;
        direction: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>>;
        textWeight: z.ZodOptional<z.ZodNumber>;
    }, z.core.$strip>>;
    type: z.ZodDefault<z.ZodEnum<{
        btree: "btree";
        hash: "hash";
        vector: "vector";
        fulltext: "fulltext";
        geo: "geo";
        compound: "compound";
    }>>;
    unique: z.ZodDefault<z.ZodBoolean>;
    sparse: z.ZodDefault<z.ZodBoolean>;
    background: z.ZodDefault<z.ZodBoolean>;
}, z.core.$strip>;
export declare const InsertDocumentSchema: z.ZodObject<{
    _id: z.ZodOptional<z.ZodString>;
}, z.core.$loose>;
export declare const UpdateDocumentSchema: z.ZodObject<{
    $set: z.ZodOptional<z.ZodRecord<z.core.$ZodRecordKey, z.core.SomeType>>;
    $unset: z.ZodOptional<z.ZodRecord<z.ZodLiteral<1>, z.core.SomeType>>;
    $inc: z.ZodOptional<z.ZodRecord<z.ZodNumber, z.core.SomeType>>;
    $mul: z.ZodOptional<z.ZodRecord<z.ZodNumber, z.core.SomeType>>;
    $push: z.ZodOptional<z.ZodRecord<z.core.$ZodRecordKey, z.core.SomeType>>;
    $pull: z.ZodOptional<z.ZodRecord<z.core.$ZodRecordKey, z.core.SomeType>>;
    $addToSet: z.ZodOptional<z.ZodRecord<z.core.$ZodRecordKey, z.core.SomeType>>;
    $rename: z.ZodOptional<z.ZodRecord<z.ZodString, z.core.SomeType>>;
}, z.core.$strip>;
//# sourceMappingURL=database.d.ts.map