/**
 * Base Graph Adapter
 *
 * Abstract base class defining the interface for all graph database adapters.
 * Each adapter implementation must extend this class and implement all abstract methods.
 */
import { GraphType, GraphFeature } from '../types/enums';
import { IGraphConnectionOptions, IGraphConnectionResult, IGraphTestConnectionResult } from '../types/connection.interface';
import { ICreateNodeOptions, ICreateNodeResult, IFindNodesOptions, IFindNodesResult, IUpdateNodeOptions, IUpdateNodeResult, IDeleteNodeOptions, IDeleteNodeResult, IMergeNodeOptions, IMergeNodeResult, INode, IAddLabelsOptions, IAddLabelsResult, IRemoveLabelsOptions, IRemoveLabelsResult, ISetLabelsOptions, ISetLabelsResult } from '../types/node.interface';
import { ICreateRelationshipOptions, ICreateRelationshipResult, IFindRelationshipsOptions, IFindRelationshipsResult, IUpdateRelationshipOptions, IUpdateRelationshipResult, IDeleteRelationshipOptions, IDeleteRelationshipResult, IMergeRelationshipOptions, IMergeRelationshipResult, IRelationship } from '../types/relationship.interface';
import { ITraverseOptions, ITraverseResult, IShortestPathOptions, IShortestPathResult, IAllPathsOptions, IAllPathsResult, INeighborhoodOptions, INeighborhoodResult, IConnectedComponentsOptions, IConnectedComponentsResult } from '../types/traversal.interface';
import { IGraphTransaction, IGraphTransactionOptions } from '../types/transaction.interface';
import { IRawQueryOptions, IRawQueryResult, ICountNodesResult, ICountRelationshipsResult, IGraphStatistics, IFullTextSearchOptions, IFullTextSearchResult, IVectorSearchOptions, IVectorSearchResult, IGraphWhereClause } from '../types/query.interface';
import { ICreateNodeIndexOptions, ICreateNodeConstraintOptions, IListIndexesResult, IListConstraintsResult, ICreateIndexResult, ICreateConstraintResult, IDropIndexResult, IDropConstraintResult, IListLabelsResult, IListRelationshipTypesResult } from '../types/schema.interface';
import { ICreateRelationshipIndexOptions } from '../types/relationship.interface';
/**
 * Adapter connection options
 */
export interface IAdapterConnectionOptions {
    /** Connection URL */
    connectionUrl: string;
    /** Route TCP via VPC connector relay (private Neptune) */
    vpcConnectorTunnel?: import('../../database/types/connection.interface').IVpcConnectorTunnelOptions;
    /** Database name (for some adapters) */
    database?: string;
    /** Graph name (for some adapters) */
    graphName?: string;
    /** Authentication credentials */
    auth?: {
        username: string;
        password: string;
    };
    /** Additional connection options */
    options?: IGraphConnectionOptions;
}
/**
 * Abstract base class for graph database adapters
 */
export declare abstract class BaseGraphAdapter {
    /** Graph database type this adapter handles */
    protected abstract readonly graphType: GraphType;
    /** Underlying client instance */
    protected client: any;
    /** Whether currently connected */
    protected connected: boolean;
    /** Current connection URL */
    protected connectionUrl: string;
    /** Connection options (stored for reconnection) */
    protected connectionOptions: IAdapterConnectionOptions | null;
    /** Maximum retry attempts for auto-reconnection */
    protected maxRetries: number;
    /** Flag to indicate if a reconnection is in progress */
    private reconnecting;
    /** Supported features for this adapter */
    protected abstract readonly supportedFeatures: Set<GraphFeature>;
    /**
     * Execute an operation with automatic retry on connection errors.
     * This handles transient connection timeouts and disconnects silently.
     */
    protected executeWithRetry<T>(operation: () => Promise<T>, retries?: number): Promise<T>;
    /**
     * Check if an error is a connection-related error
     */
    protected isConnectionError(error: any): boolean;
    /**
     * Attempt to reconnect to the graph database
     */
    protected attemptReconnect(): Promise<void>;
    /**
     * Connect to the graph database
     */
    abstract connect(options: IAdapterConnectionOptions): Promise<IGraphConnectionResult>;
    /**
     * Test connection without persisting
     */
    abstract testConnection(options: IAdapterConnectionOptions): Promise<IGraphTestConnectionResult>;
    /**
     * Disconnect from the graph database
     */
    abstract disconnect(): Promise<void>;
    /**
     * Check if connected
     */
    isConnected(): boolean;
    /**
     * Get the graph type
     */
    getGraphType(): GraphType;
    /**
     * Check if a feature is supported
     */
    supportsFeature(feature: GraphFeature): boolean;
    /**
     * Get all supported features
     */
    getSupportedFeatures(): GraphFeature[];
    /**
     * Create a node
     */
    abstract createNode<T = any>(options: ICreateNodeOptions<T>, transaction?: IGraphTransaction): Promise<ICreateNodeResult<T>>;
    /**
     * Find nodes by criteria
     */
    abstract findNodes<T = any>(options: IFindNodesOptions, transaction?: IGraphTransaction): Promise<IFindNodesResult<T>>;
    /**
     * Find a single node by ID
     */
    abstract findNodeById<T = any>(id: string | number, transaction?: IGraphTransaction): Promise<INode<T> | null>;
    /**
     * Update a node
     */
    abstract updateNode<T = any>(options: IUpdateNodeOptions<T>, transaction?: IGraphTransaction): Promise<IUpdateNodeResult<T>>;
    /**
     * Delete a node
     */
    abstract deleteNode(options: IDeleteNodeOptions, transaction?: IGraphTransaction): Promise<IDeleteNodeResult>;
    /**
     * Merge (upsert) a node
     */
    abstract mergeNode<T = any>(options: IMergeNodeOptions<T>, transaction?: IGraphTransaction): Promise<IMergeNodeResult<T>>;
    /**
     * Add labels to a node
     */
    abstract addLabels<T = any>(options: IAddLabelsOptions, transaction?: IGraphTransaction): Promise<IAddLabelsResult<T>>;
    /**
     * Remove labels from a node
     */
    abstract removeLabels<T = any>(options: IRemoveLabelsOptions, transaction?: IGraphTransaction): Promise<IRemoveLabelsResult<T>>;
    /**
     * Set labels on a node (replaces all existing labels)
     */
    abstract setLabels<T = any>(options: ISetLabelsOptions, transaction?: IGraphTransaction): Promise<ISetLabelsResult<T>>;
    /**
     * Create a relationship
     */
    abstract createRelationship<T = any>(options: ICreateRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<ICreateRelationshipResult<T>>;
    /**
     * Find relationships by criteria
     */
    abstract findRelationships<T = any>(options: IFindRelationshipsOptions, transaction?: IGraphTransaction): Promise<IFindRelationshipsResult<T>>;
    /**
     * Find a single relationship by ID
     */
    abstract findRelationshipById<T = any>(id: string | number, transaction?: IGraphTransaction): Promise<IRelationship<T> | null>;
    /**
     * Update a relationship
     */
    abstract updateRelationship<T = any>(options: IUpdateRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<IUpdateRelationshipResult<T>>;
    /**
     * Delete a relationship
     */
    abstract deleteRelationship(options: IDeleteRelationshipOptions, transaction?: IGraphTransaction): Promise<IDeleteRelationshipResult>;
    /**
     * Merge (upsert) a relationship
     */
    abstract mergeRelationship<T = any>(options: IMergeRelationshipOptions<T>, transaction?: IGraphTransaction): Promise<IMergeRelationshipResult<T>>;
    /**
     * Traverse the graph from a starting node
     */
    abstract traverse<TNode = any, TRel = any>(options: ITraverseOptions, transaction?: IGraphTransaction): Promise<ITraverseResult<TNode, TRel>>;
    /**
     * Find the shortest path between two nodes
     */
    abstract shortestPath<TNode = any, TRel = any>(options: IShortestPathOptions, transaction?: IGraphTransaction): Promise<IShortestPathResult<TNode, TRel>>;
    /**
     * Find all paths between two nodes
     */
    abstract allPaths<TNode = any, TRel = any>(options: IAllPathsOptions, transaction?: IGraphTransaction): Promise<IAllPathsResult<TNode, TRel>>;
    /**
     * Get the neighborhood of a node
     */
    abstract getNeighborhood<TNode = any, TRel = any>(options: INeighborhoodOptions, transaction?: IGraphTransaction): Promise<INeighborhoodResult<TNode, TRel>>;
    /**
     * Find connected components in the graph
     */
    abstract findConnectedComponents<TNode = any>(options: IConnectedComponentsOptions, transaction?: IGraphTransaction): Promise<IConnectedComponentsResult<TNode>>;
    /**
     * Count nodes matching criteria
     */
    abstract countNodes(labels?: string[], where?: IGraphWhereClause, transaction?: IGraphTransaction): Promise<ICountNodesResult>;
    /**
     * Count relationships matching criteria
     */
    abstract countRelationships(types?: string[], where?: IGraphWhereClause, transaction?: IGraphTransaction): Promise<ICountRelationshipsResult>;
    /**
     * Get graph statistics
     */
    abstract getStatistics(transaction?: IGraphTransaction): Promise<IGraphStatistics>;
    /**
     * Full-text search
     */
    abstract fullTextSearch<T = any>(options: IFullTextSearchOptions, transaction?: IGraphTransaction): Promise<IFullTextSearchResult<T>>;
    /**
     * Vector similarity search
     */
    abstract vectorSearch<T = any>(options: IVectorSearchOptions, transaction?: IGraphTransaction): Promise<IVectorSearchResult<T>>;
    /**
     * Execute a raw query
     */
    abstract query<T = any>(options: IRawQueryOptions, transaction?: IGraphTransaction): Promise<IRawQueryResult<T>>;
    /**
     * Create a node index
     */
    abstract createNodeIndex(options: ICreateNodeIndexOptions): Promise<ICreateIndexResult>;
    /**
     * Create a node constraint
     */
    abstract createNodeConstraint(options: ICreateNodeConstraintOptions): Promise<ICreateConstraintResult>;
    /**
     * Create a relationship index
     */
    abstract createRelationshipIndex(options: ICreateRelationshipIndexOptions): Promise<ICreateIndexResult>;
    /**
     * List all indexes
     */
    abstract listIndexes(): Promise<IListIndexesResult>;
    /**
     * List all constraints
     */
    abstract listConstraints(): Promise<IListConstraintsResult>;
    /**
     * Drop an index
     */
    abstract dropIndex(name: string): Promise<IDropIndexResult>;
    /**
     * Drop a constraint
     */
    abstract dropConstraint(name: string): Promise<IDropConstraintResult>;
    /**
     * List all node labels with counts and property information
     */
    abstract listLabels(): Promise<IListLabelsResult>;
    /**
     * List all relationship types with counts
     */
    abstract listRelationshipTypes(): Promise<IListRelationshipTypesResult>;
    /**
     * Begin a transaction
     */
    abstract beginTransaction(options?: IGraphTransactionOptions): Promise<IGraphTransaction>;
    /**
     * Commit a transaction
     */
    abstract commitTransaction(transaction: IGraphTransaction): Promise<void>;
    /**
     * Rollback a transaction
     */
    abstract rollbackTransaction(transaction: IGraphTransaction): Promise<void>;
    /**
     * Get the underlying client
     */
    getClient(): any;
    /**
     * Ensure the adapter is connected before performing operations
     * @throws GraphError if not connected
     */
    protected ensureConnected(): void;
    /**
     * Build where clause for the specific database
     */
    protected abstract buildWhereClause(where: IGraphWhereClause): any;
    /**
     * Parse database error into GraphError
     */
    abstract parseError(error: unknown): Error;
}