import IndexedFormula from './store';
import Fetcher, { Options } from './fetcher';
import Statement from './statement';
import RDFlibNamedNode from './named-node';
import { BlankNode, NamedNode, Quad, Quad_Subject, Term } from './tf-types';
interface UpdateManagerFormula extends IndexedFormula {
    fetcher: Fetcher;
}
type CallBackFunction = (uri: string, ok: boolean, message: string, response: Error | Response) => {} | void;
/**
* The UpdateManager is a helper object for a store.
* Just as a Fetcher provides the store with the ability to read and write,
* the Update Manager provides functionality for making small patches in real time,
* and also looking out for concurrent updates from other agents
*/
export default class UpdateManager {
    store: UpdateManagerFormula;
    ifps: {};
    fps: {};
    /** Index of objects for coordinating incoming and outgoing patches */
    patchControl: [];
    /** Object of namespaces */
    ns: any;
    /**
     * @param  store - The quadstore to store data and metadata. Created if not passed.
    */
    constructor(store?: IndexedFormula);
    patchControlFor(doc: NamedNode): any;
    isHttpUri(uri: string): boolean;
    /** Remove from the store HTTP authorization metadata
    * The editable function below relies on copies we have in the store
    * of the results of previous HTTP transactions. However, when
    * the user logs in, then that data misrepresents what would happen
    * if the user tried again.
    */
    flagAuthorizationMetadata(kb?: IndexedFormula): void;
    /**
     * Tests whether a file is editable.
     * If the file has a specific annotation that it is machine written,
     * for safety, it is editable (this doesn't actually check for write access)
     * If the file has wac-allow and accept patch headers, those are respected.
     * and local write access is determined by those headers.
     * This async version not only looks at past HTTP requests, it also makes new ones if necessary.
     *
     * @returns The method string N3PATCH or SPARQL or DAV or
     *   LOCALFILE or false if known, undefined if not known.
     */
    checkEditable(uri: string | NamedNode, kb?: IndexedFormula): Promise<string | boolean | undefined>;
    /**
     * Tests whether a file is editable.
     * If the file has a specific annotation that it is machine written,
     * for safety, it is editable (this doesn't actually check for write access)
     * If the file has wac-allow and accept patch headers, those are respected.
     * and local write access is determined by those headers.
     * This synchronous version only looks at past HTTP requests, does not make new ones.
     *
     * @returns The method string SPARQL or DAV or
     *   LOCALFILE or false if known, undefined if not known.
     */
    editable(uri: string | NamedNode, kb?: IndexedFormula): string | boolean | undefined;
    anonymize(obj: any): any;
    anonymizeNT(stmt: Quad): string;
    nTriples(stmt: any): string;
    /**
     * Returns a list of all bnodes occurring in a statement
     * @private
     */
    statementBnodes(st: Quad): BlankNode[];
    /**
     * Returns a list of all bnodes occurring in a list of statements
     * @private
     */
    statementArrayBnodes(sts: ReadonlyArray<Quad>): BlankNode[];
    /**
     * Makes a cached list of [Inverse-]Functional properties
     * @private
     */
    cacheIfps(): void;
    /**
     * Returns a context to bind a given node, up to a given depth
     * @private
     */
    bnodeContext2(x: any, source: any, depth: any): any;
    /**
     * Returns the smallest context to bind a given single bnode
     * @private
     */
    bnodeContext1(x: any, source: any): any;
    /**
     * @private
     */
    mentioned(x: any): boolean;
    /**
     * @private
     */
    bnodeContext(bnodes: any, doc: any): never[];
    /**
     * Returns the best context for a single statement
     * @private
     */
    statementContext(st: Quad): never[];
    /**
     * @private
     */
    contextWhere(context: any): string;
    /**
     * @private
     */
    fire(uri: string, query: string, callbackFunction: CallBackFunction, options?: Options): Promise<void>;
    /** return a statemnet updating function
     *
     * This does NOT update the statement.
     * It returns an object which includes
     *  function which can be used to change the object of the statement.
     */
    update_statement(statement: Quad): {
        statement: Term[] | undefined;
        statementNT: string | undefined;
        where: string;
        set_object: (obj: any, callbackFunction: any) => void;
    } | undefined;
    insert_statement(st: Quad, callbackFunction: CallBackFunction): void;
    delete_statement(st: Quad | Quad[], callbackFunction: CallBackFunction): void;
    /**
     * Requests a now or future action to refresh changes coming downstream
     * This is designed to allow the system to re-request the server version,
     * when a websocket has pinged to say there are changes.
     * If the websocket, by contrast, has sent a patch, then this may not be necessary.
     *
     * @param doc
     * @param action
     */
    requestDownstreamAction(doc: NamedNode, action: any): void;
    /**
     * We want to start counting websocket notifications
     * to distinguish the ones from others from our own.
     */
    clearUpstreamCount(doc: NamedNode): void;
    getUpdatesVia(doc: NamedNode): string | null;
    addDownstreamChangeListener(doc: NamedNode, listener: any): void;
    reloadAndSync(doc: NamedNode): void;
    /**
     * Sets up websocket to listen on
     *
     * There is coordination between upstream changes and downstream ones
     * so that a reload is not done in the middle of an upstream patch.
     * If you use this API then you get called when a change happens, and you
     * have to reload the file yourself, and then refresh the UI.
     * Alternative is addDownstreamChangeListener(), where you do not
     * have to do the reload yourself. Do mot mix them.
     *
     * kb contains the HTTP  metadata from previous operations
     *
     * @param doc
     * @param handler
     *
     * @returns {boolean}
     */
    setRefreshHandler(doc: NamedNode, handler: any): boolean;
    /**
     * This high-level function updates the local store iff the web is changed successfully.
     * Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause).
     * The `why` property of each statement must be the give the web document to be updated.
     * The statements to be deleted and inserted may span more than one web document.
     * @param deletions - Statement or statements to be deleted.
     * @param insertions - Statement or statements to be inserted.
     * @returns a promise
     */
    updateMany(deletions: ReadonlyArray<Statement>, insertions?: ReadonlyArray<Statement>): Promise<void[]>;
    /**
     * @private
     *
     * This helper function constructs SPARQL Update query from resolved arguments.
     *
     * @param ds: deletions array.
     * @param is: insertions array.
     * @param bnodes_context: Additional context to uniquely identify any blank nodes.
     */
    constructSparqlUpdateQuery(ds: ReadonlyArray<Statement>, is: ReadonlyArray<Statement>, bnodes_context: any): string;
    /**
     * @private
     *
     * This helper function constructs n3-patch query from resolved arguments.
     *
     * @param ds: deletions array.
     * @param is: insertions array.
     * @param bnodes_context: Additional context to uniquely identify any blanknodes.
     */
    constructN3PatchQuery(ds: ReadonlyArray<Statement>, is: ReadonlyArray<Statement>, bnodes_context: any): string;
    /**
     * This high-level function updates the local store if the web is changed successfully.
     * Deletions, insertions may be undefined or single statements or lists or formulae (may contain bnodes which can be indirectly identified by a where clause).
     * The `why` property of each statement must be the same and give the web document to be updated.
     * @param deletions - Statement or statements to be deleted.
     * @param insertions - Statement or statements to be inserted.
     * @param callback - called as callbackFunction(uri, success, errorbody)
     *           OR returns a promise
     * @param options - Options for the fetch call
     */
    update(deletions: ReadonlyArray<Statement>, insertions: ReadonlyArray<Statement>, callback?: (uri: string | undefined | null, success: boolean, errorBody?: string, response?: Response | Error) => void, secondTry?: boolean, options?: Options): void | Promise<void>;
    updateDav(doc: Quad_Subject, ds: any, is: any, callbackFunction: any, options?: Options): null | Promise<void>;
    /**
     * Likely deprecated, since this lib no longer deals with browser extension
     *
     * @param doc
     * @param ds
     * @param is
     * @param callbackFunction
     * @param options
     */
    updateLocalFile(doc: NamedNode, ds: any, is: any, callbackFunction: any, options?: Options): void;
    /**
     * @throws {Error} On unsupported content type
     *
     * @returns {string}
     */
    serialize(uri: string, data: string | Quad[], contentType: string): string;
    /**
     * This is suitable for an initial creation of a document.
     */
    put(doc: RDFlibNamedNode, data: string | Quad[], contentType: string, callback: (uri: string, ok: boolean, errorMessage?: string, response?: unknown) => void): Promise<void>;
    /**
     * Reloads a document.
     *
     * Fast and cheap, no metadata. Measure times for the document.
     * Load it provisionally.
     * Don't delete the statements before the load, or it will leave a broken
     * document in the meantime.
     *
     * @param kb
     * @param doc {RDFlibNamedNode}
     * @param callbackFunction
     */
    reload(kb: IndexedFormula, doc: docReloadType, callbackFunction: (ok: boolean, message?: string, response?: Error | Response) => {} | void): void;
}
interface docReloadType extends NamedNode {
    reloadTimeCount?: number;
    reloadTimeTotal?: number;
}
export {};