import * as stream from "stream";
import type { NamedNode } from "@rdfjs/types";
import * as n3 from "n3";
import type { Models, Routes } from "@triply/utils";
import AsyncIteratorHelper from "./utils/AsyncIteratorHelper.ts";
import type { Account } from "./Account.ts";
import type App from "./App.ts";
import Asset from "./Asset.ts";
import Graph from "./Graph.ts";
import Service from "./Service.ts";
type JobDefaultsConfig = Omit<Routes.datasets._account._dataset.jobs.Post["Req"]["Body"], "type" | "url" | "downloadUrls">;
interface ImportFromDatasetArgs {
    graphMap?: {
        [from: string]: string | Graph | NamedNode;
    };
    graphNames?: Array<string | Graph | NamedNode>;
    overwrite?: boolean;
}
export type Prefixes = {
    [label: string]: n3.PrefixedToIri | string | NamedNode;
};
type DsResourceType = "assets" | "graphs" | "services";
export type NewService = NewServiceVirtuoso | NewServiceElasticsearch | NewServiceJena;
type NewServiceVirtuoso = {
    type: "virtuoso";
    config?: never;
};
type NewServiceElasticsearch = {
    type: "elasticSearch";
    config?: Models.ServiceConfigElastic;
};
type NewServiceJena = {
    type: "jena";
    config?: Models.ServiceConfigJena;
};
type UploadAssetModes = "throw-if-exists" | "replace-if-exists" | "append-version";
export default class Dataset {
    app: App;
    private _info?;
    owner: Account;
    private _lastJob?;
    slug: string;
    private _allPrefixes;
    readonly type = "Dataset";
    constructor(app: App, owner: Account, datasetInfo: Models.Dataset);
    getServices(): AsyncIteratorHelper<Models.ServiceMetadata, Service>;
    getService<T extends Dataset>(this: T, serviceName: string): Promise<Service>;
    clear(resourceType: DsResourceType, ...rest: DsResourceType[]): Promise<this>;
    get api(): {
        url: string;
        path: string;
    };
    getGraph(graphNameOrIri: string | NamedNode): Promise<Graph>;
    deleteGraph(graphNameOrIri: string | NamedNode): Promise<void>;
    private _setInfo;
    private _getDatasetNameWithOwner;
    getInfo(refresh?: boolean): Promise<Models.Dataset>;
    getAsset(assetName: string, versionNumber?: number): Promise<Asset>;
    getAssets(): AsyncIteratorHelper<Models.Asset, Asset>;
    getGraphs(): AsyncIteratorHelper<Models.Graph, Graph>;
    private _getDownloadPath;
    graphsToFile(destinationPath: string, opts?: {
        compressed?: boolean;
        graph?: Graph;
    }): Promise<void>;
    graphsToStream(type: "compressed" | "rdf-js", opts?: {
        graph?: Graph;
        extension?: string;
    }): Promise<stream.Readable>;
    graphsToStore(graph?: Graph): Promise<n3.Store>;
    importFromDataset(fromDataset: Dataset, args?: ImportFromDatasetArgs): Promise<Models.Imports>;
    update(config: Models.UpdateDataset): Promise<this>;
    copy(toAccountName: string, newDatasetName?: string): Promise<Dataset>;
    renameGraph(from: string, to: string): Promise<Graph>;
    delete(): Promise<void>;
    setAvatar(pathBufferOrFile: string | Buffer | File): Promise<this>;
    private _throwIfJobRunning;
    importFromFiles(files: File[] | string[], defaultsConfig?: JobDefaultsConfig): Promise<Dataset>;
    importFromStore(store: n3.Store, opts?: JobDefaultsConfig): Promise<Dataset>;
    importFromUrls(urls: string[], defaultConfig?: JobDefaultsConfig): Promise<Dataset>;
    describe(iri: string | NamedNode): Promise<n3.Quad[]>;
    getStatements(payload: {
        subject?: string;
        predicate?: string;
        object?: string;
        graph?: string;
    }): AsyncIteratorHelper<Models.NtriplyStatement, Models.NtriplyStatement>;
    uploadAsset(fileOrPath: string | File, opts?: {
        mode?: UploadAssetModes;
        name?: string;
    }): Promise<Asset>;
    uploadAsset(fileOrPath: string | File, name?: string): Promise<Asset>;
    addService(name: string, opts?: NewService): Promise<Service>;
    ensureService<T extends Dataset>(this: T, name: string, args?: NewService): Promise<Service>;
    addPrefixes(newPrefixes: Prefixes): Promise<{
        [prefixLabel: string]: string;
    }>;
    removePrefixes(prefixLabels: string[]): Promise<{
        [prefixLabel: string]: string;
    }>;
    getPrefixes(refresh?: boolean): Promise<{
        [prefixLabel: string]: string;
    }>;
    nde: {
        datasetregister: {
            submit: (rejectOnValidationError?: boolean) => Promise<n3.Quad[]>;
            validate: (rejectOnValidationError?: boolean) => Promise<n3.Quad[]>;
        };
    };
}
interface JobConfig extends JobDefaultsConfig {
    app: App;
    datasetPath: string;
    datasetNameWithOwner: string;
}
export declare class JobUpload {
    private _config;
    private _info?;
    private jobUrl?;
    private urlMapper;
    constructor(conf: JobConfig);
    getJobUrl(): string | undefined;
    create(): Promise<this>;
    info(): Models.IndexJob | undefined;
    private uploadFile;
    uploadFiles(files: string[] | File[]): Promise<this>;
    private refresh;
    exec(): Promise<void>;
}
export {};
//# sourceMappingURL=Dataset.d.ts.map