import { Readable } from 'stream';
import type { Quad } from '@rdfjs/types';
import { RepresentationMetadata } from '@solid/community-server';
import type { Representation, ResourceIdentifier, Guarded, DataAccessor, FileIdentifierMapper } from '@solid/community-server';
import { type RdfAccessScope } from '../rdf/RdfAccessScope';
import type { RdfSourceInput, RdfTextChunkInput, RdfTextSourceInput, RdfTermRewriteInput, RdfTermRewriteResult, RdfVectorChunkInput, RdfVectorSourceInput } from '../rdf/types';
import type { SparqlVoidOptions } from '../sparql/SubgraphQueryEngine';
import type { SolidFsChange, SolidFsManifest } from '../../solidfs/types';
import type { RdfSearchReconciliationIntentSink } from '../../search/RdfSearchIntentSink';
export interface LocalRdfDocument {
    data: Guarded<Readable>;
    metadata: RepresentationMetadata;
}
export interface LocalRdfReadableAccessor {
    getLocalRdfDocument(identifier: ResourceIdentifier): Promise<LocalRdfDocument>;
}
export interface LocalRdfIndexAccessor {
    syncLocalRdfDocument(identifier: ResourceIdentifier, data?: Guarded<Readable>, contentType?: string, options?: LocalRdfSyncOptions): Promise<void>;
    deleteLocalRdfIndex(identifier: ResourceIdentifier): Promise<void>;
    moveLocalRdfIndex?(previousIdentifier: ResourceIdentifier, nextIdentifier: ResourceIdentifier, options?: LocalRdfMoveOptions): Promise<number>;
    rewriteTerms?(input: RdfTermRewriteInput): Promise<RdfTermRewriteResult> | RdfTermRewriteResult;
}
export interface LocalRdfSyncOptions {
    source?: string;
    workspace?: string;
    localPath?: string;
    sourceVersion?: string;
}
export interface LocalRdfMoveOptions extends LocalRdfSyncOptions {
    previousSource?: string;
}
export interface SourceScopedStructuredRdfAccessor {
    writeRdfSourceDocument(identifier: ResourceIdentifier, quads: Quad[], metadata: RepresentationMetadata, source: RdfSourceInput): Promise<void>;
    deleteRdfSourceDocument(identifier: ResourceIdentifier): Promise<void>;
    moveRdfSourceDocument?(oldSource: string, next: RdfSourceInput): Promise<number>;
    indexTextSource?(source: RdfTextSourceInput, text: string, chunks?: RdfTextChunkInput[]): Promise<void>;
    moveTextSource?(oldSource: string, next: RdfTextSourceInput): Promise<number>;
    deleteTextSource?(source: string): Promise<number>;
    indexVectorSource?(source: RdfVectorSourceInput, chunks: RdfVectorChunkInput[]): Promise<void>;
    moveVectorSource?(oldSource: string, next: RdfVectorSourceInput): Promise<number>;
    deleteVectorSource?(source: string): Promise<number>;
}
export interface LocalRdfAuthorityJournalOperation {
    id: string;
}
export interface LocalRdfAuthorityJournal {
    recordLocalCommitted(change: SolidFsChange, workspace: SolidFsManifest, txId?: string): Promise<LocalRdfAuthorityJournalOperation>;
    markDone(id: string): Promise<void>;
    markRetryableFailure(id: string, error: unknown): Promise<void>;
    markReconcileRequired(id: string, reason: string): Promise<void>;
    markFailedPermanent(id: string, error: unknown): Promise<void>;
}
/**
 * MixDataAccessor - Routes data to appropriate storage based on content type
 *
 * - RDF data (internal/quads) -> structuredDataAccessor (Solid RDF engine by default)
 * - RDF file mirrors (.ttl/.jsonld) -> rdfFileDataAccessor (local FileSystem)
 * - Other data (binary, text, etc.) -> unstructuredDataAccessor (FileSystem, Minio, etc.)
 *
 * This uses composition instead of inheritance, allowing any DataAccessor
 * to be used as the RDF storage backend.
 */
export declare class MixDataAccessor implements DataAccessor, LocalRdfIndexAccessor {
    protected readonly logger: import("global-logger-factory").Logger<unknown>;
    private readonly structuredDataAccessor;
    private readonly unstructuredDataAccessor;
    private readonly rdfFileDataAccessor;
    private readonly rdfFileMapper?;
    private readonly localRdfAuthorityJournal?;
    private readonly presignedRedirectEnabled;
    private readonly mirrorContainersToUnstructured;
    private readonly textSearchIndexingEnabled;
    private readonly rdfSearchIntentSink?;
    constructor(structuredDataAccessor: DataAccessor, unstructuredDataAccessor: DataAccessor, presignedRedirectEnabled?: boolean, mirrorContainersToUnstructured?: boolean, rdfFileDataAccessor?: DataAccessor, textSearchIndexingEnabled?: boolean, rdfFileMapper?: FileIdentifierMapper, localRdfAuthorityJournal?: LocalRdfAuthorityJournal, rdfSearchIntentSink?: RdfSearchReconciliationIntentSink);
    /**
     * This accessor supports all types of data.
     */
    canHandle(representation: Representation): Promise<void>;
    /**
     * Checks if the given representation is unstructured (non-RDF).
     */
    private isUnstructured;
    getData(identifier: ResourceIdentifier): Promise<Guarded<Readable>>;
    /**
     * Read the local RDF file mirror used by SolidFS/local-first HTTP reads.
     *
     * `getData()` intentionally keeps returning the structured quad stream for
     * CSS internals. This method is the explicit file-content path for callers
     * that need a real Turtle/JSON-LD byte stream.
     */
    getLocalRdfDocument(identifier: ResourceIdentifier): Promise<LocalRdfDocument>;
    getMetadata(identifier: ResourceIdentifier): Promise<RepresentationMetadata>;
    getChildren(identifier: ResourceIdentifier): AsyncIterableIterator<RepresentationMetadata>;
    writeContainer(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
    writeDocument(identifier: ResourceIdentifier, data: Guarded<Readable>, metadata: RepresentationMetadata): Promise<void>;
    writeMetadata(identifier: ResourceIdentifier, metadata: RepresentationMetadata): Promise<void>;
    deleteResource(identifier: ResourceIdentifier): Promise<void>;
    /**
     * Execute SPARQL UPDATE.
     *
     * Native QLever prepares an exact graph delta. The accessor validates its
     * write scope, patches the local RDF authority files, and rebuilds the index.
     */
    executeSparqlUpdate(query: string, baseIri?: string, accessScope?: RdfAccessScope, options?: SparqlVoidOptions): Promise<void>;
    private prepareNativeRdfSparqlUpdate;
    private executePreparedRdfSparqlUpdate;
    private assertPreparedDeltaQuadGraph;
    private readLocalRdfState;
    private writeLocalRdfAuthority;
    private writeLocalRdfAuthorityPatches;
    private prepareLocalRdfAuthorityJournalPatches;
    private recordLocalRdfAuthorityJournalPatch;
    private markLocalRdfAuthorityJournalFailure;
    private markLocalRdfAuthorityRollbackComplete;
    private localRdfPatchWorkspace;
    private localRdfPatchRelativePath;
    private rollbackLocalRdfAuthorityPatches;
    private toDefaultGraphQuad;
    private toGraphQuad;
    private quadKey;
    /**
     * Rebuild the structured RDF index from an already-written local RDF file.
     *
     * SolidFS uses this after tools edit `.ttl`/`.jsonld` files directly. The
     * local file remains the content authority; the structured accessor is only
     * refreshed as query/index state.
     */
    syncLocalRdfDocument(identifier: ResourceIdentifier, data?: Guarded<Readable>, contentType?: string, options?: LocalRdfSyncOptions): Promise<void>;
    deleteLocalRdfIndex(identifier: ResourceIdentifier): Promise<void>;
    moveLocalRdfIndex(previousIdentifier: ResourceIdentifier, nextIdentifier: ResourceIdentifier, options?: LocalRdfMoveOptions): Promise<number>;
    private writeRdfDocument;
    private writeStructuredRdfIndex;
    private refreshLocalRdfMirror;
    private getLocalRdfMetadata;
    private getExistingLocalRdfMetadata;
    private createLocalRdfMetadata;
    private localRdfContentType;
    private sourceScopedStructuredAccessor;
    private syncTextSearchIndex;
    private syncUnstructuredTextSearchIndex;
    private deleteSearchIndexes;
    private moveSearchIndexes;
    private moveVectorIndexIfPresent;
    private deleteVectorIndexIfPresent;
    private rdfSourceInput;
    private rdfTextSourceInput;
    private relativePathFromWorkspace;
    private isByLineRdfIdentifier;
    private isRdfDocumentIdentifier;
    private isSearchableUnstructuredText;
    private isLocalMirroredRdf;
    private serializeQuadsForLocalFile;
    private serializeNQuads;
    private parseLocalRdf;
    private readStreamText;
    /**
     * Write unstructured document: store data in unstructured accessor,
     * then save metadata in structured accessor.
     */
    private writeUnstructuredDocument;
    private deleteUnstructuredResourceIfPresent;
    private deleteRdfFileResourceIfPresent;
    private ensureUnstructuredParentContainers;
    private ensureRdfFileParentContainers;
    private ensureParentContainers;
    private writeContainerIfMissing;
    private sameIdentifier;
    private parentContainer;
    private invalidateMetadataCache;
}