import type { Quad, Term } from '@rdfjs/types';
import type { RdfEngineLike, RdfNativeSparqlAccessScope, RdfNativeSparqlResult } from '../storage/rdf/types';
export declare const DEFAULT_BASE_PATH = "urn:xpod:semantic:";
export interface SemanticFixtureCase {
    id: string;
    documents: readonly {
        sourceUri: string;
        graph?: 'source' | 'default';
        contentType: 'text/turtle';
        body: string;
    }[];
    updates: readonly {
        sourceUri: string;
        sparql: string;
    }[];
    query: string;
    acceptMediaType: string;
    accessScope: {
        principal: string;
        mode: string;
        allowedGraphs: readonly string[];
        allowedSources: readonly string[];
        deniedGraphs: readonly string[];
        deniedSources: readonly string[];
    };
    expectedCanonical: Record<string, unknown>;
}
export interface LocalQleverSemanticHarnessOptions {
    fixturePath: string;
    runtimeCommand: string;
    artifactPath: string;
    tempRoot?: string;
    runtimeCwd?: string;
    timeoutMs?: number;
}
export interface PostgresQleverSemanticHarnessOptions {
    fixturePath: string;
    connectionString: string;
    artifactPath: string;
    timeoutMs?: number;
}
export type PostgresPublicSemanticHarnessOptions = PostgresQleverSemanticHarnessOptions;
export interface SemanticConformanceReport {
    schemaVersion: 1;
    backend: 'sqlite' | 'pg';
    engine: 'local-qlever-prepared-update-authority' | 'pg-qlever-prepared-update-authority' | 'pg-public-rdf-query-authority';
    status: 'ok' | 'failed';
    caseIds: string[];
    skipped: [];
    failed: {
        caseId: string;
        message: string;
    }[];
    results: {
        caseId: string;
        status: 'ok';
        canonical: unknown;
        preparedUpdates: number;
        appliedDelta: {
            deletedRows: number;
            insertedRows: number;
        };
        authority: string;
    }[];
    authorization: {
        deniedRowsObserved: number;
    };
    sourceScope: {
        sourceDeniedValidatedBy: string;
    };
    canonicalDigest: string;
}
export interface SemanticParityResult {
    caseIds: string[];
    canonicalDigest: string;
}
export interface SemanticFixtureModule {
    REQUIRED_CASES: readonly string[];
    semanticConformanceCases: readonly SemanticFixtureCase[];
}
export interface SemanticCaseExecutor {
    prepareAndApplyUpdate(engine: RdfEngineLike, sparql: string, sourceUri: string, timeoutMs: number | undefined): Promise<{
        deletedRows: number;
        insertedRows: number;
    }>;
    query(engine: RdfEngineLike, testCase: SemanticFixtureCase, timeoutMs: number | undefined): Promise<RdfNativeSparqlResult>;
}
export declare function runCaseWithEngine(engine: RdfEngineLike, testCase: SemanticFixtureCase, timeoutMs: number | undefined, authority: string, seedDocuments: boolean | undefined, executor: SemanticCaseExecutor): Promise<SemanticConformanceReport['results'][number]>;
export declare function seedDocument(engine: RdfEngineLike, document: SemanticFixtureCase['documents'][number]): Promise<void>;
export declare function assertSemanticConformanceParity(local: SemanticConformanceReport, cloud: SemanticConformanceReport): SemanticParityResult;
export declare function makeAccessScope(testCase: SemanticFixtureCase): RdfNativeSparqlAccessScope;
export declare function exactQuadPattern(quad: Quad): {
    graph: import("@rdfjs/types").Quad_Graph;
    subject: import("@rdfjs/types").Quad_Subject;
    predicate: import("@rdfjs/types").Quad_Predicate;
    object: import("@rdfjs/types").Quad_Object;
};
export declare function queryOperation(mediaType: string): 'queryBindings' | 'queryQuads';
export declare function validateEnvelope(result: RdfNativeSparqlResult, context: string, mediaType: string): void;
export declare function serializeQuads(quads: AsyncIterable<Quad>): Promise<string>;
export declare function termToSparqlJson(term: Term): Record<string, string>;
export declare function buildSemanticReport(options: {
    backend: SemanticConformanceReport['backend'];
    engine: SemanticConformanceReport['engine'];
    caseIds: readonly string[];
    failed: SemanticConformanceReport['failed'];
    results: SemanticConformanceReport['results'];
    sourceDeniedValidatedBy: string;
}): SemanticConformanceReport;
export declare function assertPath(name: string, value: string): void;
export declare function connectionStringWithSearchPath(connectionString: string, schema: string): string;
export declare function quoteIdentifier(value: string): string;
export declare function slug(value: string): string;
export declare function quadIdentity(quad: Quad): string;