/**
 * @nahisaho/yata-scale - Shard Manager
 *
 * Manages shard lifecycle, health, and operations
 */
import { type Result } from 'neverthrow';
import type { ShardConfig, ShardInfo, ShardHealth, RebalanceOptions, RebalanceJob, PartitionStrategyType, Entity, Relationship } from '../types.js';
import { ShardError, ShardNotFoundError, ShardUnavailableError, RebalanceError } from '../errors.js';
import { ShardRouter } from './ShardRouter.js';
/**
 * Shard storage interface
 */
export interface ShardStorage {
    readonly shardId: string;
    getEntity(id: string): Promise<Entity | undefined>;
    putEntity(entity: Entity): Promise<void>;
    deleteEntity(id: string): Promise<boolean>;
    getRelationship(id: string): Promise<Relationship | undefined>;
    putRelationship(relationship: Relationship): Promise<void>;
    deleteRelationship(id: string): Promise<boolean>;
    getEntities(ids: string[]): Promise<Map<string, Entity>>;
    putEntities(entities: Entity[]): Promise<void>;
    getEntityCount(): Promise<number>;
    getRelationshipCount(): Promise<number>;
    getSizeBytes(): Promise<number>;
    open(): Promise<void>;
    close(): Promise<void>;
    clear(): Promise<void>;
}
/**
 * Shard manager for lifecycle and operations
 */
export declare class ShardManager {
    private readonly strategyType;
    private readonly storageFactory;
    private shards;
    private storage;
    private router;
    private rebalanceJobs;
    private healthCheckInterval?;
    constructor(strategyType: PartitionStrategyType, storageFactory: (config: ShardConfig) => ShardStorage);
    /**
     * Initialize with shard configurations
     */
    initialize(configs: ShardConfig[]): Promise<void>;
    /**
     * Create a new shard
     */
    createShard(config: ShardConfig): Promise<Result<ShardInfo, ShardError>>;
    /**
     * Remove a shard
     */
    removeShard(shardId: string, graceful?: boolean): Promise<Result<void, ShardError>>;
    /**
     * Get shard info
     */
    getShardInfo(shardId: string): Result<ShardInfo, ShardNotFoundError>;
    /**
     * List all shards
     */
    listShards(): ShardInfo[];
    /**
     * Get shard for an entity
     */
    getShardForEntity(entityId: string): Result<ShardInfo, ShardNotFoundError | ShardUnavailableError>;
    /**
     * Get storage for an entity
     */
    getStorageForEntity(entityId: string): Result<ShardStorage, ShardNotFoundError | ShardUnavailableError>;
    /**
     * Start rebalancing
     */
    startRebalance(options?: RebalanceOptions): Promise<Result<RebalanceJob, RebalanceError>>;
    /**
     * Execute rebalance operation
     */
    private executeRebalance;
    /**
     * Get rebalance status
     */
    getRebalanceStatus(jobId: string): Result<RebalanceJob, RebalanceError>;
    /**
     * Cancel rebalance
     */
    cancelRebalance(jobId: string): Promise<Result<void, RebalanceError>>;
    /**
     * Check health of all shards
     */
    checkHealth(): Promise<Map<string, ShardHealth>>;
    /**
     * Repair a shard
     */
    repairShard(shardId: string): Promise<Result<void, ShardError>>;
    /**
     * Get the router
     */
    getRouter(): ShardRouter;
    /**
     * Get storage for a shard
     */
    getStorage(shardId: string): ShardStorage | undefined;
    /**
     * Close all shards
     */
    close(): Promise<void>;
    /**
     * Update shard status
     */
    private updateShardStatus;
    /**
     * Create a connection object for router
     */
    private createConnection;
    /**
     * Start health check interval
     */
    private startHealthCheck;
    /**
     * Stop health check interval
     */
    private stopHealthCheck;
}
//# sourceMappingURL=ShardManager.d.ts.map