import { Collection as CollectionCore } from './Collection.js';
import type { StorageBackend } from './storage/StorageBackend.js';
import type { CollectionConfig, CollectionDescription, CollectionSnapshot, CollectionStats, CompactOptions, CompactResult, DeleteRequest, Filter, GetOptions, ImportOptions, InsertManyOptions, InsertOptions, ListOptions, ListPage, Metadata, MetadataSchemaOption, PackedInsert, ScanOptions, SearchMethod, SearchOptions, SearchResult, UpdateManyRequest, UpdatePatch, VectorRecord, VectorRecordInput, VerificationReport, WriteSession } from './public-api.js';
export interface PublicCollectionOptions<TMetadata = Metadata> {
    metadataSchema?: MetadataSchemaOption<TMetadata>;
    /** Bounded default concurrency for independent searchMany calls. */
    searchConcurrency?: number;
    /** @internal Shared lifecycle token for scoped handles. */
    lifecycle?: {
        destroyed: boolean;
    };
}
/**
 * Stable, record-oriented collection API. The actual HNSW/persistence engine
 * is deliberately kept behind this facade and is not exported from the root.
 */
export declare class Collection<TMetadata = Metadata> {
    readonly name: string;
    readonly search: SearchMethod<TMetadata>;
    private readonly core;
    private readonly config;
    private readonly metadataSchema?;
    private readonly searchConcurrency?;
    private readonly scopedFilter?;
    private readonly lifecycle;
    private destroyed;
    private constructor();
    private ensureUsable;
    private getDimension;
    private getMetric;
    private getM;
    private getEfConstruction;
    private effectiveFilter;
    private normalizeMetadata;
    private validateMetadataDescriptor;
    private normalizeRecord;
    private normalizeRecords;
    private addConfig;
    insert(records: readonly VectorRecordInput<TMetadata>[], options?: InsertOptions): Promise<void>;
    upsert(records: readonly VectorRecordInput<TMetadata>[], options?: InsertOptions): Promise<void>;
    insertPacked(input: PackedInsert<TMetadata>): Promise<void>;
    insertMany(source: AsyncIterable<VectorRecordInput<TMetadata>> | Iterable<VectorRecordInput<TMetadata>>, options?: InsertManyOptions): Promise<number>;
    /** Import a stream with explicit duplicate semantics. */
    import(source: AsyncIterable<VectorRecordInput<TMetadata>> | Iterable<VectorRecordInput<TMetadata>>, options?: ImportOptions): Promise<number>;
    private recordFromStored;
    get(id: string, options?: GetOptions): Promise<VectorRecord<TMetadata> | undefined>;
    getMany(ids: readonly string[], options?: GetOptions): Promise<Array<VectorRecord<TMetadata>>>;
    list(options?: ListOptions<TMetadata>): Promise<ListPage<TMetadata>>;
    scan(options?: ScanOptions<TMetadata>): AsyncGenerator<VectorRecord<TMetadata>>;
    export(options?: ScanOptions<TMetadata>): AsyncGenerator<VectorRecord<TMetadata>>;
    update(id: string, patch: UpdatePatch<TMetadata>): Promise<void>;
    updateMany(request: UpdateManyRequest<TMetadata>): Promise<number>;
    private normalizeDeleteRequest;
    private resolveDeleteIds;
    delete(request: DeleteRequest<TMetadata> | string | readonly string[]): Promise<number>;
    has(id: string): boolean;
    count(options?: {
        filter?: Filter<TMetadata>;
    }): number;
    scope(filter: Filter<TMetadata>): Collection<TMetadata>;
    /** Convenience namespace handle backed by a metadata filter. */
    namespace(value: string, field?: string): Collection<TMetadata>;
    searchMany(options: readonly SearchOptions<TMetadata>[], batchOptions?: {
        concurrency?: number | 'auto';
        signal?: AbortSignal;
    }): Promise<Array<SearchResult<TMetadata>>>;
    private resolveSearch;
    private searchRecords;
    describe(): Promise<CollectionDescription>;
    stats(): Promise<CollectionStats>;
    verify(): Promise<VerificationReport>;
    compact(options?: CompactOptions): Promise<CompactResult>;
    optimize(options?: CompactOptions): Promise<CompactResult>;
    flush(): Promise<void>;
    /** Close a standalone handle; database-owned handles are also safe to close directly. */
    close(): Promise<void>;
    write(callback: (session: WriteSession<TMetadata>) => Promise<void> | void): Promise<void>;
    batch(callback: (session: WriteSession<TMetadata>) => Promise<void> | void): Promise<void>;
    exportSnapshot(): Promise<CollectionSnapshot<TMetadata>>;
    private destroyForDatabase;
}
export type { Collection as PublicCollection };
/** @internal package-internal constructor bridge; not exported from the root. */
export declare function createCollectionForDatabase<TMetadata>(name: string, config: CollectionConfig<TMetadata>, core: CollectionCore, options?: PublicCollectionOptions<TMetadata>): Collection<TMetadata>;
/** @internal package-internal lifecycle bridge; not exported from the root. */
export declare function destroyCollectionForDatabase(collection: Collection<any>, save?: boolean): Promise<void>;
/** @internal package-internal storage bridge; not exported from the root. */
export declare function collectionEngineForDatabase(collection: Collection<any>): CollectionCore;
export interface StandaloneCollectionOptions<TMetadata = Metadata> {
    storage?: StorageBackend;
    autoPersist?: boolean;
    durability?: 'immediate' | 'manual' | {
        mode: 'batched';
        maxOperations?: number;
        maxDelayMs?: number;
    };
    metadataSchema?: MetadataSchemaOption<TMetadata>;
    searchConcurrency?: number;
}
/**
 * Explicit advanced factory for a collection that is not manifest-managed by
 * VectorDB. The root package intentionally exposes Collection only as a type.
 */
export declare function openStandaloneCollection<TMetadata = Metadata>(name: string, config: CollectionConfig<TMetadata>, options?: StandaloneCollectionOptions<TMetadata>): Promise<Collection<TMetadata>>;
//# sourceMappingURL=PublicCollection.d.ts.map