core-3nweb-client-lib 0.26.1 → 0.27.3

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

@@ -16,7 +16,7 @@
  this program. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapSyncStorageImplementation = exports.wrapStorageImplementation = exports.NodesContainer = void 0;
+exports.setPathInExc = exports.isSyncedStorage = exports.wrapSyncStorageImplementation = exports.wrapStorageImplementation = exports.NodesContainer = void 0;
 /**
  * This is a container for file system nodes.
  *
@@ -98,14 +98,16 @@ function wrapStorageImplementation(impl) {
         type: impl.type,
         versioned: impl.versioned,
         nodes: impl.nodes,
+        logError: impl.logError,
         getNodeEvents: impl.getNodeEvents.bind(impl),
         broadcastNodeEvent: impl.broadcastNodeEvent.bind(impl),
         storageForLinking: impl.storageForLinking.bind(impl),
         generateNewObjId: impl.generateNewObjId.bind(impl),
-        getObj: impl.getObj.bind(impl),
+        getObjSrc: impl.getObjSrc.bind(impl),
         saveObj: impl.saveObj.bind(impl),
         close: impl.close.bind(impl),
         removeObj: impl.removeObj.bind(impl),
+        status: impl.status.bind(impl),
         cryptor: impl.cryptor
     };
     return Object.freeze(wrap);
@@ -113,24 +115,33 @@ function wrapStorageImplementation(impl) {
 exports.wrapStorageImplementation = wrapStorageImplementation;
 function wrapSyncStorageImplementation(impl) {
     const storageWrap = wrapStorageImplementation(impl);
-    const wrap = {
-        type: storageWrap.type,
-        versioned: storageWrap.versioned,
-        close: storageWrap.close,
-        cryptor: storageWrap.cryptor,
-        generateNewObjId: storageWrap.generateNewObjId,
-        getObj: storageWrap.getObj,
-        nodes: storageWrap.nodes,
-        getNodeEvents: storageWrap.getNodeEvents,
-        broadcastNodeEvent: storageWrap.broadcastNodeEvent,
-        removeObj: storageWrap.removeObj,
-        saveObj: storageWrap.saveObj,
-        storageForLinking: storageWrap.storageForLinking,
-        getRootKeyDerivParamsFromServer: impl.getRootKeyDerivParamsFromServer.bind(impl),
-        getRemoteConflictObjVersion: impl.getRemoteConflictObjVersion.bind(impl),
-        getObjSyncInfo: impl.getObjSyncInfo.bind(impl)
-    };
+    const wrap = {};
+    for (const [field, value] of Object.entries(storageWrap)) {
+        wrap[field] = value;
+    }
+    wrap.getRootKeyDerivParamsFromServer =
+        impl.getRootKeyDerivParamsFromServer.bind(impl);
+    wrap.getObjSrcOfRemoteVersion = impl.getObjSrcOfRemoteVersion.bind(impl);
+    wrap.archiveVersionOnServer = impl.archiveVersionOnServer.bind(impl);
+    wrap.isRemoteVersionOnDisk = impl.isRemoteVersionOnDisk.bind(impl);
+    wrap.download = impl.download.bind(impl);
+    wrap.upload = impl.upload.bind(impl);
+    wrap.uploadObjRemoval = impl.uploadObjRemoval.bind(impl);
+    wrap.dropCachedLocalObjVersionsLessOrEqual = impl.dropCachedLocalObjVersionsLessOrEqual.bind(impl);
+    wrap.adoptRemote = impl.adoptRemote.bind(impl);
+    wrap.updateStatusInfo = impl.updateStatusInfo.bind(impl);
     return Object.freeze(wrap);
 }
 exports.wrapSyncStorageImplementation = wrapSyncStorageImplementation;
+function isSyncedStorage(storage) {
+    return !!storage.upload;
+}
+exports.isSyncedStorage = isSyncedStorage;
+function setPathInExc(exc, path) {
+    if ((exc.type === 'fs-sync') || (exc.type === 'file')) {
+        exc.path = path;
+    }
+    return exc;
+}
+exports.setPathInExc = setPathInExc;
 Object.freeze(exports);

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

@@ -45,6 +45,7 @@ export declare class FileNode extends NodeInFS<FilePersistance> {
     static makeForExisting(storage: Storage, parentId: string, fileName: string, objId: string, key: Uint8Array): Promise<FileNode>;
     static makeFromLinkParams(storage: Storage, params: FileLinkParams): Promise<FileNode>;
     private static initWithAttrs;
+    protected setCurrentStateFrom(src: ObjSource): Promise<void>;
     private setUpdatedState;
     get size(): number;
     readSrc(): Promise<{

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

@@ -97,7 +97,7 @@ class FileNode extends node_in_fs_1.NodeInFS {
         if (!fileName || !objId) {
             throw new Error("Bad file parameter(s) given");
         }
-        this.crypto = new FilePersistance(xsp_files_1.idToHeaderNonce(this.objId), key, this.storage.cryptor);
+        this.crypto = new FilePersistance((0, xsp_files_1.idToHeaderNonce)(this.objId), key, this.storage.cryptor);
         Object.seal(this);
     }
     static async makeForNew(storage, parentId, name, key) {
@@ -123,12 +123,15 @@ class FileNode extends node_in_fs_1.NodeInFS {
         return file;
     }
     static async initWithAttrs(storage, parentId, fileName, objId, key) {
-        const src = await storage.getObj(objId);
+        const src = await storage.getObjSrc(objId);
         const file = new FileNode(storage, fileName, objId, src.version, parentId, key);
-        const fileAttrs = await file.crypto.getAttrs(src);
-        file.setUpdatedState(src.version, fileAttrs);
+        await file.setCurrentStateFrom(src);
         return file;
     }
+    async setCurrentStateFrom(src) {
+        const fileAttrs = await this.crypto.getAttrs(src);
+        this.setUpdatedState(src.version, fileAttrs);
+    }
     setUpdatedState(version, fileAttrs) {
         this.fileSize = fileAttrs.size;
         super.setUpdatedParams(version, fileAttrs.attrs, fileAttrs.xattrs);
@@ -137,7 +140,7 @@ class FileNode extends node_in_fs_1.NodeInFS {
         return this.fileSize;
     }
     async readSrc() {
-        const objSrc = await this.storage.getObj(this.objId);
+        const objSrc = await this.storage.getObjSrc(this.objId);
         if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
             const version = objSrc.version;
             if (this.version < version) {
@@ -157,7 +160,7 @@ class FileNode extends node_in_fs_1.NodeInFS {
         }
     }
     async readBytes(start, end) {
-        const objSrc = await this.storage.getObj(this.objId);
+        const objSrc = await this.storage.getObjSrc(this.objId);
         if ((this.storage.type === 'synced') || (this.storage.type === 'local')) {
             const version = objSrc.version;
             if (this.version < version) {
@@ -177,8 +180,8 @@ class FileNode extends node_in_fs_1.NodeInFS {
         }
     }
     async writeSink(truncate, currentVersion, changes) {
-        const deferredSink = deferred_1.defer();
-        const newSize = deferred_1.defer();
+        const deferredSink = (0, deferred_1.defer)();
+        const newSize = (0, deferred_1.defer)();
         let version = 0; // need to set any value to satisfy compiler
         const completion = this.doChange(false, async () => {
             const { attrs, xattrs, newVersion, sinkPromise, sub } = await this.startMakingSinkInsideChange(truncate, currentVersion, changes);
@@ -194,12 +197,12 @@ class FileNode extends node_in_fs_1.NodeInFS {
             }),
             completion
         ]);
-        assert_1.assert(!!sink);
+        (0, assert_1.assert)(!!sink);
         // sink's done should await completion of obj saving, and
         // error in obj saving should cancel sink
         const originalDone = sink.done;
         completion.catch(originalDone);
-        assert_1.assert(!Object.isFrozen(sink), `Can't mutate frozen sink`);
+        (0, assert_1.assert)(!Object.isFrozen(sink), `Can't mutate frozen sink`);
         sink.done = async (err) => {
             if (err) {
                 newSize.resolve(0);
@@ -218,12 +221,12 @@ class FileNode extends node_in_fs_1.NodeInFS {
     async startMakingSinkInsideChange(truncate, currentVersion, changes) {
         if ((typeof currentVersion === 'number')
             && (this.version !== currentVersion)) {
-            throw file_1.makeVersionMismatchExc(this.name);
+            throw (0, file_1.makeVersionMismatchExc)(this.name);
         }
         const { attrs, xattrs, newVersion } = super.getParamsForUpdate(changes);
         const base = ((truncate || (this.version === 0)) ?
             undefined :
-            await this.storage.getObj(this.objId));
+            await this.storage.getObjSrc(this.objId));
         const { sinkPromise, sub } = await this.crypto.getFileSink(newVersion, attrs, xattrs, base);
         return { attrs, xattrs, newVersion, sinkPromise, sub };
     }
@@ -234,6 +237,7 @@ class FileNode extends node_in_fs_1.NodeInFS {
         this.broadcastEvent({
             type: 'file-change',
             path: this.name,
+            src: 'local',
             newVersion
         });
     }
@@ -242,7 +246,7 @@ class FileNode extends node_in_fs_1.NodeInFS {
             const { attrs, xattrs, newVersion } = super.getParamsForUpdate(changes);
             const encSub = await this.crypto.saveBytes(bytes, newVersion, attrs, xattrs);
             const newSize = Promise.resolve(Array.isArray(bytes) ?
-                buffer_utils_1.byteLengthIn(bytes) : bytes.length);
+                (0, buffer_utils_1.byteLengthIn)(bytes) : bytes.length);
             await this.savingObjInsideChange(attrs, newSize, xattrs, newVersion, encSub);
             return this.version;
         });

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

@@ -10,6 +10,11 @@ declare type Observer<T> = web3n.Observer<T>;
 declare type FileByteSource = web3n.files.FileByteSource;
 declare type FileByteSink = web3n.files.FileByteSink;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
+declare type WritableFileSyncAPI = web3n.files.WritableFileSyncAPI;
+declare type SyncStatus = web3n.files.SyncStatus;
+declare type WritableFileVersionedAPI = web3n.files.WritableFileVersionedAPI;
+declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
+declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 export declare class FileObject implements WritableFile, Linkable {
     name: string;
     isNew: boolean;
@@ -17,7 +22,7 @@ export declare class FileObject implements WritableFile, Linkable {
     v: V;
     private constructor();
     static makeExisting(node: FileNode, writable: boolean): WritableFile | ReadonlyFile;
-    static makeForNotExisiting(name: string, makeNode: () => Promise<FileNode>): WritableFile;
+    static makeForNotExisiting(name: string, makeNode: () => Promise<FileNode>, isInSyncedStorage: boolean): WritableFile;
     static makeFileFromLinkParams(storage: Storage, params: LinkParameters<FileLinkParams>): Promise<WritableFile | ReadonlyFile>;
     getLinkParams(): Promise<LinkParameters<FileLinkParams>>;
     stat(): Promise<Stats>;
@@ -35,14 +40,19 @@ export declare class FileObject implements WritableFile, Linkable {
     getByteSink(truncate?: boolean): Promise<FileByteSink>;
     copy(file: File): Promise<void>;
 }
-declare type WritableFileVersionedAPI = web3n.files.WritableFileVersionedAPI;
-declare class V implements WritableFileVersionedAPI {
+interface N {
+    getNode(): Promise<FileNode>;
+    ensureIsWritable(): void;
+}
+declare class V implements WritableFileVersionedAPI, N {
     name: string;
     node: FileNode | undefined;
     private makeOrGetNode;
-    writable: boolean;
-    constructor(name: string, node: FileNode | undefined, makeOrGetNode: (() => Promise<FileNode>) | undefined, writable: boolean);
-    private getNode;
+    readonly writable: boolean;
+    readonly sync: undefined | S;
+    constructor(name: string, node: FileNode | undefined, makeOrGetNode: (() => Promise<FileNode>) | undefined, writable: boolean, isInSyncedStorage: boolean);
+    getNode(): Promise<FileNode>;
+    ensureIsWritable(): void;
     updateXAttrs(changes: XAttrsChanges): Promise<number>;
     getXAttr(xaName: string): Promise<{
         attr: any;
@@ -77,5 +87,20 @@ declare class V implements WritableFileVersionedAPI {
         json: T;
         version: number;
     }>;
+    archiveCurrent(version?: number): Promise<number>;
+    listVersions(): Promise<{
+        current?: number;
+        archived?: number[];
+    }>;
+}
+declare class S implements WritableFileSyncAPI {
+    private readonly n;
+    constructor(n: N);
+    upload(opts?: OptionsToUploadLocal): Promise<void>;
+    status(): Promise<SyncStatus>;
+    updateStatusInfo(): Promise<SyncStatus>;
+    isRemoteVersionOnDisk(version: number): Promise<'complete' | 'partial' | 'none'>;
+    download(version: number): Promise<void>;
+    adoptRemote(opts?: OptionsToAdopteRemote): Promise<void>;
 }
 export {};

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

@@ -28,46 +28,39 @@ const buffer_utils_1 = require("../../../lib-common/buffer-utils");
 const pipe_1 = require("../../../lib-common/byte-streaming/pipe");
 const utils_for_observables_1 = require("../../../lib-common/utils-for-observables");
 class FileObject {
-    constructor(name, isNew, node, makeOrGetNode, writable) {
+    constructor(name, isNew, node, makeOrGetNode, writable, isInSyncedStorage) {
         this.name = name;
         this.isNew = isNew;
         this.writable = writable;
-        this.v = new V(name, node, makeOrGetNode, writable);
+        this.v = new V(name, node, makeOrGetNode, writable, isInSyncedStorage);
         Object.seal(this);
     }
     static makeExisting(node, writable) {
-        const f = new FileObject(node.name, false, node, undefined, writable);
-        return (writable ?
-            files_1.wrapWritableFile(f) : files_1.wrapReadonlyFile(f));
+        const f = new FileObject(node.name, false, node, undefined, writable, node.isInSyncedStorage);
+        return (writable ? (0, files_1.wrapWritableFile)(f) : (0, files_1.wrapReadonlyFile)(f));
     }
-    static makeForNotExisiting(name, makeNode) {
-        const f = new FileObject(name, true, undefined, makeNode, true);
-        return files_1.wrapWritableFile(f);
+    static makeForNotExisiting(name, makeNode, isInSyncedStorage) {
+        const f = new FileObject(name, true, undefined, makeNode, true, isInSyncedStorage);
+        return (0, files_1.wrapWritableFile)(f);
     }
     static async makeFileFromLinkParams(storage, params) {
         const node = await file_node_1.FileNode.makeFromLinkParams(storage, params.params);
         return FileObject.makeExisting(node, !params.readonly);
     }
     async getLinkParams() {
-        if (!this.v.node) {
-            throw new Error('File does not exist, yet, and cannot be linked.');
-        }
-        const linkParams = this.v.node.getParamsForLink();
+        const node = await this.v.getNode();
+        const linkParams = node.getParamsForLink();
         linkParams.params.fileName = this.name;
         linkParams.readonly = !this.writable;
         return linkParams;
     }
     async stat() {
-        if (!this.v.node) {
-            throw file_1.makeFileException(file_1.Code.notFound, this.name);
-        }
-        const sync = await this.v.node.sync();
-        const attrs = this.v.node.getAttrs();
+        const node = await this.v.getNode();
+        const attrs = node.getAttrs();
         const stat = {
             writable: this.writable,
-            size: this.v.node.size,
-            version: this.v.node.version,
-            sync,
+            size: node.size,
+            version: node.version,
             isFile: true,
             ctime: new Date(attrs.ctime),
             mtime: new Date(attrs.mtime),
@@ -90,7 +83,7 @@ class FileObject {
             throw new Error(`Node for file ${this.name} is not yet initialized`);
         }
         const sub = this.v.node.event$
-            .subscribe(utils_for_observables_1.toRxObserver(observer));
+            .subscribe((0, utils_for_observables_1.toRxObserver)(observer));
         return () => sub.unsubscribe();
     }
     async readBytes(start, end) {
@@ -130,11 +123,12 @@ exports.FileObject = FileObject;
 Object.freeze(FileObject.prototype);
 Object.freeze(FileObject);
 class V {
-    constructor(name, node, makeOrGetNode, writable) {
+    constructor(name, node, makeOrGetNode, writable, isInSyncedStorage) {
         this.name = name;
         this.node = node;
         this.makeOrGetNode = makeOrGetNode;
         this.writable = writable;
+        this.sync = (isInSyncedStorage ? new S(this) : undefined);
         Object.seal(this);
     }
     async getNode() {
@@ -144,7 +138,13 @@ class V {
         }
         return this.node;
     }
+    ensureIsWritable() {
+        if (!this.writable) {
+            throw new Error(`File is not writable`);
+        }
+    }
     async updateXAttrs(changes) {
+        this.ensureIsWritable();
         const node = await this.getNode();
         return node.updateXAttrs(changes);
     }
@@ -172,16 +172,18 @@ class V {
         return linkParams;
     }
     async getByteSink(truncate = true, currentVersion) {
+        this.ensureIsWritable();
         const node = await this.getNode();
         return node.writeSink(truncate, currentVersion);
     }
     async getByteSource() {
         if (!this.node) {
-            throw file_1.makeFileException(file_1.Code.notFound, this.name);
+            throw (0, file_1.makeFileException)('notFound', this.name);
         }
         return this.node.readSrc();
     }
     async writeBytes(bytes) {
+        this.ensureIsWritable();
         const node = await this.getNode();
         return node.save(bytes);
     }
@@ -194,7 +196,7 @@ class V {
     }
     async readBytes(start, end) {
         if (!this.node) {
-            throw file_1.makeFileException(file_1.Code.notFound, this.name);
+            throw (0, file_1.makeFileException)('notFound', this.name);
         }
         return await this.node.readBytes(start, end);
     }
@@ -207,7 +209,7 @@ class V {
         const { version, sink } = await this.getByteSink();
         const src = (file.v ?
             (await file.v.getByteSource()).src : await file.getByteSource());
-        await pipe_1.pipe(src, sink);
+        await (0, pipe_1.pipe)(src, sink);
         return version;
     }
     async readJSON() {
@@ -215,7 +217,53 @@ class V {
         const json = JSON.parse(txt);
         return { json, version };
     }
+    async archiveCurrent(version) {
+        this.ensureIsWritable();
+        const node = await this.getNode();
+        return node.archiveCurrent(version);
+    }
+    async listVersions() {
+        const node = await this.getNode();
+        return node.listVersions();
+    }
 }
 Object.freeze(V.prototype);
 Object.freeze(V);
+class S {
+    constructor(n) {
+        this.n = n;
+        Object.freeze(this);
+    }
+    async upload(opts) {
+        this.n.ensureIsWritable();
+        const node = await this.n.getNode();
+        const uploadVersion = await node.upload(opts);
+        return uploadVersion;
+    }
+    async status() {
+        const node = await this.n.getNode();
+        const status = await node.syncStatus();
+        return status;
+    }
+    async updateStatusInfo() {
+        const node = await this.n.getNode();
+        const status = await node.updateStatusInfo();
+        return status;
+    }
+    async isRemoteVersionOnDisk(version) {
+        const node = await this.n.getNode();
+        const isOnDisk = await node.isSyncedVersionOnDisk(version);
+        return isOnDisk;
+    }
+    async download(version) {
+        const node = await this.n.getNode();
+        await node.download(version);
+    }
+    async adoptRemote(opts) {
+        const node = await this.n.getNode();
+        await node.adoptRemote(opts);
+    }
+}
+Object.freeze(S.prototype);
+Object.freeze(S);
 Object.freeze(exports);

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

@@ -64,14 +64,14 @@ var formatV1;
             o: nodeInfo.objId
         };
         const jsonBytes = buffer_utils_1.utf8.pack(JSON.stringify(json));
-        assert_1.assert(jsonBytes.length < 0xffffffff);
+        (0, assert_1.assert)(jsonBytes.length < 0xffffffff);
         bytes.push(numberToBytes(jsonBytes.length));
         bytes.push(jsonBytes);
         return bytes;
     }
     function numberToBytes(x) {
         const arr = Buffer.allocUnsafe(4);
-        big_endian_1.packUintTo4Bytes(x, arr, 0);
+        (0, big_endian_1.packUintTo4Bytes)(x, arr, 0);
         return arr;
     }
     function parse(bytes) {
@@ -92,9 +92,9 @@ var formatV1;
         if (bytes.length < (xsp_files_1.KEY_LENGTH + 4)) {
             throw parsingException(`Cannot deserialize node key from bytes`);
         }
-        const key = buffer_utils_1.makeUint8ArrayCopy(bytes.subarray(0, xsp_files_1.KEY_LENGTH));
+        const key = (0, buffer_utils_1.makeUint8ArrayCopy)(bytes.subarray(0, xsp_files_1.KEY_LENGTH));
         bytes = bytes.subarray(xsp_files_1.KEY_LENGTH);
-        const jsonBytesLen = big_endian_1.uintFrom4Bytes(bytes);
+        const jsonBytesLen = (0, big_endian_1.uintFrom4Bytes)(bytes);
         bytes = bytes.subarray(4);
         try {
             const json = JSON.parse(buffer_utils_1.utf8.open(bytes.subarray(0, jsonBytesLen)));

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

@@ -1,4 +1,4 @@
-import { Storage, Node, NodeType } from './common';
+import { Storage, NodeType } from './common';
 import { NodeInFS } from './node-in-fs';
 import { FileNode } from './file-node';
 import { LinkNode } from './link-node';
@@ -8,6 +8,10 @@ import { CommonAttrs, XAttrs } from './attrs';
 import { NodePersistance } from './node-persistence';
 declare type ListingEntry = web3n.files.ListingEntry;
 declare type XAttrsChanges = web3n.files.XAttrsChanges;
+declare type FolderDiff = web3n.files.FolderDiff;
+declare type OptionsToAdopteRemote = web3n.files.OptionsToAdopteRemote;
+declare type OptionsToAdoptRemoteItem = web3n.files.OptionsToAdoptRemoteItem;
+declare type OptionsToUploadLocal = web3n.files.OptionsToUploadLocal;
 export interface NodeInfo {
     /**
      * This is a usual file name.
@@ -54,6 +58,7 @@ declare class FolderPersistance extends NodePersistance {
         attrs: CommonAttrs;
         xattrs?: XAttrs;
     }>;
+    static readFolderContent(objId: string | null, key: Uint8Array, src: ObjSource, cryptor: AsyncSBoxCryptor): Promise<FolderInfo>;
 }
 export interface FolderLinkParams {
     folderName: string;
@@ -68,21 +73,18 @@ export declare class FolderNode extends NodeInFS<FolderPersistance> {
     private static readNodeFromObjBytes;
     static rootFromLinkParams(storage: Storage, params: FolderLinkParams): Promise<FolderNode>;
     static rootFromJSON(storage: Storage, name: string | undefined, folderJson: FolderInJSON): FolderNode;
+    protected setCurrentStateFrom(src: ObjSource): Promise<void>;
+    adoptRemote(opts: OptionsToAdopteRemote | undefined): Promise<void>;
+    private callRemoveObjOn;
     list(): {
         lst: ListingEntry[];
         version: number;
     };
-    listFolders(): string[];
-    private getNodeInfo;
+    childExistsInSyncedVersion(childObjId: string): Promise<boolean>;
+    getNodeInfo(name: string, undefOnMissing?: boolean): NodeInfo | undefined;
     hasChild(childName: string, throwIfMissing?: boolean): boolean;
-    /**
-     * @param objId
-     * @return either node (promise for node), or a deferred, which promise has
-     * been registered under a given id, and, therefore, has to be resolved with
-     * node.
-     */
-    private getNodeOrArrangePromise;
-    getNode<T extends Node>(type: NodeType | undefined, name: string, undefOnMissing?: boolean): Promise<T | undefined>;
+    getNode<T extends NodeInFS<any>>(type: NodeType | undefined, name: string, undefOnMissing?: boolean): Promise<T | undefined>;
+    private getOrMakeChildNodeForInfo;
     getFolder(name: string, undefOnMissing?: boolean): Promise<FolderNode | undefined>;
     getFile(name: string, undefOnMissing?: boolean): Promise<FileNode | undefined>;
     getLink(name: string, undefOnMissing?: boolean): Promise<LinkNode | undefined>;
@@ -130,8 +132,25 @@ export declare class FolderNode extends NodeInFS<FolderPersistance> {
      */
     isEmpty(): boolean;
     private getAllNodes;
-    protected delete(remoteEvent?: boolean): Promise<void>;
+    private removeFolderObj;
+    private callRemoveObjOnAll;
+    private removeChildrenObjsInSyncedStorage;
+    private uploadRemovalOfObjs;
     getParamsForLink(): LinkParameters<FolderLinkParams>;
-    protected doOnExternalChange(expectedVersion: number): Promise<void>;
+    upload(opts: OptionsToUploadLocal | undefined): Promise<void>;
+    private uploadRemovalOf;
+    private listRemovedInTreeToUploadRm;
+    protected needUpload(localVersion: number | undefined): Promise<{
+        localVersion: number;
+        uploadVersion: number;
+        createOnRemote: boolean;
+    } | undefined>;
+    private getNodesRemovedBetweenVersions;
+    adoptRemoteFolderItem(itemName: string, opts: OptionsToAdoptRemoteItem | undefined): Promise<number>;
+    private addRemoteChild;
+    private replaceLocalChildWithRemote;
+    diffCurrentAndRemote(remoteVersion: number | undefined): Promise<FolderDiff | undefined>;
+    private diffWithArchivedRemote;
+    private diffWithRemote;
 }
 export {};