import { Observable } from 'rxjs';
export interface CNDConfig {
    cbd: {
        host: string;
        port: number;
        database: string;
        auth?: {
            username?: string;
            password?: string;
            token?: string;
        };
    };
    enterprise?: {
        enabled: boolean;
        features: {
            serviceDiscovery?: boolean;
            authentication?: boolean;
            authorization?: boolean;
            encryption?: boolean;
            audit?: boolean;
            monitoring?: boolean;
            backup?: boolean;
            clustering?: boolean;
        };
    };
    serviceDiscovery?: {
        enabled: boolean;
        registryUrl?: string;
        serviceName?: string;
        healthCheckInterval?: number;
        tags?: string[];
    };
    auth?: {
        enabled: boolean;
        provider: 'internal' | 'oauth2' | 'jwt' | 'saml' | 'ldap';
        config: {
            secret?: string;
            issuer?: string;
            audience?: string;
            algorithms?: string[];
            publicKey?: string;
            privateKey?: string;
        };
        rbac?: {
            enabled: boolean;
            roles: Record<string, string[]>;
            permissions: Record<string, string[]>;
        };
    };
    security?: {
        encryption?: {
            enabled: boolean;
            algorithm: 'aes-256-gcm' | 'aes-192-gcm' | 'aes-128-gcm';
            keyRotation?: {
                enabled: boolean;
                interval: number;
            };
        };
        audit?: {
            enabled: boolean;
            storage: 'database' | 'file' | 'external';
            retention: number;
        };
        rateLimit?: {
            enabled: boolean;
            windowMs: number;
            maxRequests: number;
        };
    };
    realtime?: {
        enabled: boolean;
        websocketPort?: number;
    };
    cache?: {
        enabled: boolean;
        ttl?: number;
        distributed?: boolean;
        redis?: {
            host: string;
            port: number;
            password?: string;
        };
    };
    performance?: {
        monitoring?: {
            enabled: boolean;
            metricsPort?: number;
            healthCheckPath?: string;
        };
        clustering?: {
            enabled: boolean;
            nodes: string[];
            replicationFactor: number;
        };
        backup?: {
            enabled: boolean;
            schedule: string;
            storage: 's3' | 'gcs' | 'azure' | 'local';
            retention: number;
        };
    };
    logging?: {
        enabled: boolean;
        level: 'debug' | 'info' | 'warn' | 'error';
        structured?: boolean;
        destination?: 'console' | 'file' | 'elasticsearch' | 'splunk';
    };
}
export interface ServiceDiscoveryConfig {
    enabled: boolean;
    registryUrl: string;
    serviceName: string;
    serviceId: string;
    version: string;
    tags: string[];
    healthCheck: {
        path: string;
        interval: number;
        timeout: number;
    };
    metadata: Record<string, any>;
}
export interface AuthenticationContext {
    userId: string;
    sessionId: string;
    permissions: string[];
    roles: string[];
    tenant?: string;
    expiresAt: Date;
    metadata: Record<string, any>;
}
export interface AuditLog {
    id: string;
    timestamp: Date;
    userId: string;
    sessionId: string;
    operation: string;
    resource: string;
    details: Record<string, any>;
    result: 'success' | 'failure' | 'partial';
    duration: number;
    metadata: Record<string, any>;
}
export interface MetricsData {
    timestamp: Date;
    service: string;
    operation: string;
    duration: number;
    status: 'success' | 'error';
    metadata: Record<string, any>;
}
export interface SchemaDefinition {
    [tableName: string]: TableSchema;
}
export interface TableSchema {
    [fieldName: string]: FieldDefinition | RelationDefinition;
}
export interface FieldDefinition {
    type: 'string' | 'number' | 'boolean' | 'date' | 'json' | 'text' | 'uuid';
    primary?: boolean;
    unique?: boolean;
    required?: boolean;
    default?: any;
    references?: string;
}
export interface RelationDefinition {
    name: string;
    type: 'hasOne' | 'hasMany' | 'belongsTo' | 'manyToMany';
    table: string;
    foreignKey?: string;
    pivotTable?: string;
    fieldName?: string;
}
export interface QueryResult<T = any> {
    data: T[];
    count: number;
    executionTime: number;
    query: string;
}
export interface QueryBuilder<T = any> {
    select(fields?: string[]): QueryBuilder<T>;
    where(conditions: Record<string, any>): QueryBuilder<T>;
    orderBy(field: string, direction?: 'asc' | 'desc'): QueryBuilder<T>;
    limit(count: number): QueryBuilder<T>;
    offset(count: number): QueryBuilder<T>;
    include(relations: string[]): QueryBuilder<T>;
    execute(): Promise<QueryResult<T>>;
    first(): Promise<T | null>;
    live(): Observable<T[]>;
}
export interface DocumentQuery<T = any> {
    find(query?: Record<string, any>): Promise<T[]>;
    findOne(query?: Record<string, any>): Promise<T | null>;
    findById(id: string): Promise<T | null>;
    create(document: Partial<T>): Promise<T>;
    update(id: string, updates: Partial<T>): Promise<T>;
    delete(id: string): Promise<boolean>;
    count(query?: Record<string, any>): Promise<number>;
    search(text: string, fields?: string[]): Promise<T[]>;
}
export interface GraphNode {
    id: string;
    labels: string[];
    properties: Record<string, any>;
}
export interface GraphRelationship {
    id: string;
    type: string;
    startNode: string;
    endNode: string;
    properties: Record<string, any>;
}
export interface GraphQuery {
    match(pattern: string): GraphQuery;
    where(conditions: Record<string, any>): GraphQuery;
    return(fields: string[]): Promise<any[]>;
    create(node: Partial<GraphNode>): Promise<GraphNode>;
    relate(from: string, to: string, type: string, properties?: Record<string, any>): Promise<GraphRelationship>;
}
export interface VectorQuery {
    insert(id: string, vector: number[], metadata?: Record<string, any>): Promise<void>;
    similarity(vector: number[], options?: {
        threshold?: number;
        limit?: number;
    }): Promise<VectorResult[]>;
    delete(id: string): Promise<boolean>;
    update(id: string, vector: number[], metadata?: Record<string, any>): Promise<void>;
}
export interface VectorResult {
    id: string;
    score: number;
    metadata: Record<string, any>;
}
export interface TimeSeriesQuery {
    insert(timestamp: Date, value: number, tags?: Record<string, string>): Promise<void>;
    range(start: Date, end: Date): TimeSeriesQuery;
    where(tags: Record<string, string>): TimeSeriesQuery;
    aggregate(func: 'avg' | 'sum' | 'min' | 'max' | 'count', interval?: string): Promise<TimeSeriesPoint[]>;
    latest(): Promise<TimeSeriesPoint | null>;
}
export interface TimeSeriesPoint {
    timestamp: Date;
    value: number;
    tags: Record<string, string>;
}
export interface CacheAPI {
    get<T = any>(key: string): Promise<T | null>;
    set<T = any>(key: string, value: T, options?: {
        ttl?: number;
    }): Promise<void>;
    delete(key: string): Promise<boolean>;
    exists(key: string): Promise<boolean>;
    expire(key: string, ttl: number): Promise<boolean>;
    keys(pattern?: string): Promise<string[]>;
    flush(): Promise<void>;
}
export interface MigrationOptions {
    tables?: string[];
    collections?: string[];
    transform?: Record<string, (data: any) => any>;
    batchSize?: number;
    dryRun?: boolean;
}
export interface MigrationResult {
    source: string;
    tablesProcessed: string[];
    recordsProcessed: number;
    errors: string[];
    duration: number;
}
export interface RealtimeSubscription {
    id: string;
    query: string;
    callback: (data: any) => void;
    unsubscribe: () => void;
}
export interface Transaction {
    sql<T>(query: TemplateStringsArray, ...values: any[]): Promise<T[]>;
    collection(name: string): DocumentQuery;
    commit(): Promise<void>;
    rollback(): Promise<void>;
}
export interface AdminConfig {
    auth?: {
        provider: 'keycloak' | 'auth0' | 'custom';
        config: Record<string, any>;
    };
    tables?: Record<string, {
        permissions: ('read' | 'create' | 'update' | 'delete')[];
        fields?: Record<string, {
            editable?: boolean;
            filterable?: boolean;
            sortable?: boolean;
        }>;
    }>;
    customPages?: Record<string, {
        component: string;
        route: string;
    }>;
}
export declare class CNDError extends Error {
    code: string;
    details?: Record<string, any> | undefined;
    constructor(message: string, code: string, details?: Record<string, any> | undefined);
}
export declare class CNDValidationError extends CNDError {
    field: string;
    value: any;
    constructor(message: string, field: string, value: any);
}
export declare class CNDConnectionError extends CNDError {
    host: string;
    port: number;
    constructor(message: string, host: string, port: number);
}
//# sourceMappingURL=types.d.ts.map