import type { IncomingHttpHeaders, IncomingMessage, OutgoingHttpHeaders } from 'node:http';
import type { parse } from 'node:querystring';
import type { ReadableStream } from 'node:stream/web';
import type { DatasetCore, NamedNode, Quad, Stream, Term } from '@rdfjs/types';
import type { GraphPointer, MultiPointer } from 'clownface';
import type { Options as EndpointOptions, StreamClient } from 'sparql-http-client/StreamClient.js';
import type { ParsingClient } from 'sparql-http-client/ParsingClient.js';
import type { Client } from 'sparql-http-client';
import type { KopflosEnvironment } from './env/index.js';
import type { ResourceShapeLookup, ResourceShapeMatch } from './resourceShape.js';
import type { ResourceLoader, ResourceLoaderLookup } from './resourceLoader.js';
import type { Handler, HandlerLookup } from './handler.js';
import type { HttpMethod } from './httpMethods.js';
import type { DecoratorLookup } from './decorators.js';
declare module '@rdfjs/types' {
    interface Stream extends AsyncIterable<Quad> {
    }
}
type Dataset = ReturnType<KopflosEnvironment['dataset']>;
export interface Body<D extends DatasetCore = Dataset> {
    isRDF: boolean;
    quadStream: Stream;
    dataset: Promise<D>;
    pointer(): Promise<GraphPointer<NamedNode, D>>;
    raw: IncomingMessage;
}
export type Query = ReturnType<typeof parse>;
interface KopflosRequest<D extends DatasetCore = DatasetCore> {
    iri: NamedNode;
    method: HttpMethod;
    headers: IncomingHttpHeaders;
    body: Body<D>;
    query: Query;
}
type ResultBody = Stream | DatasetCore | GraphPointer | Error | ReadableStream;
export interface ResultEnvelope {
    body?: ResultBody | string;
    status?: number;
    headers?: OutgoingHttpHeaders;
    end?: boolean;
}
export type KopflosResponse = ResultBody | ResultEnvelope;
export interface KopflosPlugin {
    readonly name?: string;
    onStart?(instance: Kopflos): Promise<void> | void;
    onReady?(instance: Kopflos): Promise<void> | void;
    onStop?(instance: Kopflos): Promise<void> | void;
    apiTriples?(instance: Kopflos): Promise<DatasetCore | Stream> | DatasetCore | Stream;
    apiGraphs?(instance: Kopflos): Array<NamedNode | string>;
    watchPaths?(instance: Kopflos): Array<string>;
    build?: (env: KopflosEnvironment, plugins: readonly KopflosPlugin[]) => Promise<void> | void;
}
export interface Plugins extends Record<string, KopflosPlugin> {
}
export interface Kopflos<D extends DatasetCore = Dataset> {
    get dataset(): D;
    get env(): KopflosEnvironment;
    get apis(): MultiPointer<Term, D>;
    get plugins(): ReadonlyArray<KopflosPlugin>;
    get start(): () => Promise<void>;
    getPlugin<N extends keyof Plugins>(name: N): Plugins[N] | undefined;
    handleRequest(req: KopflosRequest<D>): Promise<ResultEnvelope>;
    loadApiGraphs(): Promise<void>;
}
interface Clients {
    stream: StreamClient;
    parsed: ParsingClient;
}
type Endpoint = string | EndpointOptions | Clients | Client;
export interface Variables {
    [key: string]: unknown;
}
export interface KopflosConfig {
    [key: string]: unknown;
    mode?: 'development' | 'production';
    baseIri: string;
    apiPath?: string;
    buildDir?: string;
    sparql: Record<string, Endpoint> & {
        default: Endpoint;
    };
    codeBase?: string;
    apiGraphs?: Array<NamedNode | string>;
    plugins?: KopflosPlugin[];
    variables?: Variables;
}
export interface Options {
    dataset?: DatasetCore;
    resourceShapeLookup?: ResourceShapeLookup;
    resourceLoaderLookup?: ResourceLoaderLookup;
    decoratorLookup?: DecoratorLookup;
    handlerLookup?: HandlerLookup;
    basePath?: string;
}
export default class Impl implements Kopflos {
    private readonly options;
    readonly apiGraphs: Array<NamedNode | string>;
    readonly dataset: Dataset;
    readonly env: KopflosEnvironment;
    readonly plugins: Array<KopflosPlugin>;
    readonly start: () => Promise<void>;
    readonly ready: () => Promise<void>;
    private decorators;
    constructor({ variables, plugins, apiPath, ...config }: KopflosConfig, options?: Options);
    get graph(): import("clownface").AnyPointer<import("clownface").AnyContext, import("@zazuko/env/lib/DatasetExt.js").Dataset>;
    get apis(): MultiPointer<Term, Dataset>;
    getPlugin<N extends keyof Plugins>(name: N): Plugins[N] | undefined;
    getResponse(req: KopflosRequest<Dataset>): Promise<KopflosResponse>;
    private applicableDecorators;
    handleRequest(req: KopflosRequest<Dataset>): Promise<ResultEnvelope>;
    findResourceShape(iri: NamedNode): Promise<ResourceShapeMatch | KopflosResponse>;
    findResourceLoader(resourceShape: GraphPointer): Promise<ResourceLoader | KopflosResponse>;
    loadHandlerChain(method: HttpMethod, resourceShapeMatch: ResourceShapeMatch, coreRepresentation: Stream): Promise<[GraphPointer, Handler[]] | KopflosResponse>;
    private isEnvelope;
    private asEnvelope;
    loadApiGraphs(): Promise<void>;
    stop(): Promise<void>;
}
export {};