core-3nweb-client-lib 0.25.6 → 0.26.0

package/build/lib-client/3nstorage/xsp-fs/folder-node.js

@@ -27,7 +27,7 @@ const error_1 = require("../../../lib-common/exceptions/error");
 const node_in_fs_1 = require("./node-in-fs");
 const file_node_1 = require("./file-node");
 const link_node_1 = require("./link-node");
-const processes_1 = require("../../../lib-common/processes");
+const deferred_1 = require("../../../lib-common/processes/deferred");
 const json_utils_1 = require("../../../lib-common/json-utils");
 const xsp_files_1 = require("xsp-files");
 const random = require("../../../lib-common/random-node");
@@ -62,6 +62,17 @@ class FolderPersistance extends node_persistence_1.NodePersistance {
 }
 Object.freeze(FolderPersistance.prototype);
 Object.freeze(FolderPersistance);
+let nextMoveLabel = Math.floor(Math.random() / 2 * Number.MAX_SAFE_INTEGER);
+function getMoveLabel() {
+    const label = nextMoveLabel;
+    if (nextMoveLabel >= Number.MAX_SAFE_INTEGER) {
+        nextMoveLabel = 0;
+    }
+    else {
+        nextMoveLabel += 1;
+    }
+    return label;
+}
 class FolderNode extends node_in_fs_1.NodeInFS {
     constructor(storage, name, objId, zNonce, version, parentId, key, setNewAttrs) {
         super(storage, 'folder', name, objId, version, parentId);
@@ -183,7 +194,7 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         if (nodePromise) {
             return { nodeOrPromise: nodePromise };
         }
-        const deferred = processes_1.defer();
+        const deferred = deferred_1.defer();
         this.storage.nodes.setPromise(objId, deferred.promise);
         return { deferred };
     }
@@ -462,28 +473,30 @@ class FolderNode extends node_in_fs_1.NodeInFS {
         }
         if (dst === this) {
             // In this case we only need to change child's name
-            return this.changeChildName(childName, nameInDst);
+            await this.changeChildName(childName, nameInDst);
+        }
+        else {
+            const childJSON = this.getNodeInfo(childName);
+            // we have two transitions here, in this and in dst.
+            const moveLabel = getMoveLabel();
+            await dst.moveChildIn(nameInDst, childJSON, moveLabel);
+            await this.moveChildOut(childName, moveLabel);
         }
-        const childJSON = this.getNodeInfo(childName);
-        // we have two transitions here, in this and in dst.
-        await Promise.all([
-            await dst.moveChildIn(nameInDst, childJSON),
-            await this.moveChildOut(childName)
-        ]);
     }
-    async moveChildOut(name) {
+    async moveChildOut(name, moveLabel) {
         await this.doTransition(async (state, version) => {
             delete state.nodes[name];
             const event = {
                 type: 'entry-removal',
                 path: this.name,
                 name,
-                newVersion: version
+                newVersion: version,
+                moveLabel
             };
             return event;
         });
     }
-    async moveChildIn(newName, child) {
+    async moveChildIn(newName, child, moveLabel) {
         child = json_utils_1.copy(child);
         await this.doTransition(async (state, version) => {
             child.name = newName;
@@ -497,7 +510,8 @@ class FolderNode extends node_in_fs_1.NodeInFS {
                     isFolder: child.isFolder,
                     isLink: child.isLink
                 },
-                newVersion: version
+                newVersion: version,
+                moveLabel
             };
             return event;
         });

package/build/lib-client/3nstorage/xsp-fs/fs.d.ts

@@ -23,12 +23,14 @@ declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
 export declare class XspFS implements WritableFS {
-    storage: Storage;
-    writable: boolean;
+    readonly writable: boolean;
     name: string;
-    type: FSType;
-    v: V;
+    readonly type: FSType;
+    readonly v: V;
+    private store;
+    private readonly fsObs;
     private constructor();
+    private storage;
     readonlySubRoot(path: string): Promise<ReadonlyFS>;
     writableSubRoot(path: string, flags?: web3n.files.VersionedFileFlags): Promise<WritableFS>;
     /**
@@ -74,6 +76,7 @@ export declare class XspFS implements WritableFS {
     readLink(path: string): Promise<SymLink>;
     getLinkParams(): Promise<LinkParameters<any>>;
     static makeFolderFromLinkParams(storage: Storage, params: LinkParameters<FolderLinkParams>): Promise<ReadonlyFS | WritableFS>;
+    private getCloseEvent$;
     watchFolder(path: string, observer: Observer<FolderEvent>): () => void;
     watchFile(path: string, observer: Observer<FileEvent>): () => void;
     watchTree(path: string, observer: Observer<FolderEvent | FileEvent>): () => void;
@@ -93,8 +96,10 @@ export declare class XspFS implements WritableFS {
 }
 declare type WritableFSVersionedAPI = web3n.files.WritableFSVersionedAPI;
 declare class V implements WritableFSVersionedAPI {
-    root: FolderNode;
-    constructor();
+    private rootNode;
+    constructor(root: FolderNode);
+    close(): void;
+    getRootIfNotClosed(excPath: string): FolderNode;
     getOrCreateFile(path: string, flags: FileFlags): Promise<FileNode>;
     get(path: string): Promise<NodeInFS<any>>;
     updateXAttrs(path: string, changes: XAttrsChanges): Promise<number>;

package/build/lib-client/3nstorage/xsp-fs/fs.js

@@ -31,6 +31,7 @@ const pipe_1 = require("../../../lib-common/byte-streaming/pipe");
 const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
+const utils_for_observables_1 = require("../../../lib-common/utils-for-observables");
 function splitPathIntoParts(path) {
     return path_1.posix.resolve('/', path).split('/').filter(part => !!part);
 }
@@ -55,32 +56,37 @@ const WRITE_NONEXCL_FLAGS = {
     truncate: true
 };
 class XspFS {
-    constructor(storage, writable, name = '') {
-        this.storage = storage;
+    constructor(storage, writable, rootNode, name = '') {
         this.writable = writable;
         this.name = name;
-        this.v = new V();
-        this.type = this.storage.type;
+        this.fsObs = new utils_for_observables_1.Broadcast();
+        this.store = storage;
+        this.type = this.store.type;
+        this.v = new V(rootNode);
         Object.seal(this);
     }
+    storage() {
+        if (!this.store) {
+            throw file_1.makeFileException(file_1.Code.storageClosed, this.name);
+        }
+        return this.store;
+    }
     async readonlySubRoot(path) {
         const pathParts = splitPathIntoParts(path);
-        const folder = await this.v.root.getFolderInThisSubTree(pathParts, false)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(pathParts, false).catch(setExcPath(path));
         const folderName = ((pathParts.length === 0) ?
             this.name : pathParts[pathParts.length - 1]);
-        const fs = new XspFS(this.storage, false, folderName);
-        fs.v.root = folder;
+        const fs = new XspFS(this.storage(), false, folder, folderName);
         return files_1.wrapReadonlyFS(fs);
     }
     async writableSubRoot(path, flags = WRITE_NONEXCL_FLAGS) {
         const pathParts = splitPathIntoParts(path);
-        const folder = await this.v.root.getFolderInThisSubTree(pathParts, flags.create, flags.exclusive)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(pathParts, flags.create, flags.exclusive).catch(setExcPath(path));
         const folderName = ((pathParts.length === 0) ?
             this.name : pathParts[pathParts.length - 1]);
-        const fs = new XspFS(this.storage, true, folderName);
-        fs.v.root = folder;
+        const fs = new XspFS(this.storage(), true, folder, folderName);
         return files_1.wrapWritableFS(fs);
     }
     /**
@@ -90,8 +96,8 @@ class XspFS {
      * @param key is a file key of a root object
      */
     static async makeNewRoot(storage, key) {
-        const fs = new XspFS(storage, true);
-        fs.v.root = await folder_node_1.FolderNode.newRoot(fs.storage, key);
+        const root = await folder_node_1.FolderNode.newRoot(storage, key);
+        const fs = new XspFS(storage, true, root);
         return files_1.wrapWritableFS(fs);
     }
     /**
@@ -101,35 +107,36 @@ class XspFS {
      * @param key is a file key of a root object
      */
     static async fromExistingRoot(storage, key) {
-        const fs = new XspFS(storage, true);
         const objSrc = await storage.getObj(null);
-        fs.v.root = await folder_node_1.FolderNode.rootFromObjBytes(fs.storage, undefined, null, objSrc, key);
+        const root = await folder_node_1.FolderNode.rootFromObjBytes(storage, undefined, null, objSrc, key);
+        const fs = new XspFS(storage, true, root);
         return files_1.wrapWritableFS(fs);
     }
     static fromASMailMsgRootFromJSON(storage, folderJson, rootName) {
-        const fs = new XspFS(storage, false, rootName);
-        fs.v.root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
+        const root = folder_node_1.FolderNode.rootFromJSON(storage, rootName, folderJson);
+        const fs = new XspFS(storage, false, root, rootName);
         return files_1.wrapIntoVersionlessReadonlyFS(fs);
     }
     /**
      * Note that this method doesn't close storage.
      */
     async close() {
-        this.v.root = undefined;
-        this.storage = undefined;
+        this.v.close();
+        this.store = undefined;
+        this.fsObs.done();
     }
     async makeFolder(path, exclusive = false) {
         const folderPath = splitPathIntoParts(path);
-        await this.v.root.getFolderInThisSubTree(folderPath, true, exclusive)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        await root.getFolderInThisSubTree(folderPath, true, exclusive).catch(setExcPath(path));
     }
     select(path, criteria) {
         return files_select_1.selectInFS(this, path, criteria);
     }
     async deleteFolder(path, removeContent = false) {
         const { fileName: folderName, folderPath: parentPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(parentPath)
-            .catch(setExcPath(parentPath.join('/')));
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(parentPath).catch(setExcPath(parentPath.join('/')));
         if (typeof folderName !== 'string') {
             throw new Error('Cannot remove root folder');
         }
@@ -142,18 +149,17 @@ class XspFS {
     }
     async deleteFile(path) {
         const { fileName, folderPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(folderPath)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
         const file = await parentFolder.getFile(fileName)
             .catch(setExcPath(path));
         await parentFolder.removeChild(file);
     }
     async deleteLink(path) {
         const { fileName, folderPath } = split(path);
-        const parentFolder = await this.v.root.getFolderInThisSubTree(folderPath)
-            .catch(setExcPath(path));
-        const link = await parentFolder.getLink(fileName)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const parentFolder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
+        const link = await parentFolder.getLink(fileName).catch(setExcPath(path));
         await parentFolder.removeChild(link);
     }
     async move(initPath, newPath) {
@@ -169,10 +175,11 @@ class XspFS {
         }
         const dstFName = dstFolderPath[dstFolderPath.length - 1];
         dstFolderPath.splice(dstFolderPath.length - 1, 1);
+        const root = this.v.getRootIfNotClosed(initPath);
         try {
-            const srcFolder = await this.v.root.getFolderInThisSubTree(srcFolderPath);
+            const srcFolder = await root.getFolderInThisSubTree(srcFolderPath);
             srcFolder.hasChild(initFName, true);
-            const dstFolder = await this.v.root.getFolderInThisSubTree(dstFolderPath, true);
+            const dstFolder = await root.getFolderInThisSubTree(dstFolderPath, true);
             await srcFolder.moveChildTo(initFName, dstFolder, dstFName);
         }
         catch (exc) {
@@ -190,11 +197,13 @@ class XspFS {
     }
     async stat(path) {
         const node = await this.v.get(path);
+        const sync = await node.sync();
         const attrs = node.getAttrs();
         const stats = {
             ctime: new Date(attrs.ctime),
             mtime: new Date(attrs.mtime),
             version: node.version,
+            sync,
             writable: this.writable,
         };
         if (node.type === 'file') {
@@ -311,21 +320,22 @@ class XspFS {
         }
     }
     ensureLinkingAllowedTo(params) {
-        if (this.storage.type === 'local') {
+        const storage = this.storage();
+        if (storage.type === 'local') {
             return;
         }
-        else if (this.storage.type === 'synced') {
+        else if (storage.type === 'synced') {
             if ((params.storageType === 'share') ||
                 (params.storageType === 'synced')) {
                 return;
             }
         }
-        else if (this.storage.type === 'share') {
+        else if (storage.type === 'share') {
             if (params.storageType === 'share') {
                 return;
             }
         }
-        throw new Error(`Cannot create link to ${params.storageType} from ${this.storage.type} storage.`);
+        throw new Error(`Cannot create link to ${params.storageType} from ${storage.type} storage.`);
     }
     async link(path, target) {
         if (!target ||
@@ -335,20 +345,21 @@ class XspFS {
         const params = await target.getLinkParams();
         this.ensureLinkingAllowedTo(params);
         const { fileName, folderPath } = split(path);
-        const folder = await this.v.root.getFolderInThisSubTree(folderPath, true)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(folderPath, true).catch(setExcPath(path));
         await folder.createLink(fileName, params);
     }
     async readLink(path) {
         const { fileName, folderPath } = split(path);
-        const folder = await this.v.root.getFolderInThisSubTree(folderPath)
-            .catch(setExcPath(path));
+        const root = this.v.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(folderPath).catch(setExcPath(path));
         const link = await folder.getLink(fileName)
             .catch(setExcPath(path));
         return await link.read();
     }
     async getLinkParams() {
-        const linkParams = this.v.root.getParamsForLink();
+        const root = this.v.getRootIfNotClosed(this.name);
+        const linkParams = root.getParamsForLink();
         linkParams.params.folderName = this.name;
         linkParams.readonly = !this.writable;
         return linkParams;
@@ -356,25 +367,48 @@ class XspFS {
     static async makeFolderFromLinkParams(storage, params) {
         const name = params.params.folderName;
         const writable = !params.readonly;
-        const fs = new XspFS(storage, writable, name);
-        fs.v.root = await folder_node_1.FolderNode.rootFromLinkParams(storage, params.params);
+        const root = await folder_node_1.FolderNode.rootFromLinkParams(storage, params.params);
+        const fs = new XspFS(storage, writable, root, name);
         return (fs.writable ? files_1.wrapWritableFS(fs) : files_1.wrapReadonlyFS(fs));
     }
+    getCloseEvent$() {
+        return this.fsObs.event$.pipe(operators_1.filter(ev => (ev === 'close')));
+    }
     watchFolder(path, observer) {
-        const watchSub = rxjs_1.from(this.v.root.getFolderInThisSubTree(splitPathIntoParts(path), false))
-            .pipe(operators_1.mergeMap(f => f.event$))
-            .subscribe(observer);
+        const folderPath = splitPathIntoParts(path);
+        const root = this.v.getRootIfNotClosed(path);
+        const nodeProm = root.getFolderInThisSubTree(folderPath, false);
+        const watchSub = rxjs_1.from(nodeProm)
+            .pipe(operators_1.mergeMap(f => f.event$), operators_1.takeUntil(this.getCloseEvent$()))
+            .subscribe(utils_for_observables_1.toRxObserver(observer));
         return () => watchSub.unsubscribe();
     }
     watchFile(path, observer) {
         const { fileName, folderPath } = split(path);
-        const watchSub = rxjs_1.from(this.v.root.getFolderInThisSubTree(folderPath, false))
-            .pipe(operators_1.mergeMap(folder => folder.getFile(fileName)), operators_1.mergeMap(f => f.event$))
-            .subscribe(observer);
+        const root = this.v.getRootIfNotClosed(path);
+        const nodeProm = root.getFolderInThisSubTree(folderPath, false);
+        const watchSub = rxjs_1.from(nodeProm)
+            .pipe(operators_1.mergeMap(folder => folder.getFile(fileName)), operators_1.mergeMap(f => f.event$), operators_1.takeUntil(this.getCloseEvent$()))
+            .subscribe(utils_for_observables_1.toRxObserver(observer));
         return () => watchSub.unsubscribe();
     }
     watchTree(path, observer) {
-        throw new Error('Not implemented, yet');
+        const folderPath = splitPathIntoParts(path);
+        const root = this.v.getRootIfNotClosed(path);
+        const idToPath = new ObjIdToPathMap();
+        const setupFilterMap = root.getFolderInThisSubTree(folderPath, false)
+            .then(rootNode => idToPath.fillFromTree(rootNode));
+        const watchSub = rxjs_1.from(setupFilterMap)
+            .pipe(operators_1.mergeMap(() => this.storage().getNodeEvents()), operators_1.map(nodeEvent => {
+            const path = idToPath.getPathCorrectingTreeMap(nodeEvent);
+            if (path) {
+                const event = nodeEvent.event;
+                event.path = path;
+                return event;
+            }
+        }, 1), operators_1.filter(event => !!event), operators_1.takeUntil(this.getCloseEvent$()))
+            .subscribe(utils_for_observables_1.toRxObserver(observer));
+        return () => watchSub.unsubscribe();
     }
     async readonlyFile(path) {
         const fNode = await this.v.getOrCreateFile(path, {});
@@ -455,15 +489,23 @@ exports.XspFS = XspFS;
 Object.freeze(XspFS.prototype);
 Object.freeze(XspFS);
 class V {
-    constructor() {
-        this.root = undefined;
+    constructor(root) {
+        this.rootNode = root;
         Object.seal(this);
     }
+    close() {
+        this.rootNode = undefined;
+    }
+    getRootIfNotClosed(excPath) {
+        if (!this.rootNode) {
+            throw file_1.makeFileException(file_1.Code.storageClosed, excPath);
+        }
+        return this.rootNode;
+    }
     async getOrCreateFile(path, flags) {
         const { fileName, folderPath } = split(path);
         const { create, exclusive } = flags;
-        const folder = await this.root.getFolderInThisSubTree(folderPath, create)
-            .catch(setExcPath(path));
+        const folder = await this.getRootIfNotClosed(path).getFolderInThisSubTree(folderPath, create).catch(setExcPath(path));
         const nullOnMissing = create;
         let file = await folder.getFile(fileName, nullOnMissing)
             .catch(setExcPath(path));
@@ -479,10 +521,10 @@ class V {
     }
     async get(path) {
         const { fileName, folderPath } = split(path);
-        const folder = await this.root.getFolderInThisSubTree(folderPath, false)
-            .catch(setExcPath(path));
+        const root = this.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(folderPath, false).catch(setExcPath(path));
         if (fileName === undefined) {
-            return this.root;
+            return root;
         }
         const node = await folder.getNode(undefined, fileName)
             .catch(setExcPath(path));
@@ -505,7 +547,8 @@ class V {
         };
     }
     async listFolder(path) {
-        const folder = await this.root.getFolderInThisSubTree(splitPathIntoParts(path), false).catch(setExcPath(path));
+        const root = this.getRootIfNotClosed(path);
+        const folder = await root.getFolderInThisSubTree(splitPathIntoParts(path), false).catch(setExcPath(path));
         return folder.list();
     }
     async writeBytes(path, bytes, flags = WRITE_NONEXCL_FLAGS) {
@@ -555,4 +598,92 @@ class V {
 }
 Object.freeze(V.prototype);
 Object.freeze(V);
+class ObjIdToPathMap {
+    constructor() {
+        this.map = new Map();
+        this.moves = new Map();
+        Object.seal(this);
+    }
+    async fillFromTree(root) {
+        for (const [objId, path] of await recursiveIdAndPathList(root, '.')) {
+            this.map.set(objId, path);
+        }
+    }
+    getPathCorrectingTreeMap({ event, objId, parentObjId }) {
+        let path = this.map.get(objId);
+        if (path) {
+            if (event.type === 'removed') {
+                this.map.delete(objId);
+            }
+            else if (event.type === 'entry-renaming') {
+                const { newName, oldName } = event;
+                const child = this.findObjIdByPath(`${path}/${oldName}`);
+                if (child) {
+                    this.map.set(child, `${path}/${newName}`);
+                }
+            }
+            else if (event.type === 'entry-removal') {
+                const { moveLabel, name } = event;
+                if (moveLabel) {
+                    const child = this.findObjIdByPath(`${path}/${name}`);
+                    if (child) {
+                        const moveInfo = this.moves.get(moveLabel);
+                        if (moveInfo) {
+                            this.map.set(child, moveInfo.newPath);
+                            this.moves.delete(moveLabel);
+                        }
+                        else {
+                            this.moves.set(moveLabel, { objId: child });
+                        }
+                    }
+                }
+            }
+            else if (event.type === 'entry-addition') {
+                const { moveLabel, entry: { name } } = event;
+                const newPath = `${path}/${name}`;
+                if (moveLabel) {
+                    const moveInfo = this.moves.get(moveLabel);
+                    if (moveInfo) {
+                        this.map.set(moveInfo.objId, newPath);
+                        this.moves.delete(moveLabel);
+                    }
+                    else {
+                        this.moves.set(moveLabel, { newPath });
+                    }
+                }
+            }
+            return path;
+        }
+        const parentPath = this.map.get(parentObjId);
+        if (!parentPath || (event.type === 'removed')) {
+            return;
+        }
+        path = `${parentPath}/${event.path}`;
+        this.map.set(objId, path);
+        return path;
+    }
+    findObjIdByPath(path) {
+        for (const [objId, p] of this.map.entries()) {
+            if (p === path) {
+                return objId;
+            }
+        }
+    }
+}
+Object.freeze(ObjIdToPathMap.prototype);
+Object.freeze(ObjIdToPathMap);
+async function recursiveIdAndPathList(folder, path) {
+    const { lst } = folder.list();
+    const idAndPaths = [[folder.objId, path]];
+    for (const item of lst) {
+        if (item.isFile || item.isLink) {
+        }
+        else if (item.isFolder) {
+            const child = await folder.getFolder(item.name);
+            const childLst = await recursiveIdAndPathList(child, `${path}/${item.name}`);
+            idAndPaths.push(...childLst);
+        }
+    }
+    return idAndPaths;
+}
 Object.freeze(exports);

package/build/lib-client/3nstorage/xsp-fs/node-in-fs.d.ts

@@ -2,8 +2,10 @@ import { Node, NodeType, Storage, RemoteEvent } from './common';
 import { Observable } from 'rxjs';
 import { CommonAttrs, XAttrs } from './attrs';
 import { NodePersistance } from './node-persistence';
+import { UpSyncTaskInfo } from '../../../core/storage/synced/obj-status';
 export declare type FSEvent = web3n.files.FolderEvent | web3n.files.FileEvent;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
+declare type Stats = web3n.files.Stats;
 export declare abstract class NodeInFS<P extends NodePersistance> implements Node {
     protected readonly storage: Storage;
     readonly type: NodeType;
@@ -34,6 +36,7 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
     private bufferRemoteEvent;
     private getBufferedEvent;
     localDelete(): Promise<void>;
+    broadcastUpSyncEvent(task: UpSyncTaskInfo): void;
     /**
      * This non-synchronized method deletes object from storage, and detaches
      * this node from storage. Make sure to call it inside access synchronization
@@ -71,5 +74,6 @@ export declare abstract class NodeInFS<P extends NodePersistance> implements Nod
      */
     private events;
     get event$(): Observable<FSEvent>;
+    sync(): Promise<Stats['sync']>;
 }
 export {};