/// <reference types="node" />
import type { EventEmitter } from 'events';
import type { SinkMap } from '@rdf-esm/sink-map';
import type { RdfResource } from '@tpluscode/rdfine';
import type { DatasetIndexed } from 'rdf-dataset-indexed/dataset';
import type { DatasetCore, NamedNode, Stream } from 'rdf-js';
import type { ResourceCacheStrategy } from './ResourceCacheStrategy';
import type { ResourceRepresentation } from './ResourceRepresentation';
import type { ApiDocumentation, HydraResource } from './Resources';
import type { Operation } from './Resources/Operation';
import type { ResourceStore } from './ResourceStore';
import type { ResponseWrapper } from './ResponseWrapper';
import type { RootNodeCandidate } from './RootSelectors';
declare type InvokedOperation = Pick<Operation, 'method'> & {
    target: Pick<HydraResource, 'id'>;
};
export interface HydraResponse<D extends DatasetCore = DatasetCore, T extends RdfResource<D> = HydraResource<D>> {
    representation?: ResourceRepresentation<D, T>;
    response?: ResponseWrapper;
}
export interface HydraClient<D extends DatasetIndexed = DatasetIndexed> {
    log: (msg: string) => void;
    baseUri?: string;
    rootSelectors: [string, RootNodeCandidate][];
    parsers: SinkMap<EventEmitter, Stream>;
    loadResource<T extends RdfResource<D> = HydraResource<D>>(uri: string | NamedNode, headers?: HeadersInit): Promise<HydraResponse<D, T>>;
    loadDocumentation(uri: string | NamedNode, headers?: HeadersInit): Promise<ApiDocumentation<D> | null>;
    invokeOperation(operation: InvokedOperation, headers?: HeadersInit, body?: BodyInit): Promise<HydraResponse<D>>;
    defaultHeaders: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
    resources: ResourceStore<D>;
    apiDocumentations: ResourceRepresentation<D, ApiDocumentation<D>>[];
    cacheStrategy: ResourceCacheStrategy;
}
interface AlcaeusInit<D extends DatasetIndexed> {
    rootSelectors: [string, RootNodeCandidate][];
    resources: ResourceStore<D>;
    datasetFactory: () => D;
    parsers?: SinkMap<EventEmitter, Stream>;
    fetch: typeof fetch;
    Headers: typeof Headers;
}
export declare class Alcaeus<D extends DatasetIndexed> implements HydraClient<D> {
    baseUri?: string;
    rootSelectors: [string, RootNodeCandidate][];
    parsers: SinkMap<EventEmitter, Stream>;
    defaultHeaders: HeadersInit | (() => HeadersInit | Promise<HeadersInit>);
    log: (msg: string) => void;
    cacheStrategy: ResourceCacheStrategy;
    readonly resources: ResourceStore<D>;
    private readonly __apiDocumentations;
    private readonly datasetFactory;
    private readonly _fetch;
    private readonly _headers;
    constructor(init: AlcaeusInit<D>);
    get apiDocumentations(): ResourceRepresentation<D, ApiDocumentation<D>>[];
    loadResource<T extends RdfResource<D>>(id: string | NamedNode, headers?: HeadersInit, dereferenceApiDocumentation?: boolean): Promise<HydraResponse<D, T>>;
    loadDocumentation(id: string | NamedNode, headers?: HeadersInit): Promise<ApiDocumentation<D> | null>;
    invokeOperation(operation: InvokedOperation, headers: HeadersInit, body?: BodyInit): Promise<HydraResponse<D>>;
    private __getApiDocumentation;
    private __mergeHeaders;
    private __findRootResource;
}
export {};
//# sourceMappingURL=alcaeus.d.ts.map