@secrecy/lib 1.62.0-feat-storage-providers.4 → 1.62.0-feat-node-sharing.2

package/dist/lib/cache.js

@@ -2,6 +2,7 @@ import { LRUCache } from 'lru-cache';
 import { gigaToBytes } from './utils.js';
 export const dataCache = new Map();
 export const nodesCache = new Map();
+export const nodesEncryptionCache = new Map();
 export const usersCache = new Map();
 export const publicKeysCache = new Map();
 export const dataContentCache = new LRUCache({

package/dist/lib/client/SecrecyAppClient.js

@@ -63,17 +63,32 @@ export class SecrecyAppClient {
     async notifications() {
         return await this.#apiClient.application.notification.query();
     }
-    async userPublicKey(userId) {
-        const key = `userPublicKey:${userId}-${this.jwtDecoded.aud?.toString()}`;
-        const cachedPublicKey = publicKeysCache.get(key);
-        if (cachedPublicKey !== undefined) {
-            return cachedPublicKey;
-        }
-        const { publicKey } = await this.#apiClient.application.userPublicKey.query({
+    async userPublicKey(input) {
+        const appId = this.jwtDecoded.aud?.toString();
+        const userIds = Array.isArray(input) ? input : [input];
+        const publicKeys = Object.fromEntries(userIds
+            .map((userId) => [
             userId,
-        });
-        publicKeysCache.set(key, publicKey);
-        return publicKey;
+            publicKeysCache.get(`userPublicKey:${userId}-${appId}`),
+        ])
+            .filter(([_, key]) => !!key));
+        const missingKeys = [
+            ...new Set(userIds.filter((userId) => publicKeys[userId] === undefined)),
+        ];
+        if (missingKeys.length > 0) {
+            const userKeysMap = await this.#apiClient.application.userPublicKey.query(userIds);
+            if ('publicKey' in userKeysMap) {
+                throw Error('Should not happen!');
+            }
+            if (Object.keys(userKeysMap).length !== missingKeys.length) {
+                throw new Error("Unable to load some user's  public keys!");
+            }
+            for (const userId in userKeysMap) {
+                publicKeys[userId] = userKeysMap[userId];
+                publicKeysCache.set(`userPublicKey:${userId}-${appId}`, userKeysMap[userId]);
+            }
+        }
+        return Array.isArray(input) ? publicKeys : publicKeys[input];
     }
     async settings() {
         const settings = await this.#apiClient.application.settings.query({});

package/dist/lib/client/SecrecyCloudClient.js

@@ -1,7 +1,7 @@
 import axios from 'axios';
 import ky from 'ky';
 import { encryptName } from '../index.js';
-import { nodesCache, dataCache, dataContentCache } from '../cache.js';
+import { nodesCache, dataCache, dataContentCache, nodesEncryptionCache, } from '../cache.js';
 import { secretStreamKeygen } from '../crypto/data.js';
 import { decryptCryptoBox, encryptCryptoBox } from '../crypto/index.js';
 import { compress, decompress } from '../minify/index.js';
@@ -13,8 +13,6 @@ import { apiDataToExternal, apiDataToInternal } from './convert/data.js';
 import { apiNodeFullToInternalFull, apiNodeToExternal, apiNodeToExternalNodeFull, internalNodeFullToNodeFull, } from './convert/node.js';
 import { promiseAllLimit } from '../utils/promise.js';
 import { kiloToBytes } from '../utils.js';
-// import { md5 } from "../worker/index.js";
-// import { firstValueFrom, of } from "rxjs";
 import { fileTypeFromBuffer } from 'file-type';
 export class SecrecyCloudClient {
     #client;
@@ -50,7 +48,7 @@ export class SecrecyCloudClient {
         }
         return internalNodeFullToNodeFull(node);
     }
-    async uploadData({ storage, data, encrypted = true, encryptProgress, uploadProgress, signal, meta, }) {
+    async uploadData({ storageType, data, encrypted = true, encryptProgress, uploadProgress, signal, meta, }) {
         const dataBuffer = data instanceof File ? new Uint8Array(await data.arrayBuffer()) : data;
         let filetype;
         if (meta === true) {
@@ -62,8 +60,7 @@ export class SecrecyCloudClient {
         else if (!encrypted) {
             filetype = await fileTypeFromBuffer(dataBuffer);
         }
-        if (storage.protocol === 'mongo' &&
-            dataBuffer.byteLength > kiloToBytes(1024)) {
+        if (storageType === 'lite' && dataBuffer.byteLength > kiloToBytes(1024)) {
             throw new Error('The data is too big for lite upload!');
         }
         const compressed = encrypted ? compress(dataBuffer) : dataBuffer;
@@ -82,11 +79,11 @@ export class SecrecyCloudClient {
             current: 0,
             percent: 0,
         });
-        if (storage.protocol === 'mongo') {
+        if (storageType === 'lite') {
             const uploadDataArgs = encryptedDataKey && md5Encrypted
                 ? {
                     type: 'encrypted',
-                    bytes: Buffer.from(encryptedData),
+                    content: Buffer.from(encryptedData),
                     sizeEncrypted: BigInt(encryptedData.byteLength),
                     size: BigInt(dataBuffer.byteLength),
                     key: sodium.to_hex(encryptedDataKey),
@@ -96,13 +93,13 @@ export class SecrecyCloudClient {
                 }
                 : {
                     type: 'unencrypted',
-                    bytes: Buffer.from(encryptedData),
+                    content: Buffer.from(encryptedData),
                     md5: md5Data,
                     sizeEncrypted: undefined,
                     size: BigInt(dataBuffer.byteLength),
                     ...filetype,
                 };
-            const uploadData = await this.#apiClient.cloud.uploadMongoData.mutate(uploadDataArgs, { signal });
+            const uploadData = await this.#apiClient.cloud.uploadLiteData.mutate(uploadDataArgs, { signal });
             await uploadProgress?.({
                 total: encryptedData.byteLength,
                 current: encryptedData.byteLength,
@@ -110,7 +107,7 @@ export class SecrecyCloudClient {
             });
             const localData = {
                 id: uploadData.id,
-                storage: storage,
+                storageType: 'lite',
                 size: uploadDataArgs.size,
                 sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
                 data: dataBuffer,
@@ -119,7 +116,7 @@ export class SecrecyCloudClient {
             dataContentCache.set(uploadData.id, localData);
             return localData;
         }
-        if (storage.protocol === 's3') {
+        if (storageType === 's3' || storageType === 'cold') {
             const uploadDataArgs = encryptedDataKey && md5Encrypted
                 ? {
                     type: 'encrypted',
@@ -137,7 +134,7 @@ export class SecrecyCloudClient {
                     sizeEncrypted: undefined,
                     ...filetype,
                 };
-            const uploadDataCaller = storage.mode === 'standard'
+            const uploadDataCaller = storageType === 's3'
                 ? this.#apiClient.cloud.uploadData
                 : this.#apiClient.cloud.uploadColdData;
             const uploadData = await uploadDataCaller.mutate(uploadDataArgs, {
@@ -154,7 +151,7 @@ export class SecrecyCloudClient {
                 });
                 const localData = {
                     id: uploadData.id,
-                    storage: storage,
+                    storageType: storageType,
                     size: uploadDataArgs.size,
                     sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
                     data: dataBuffer,
@@ -211,7 +208,7 @@ export class SecrecyCloudClient {
             }));
             const localData = {
                 id: uploadData.id,
-                storage: storage,
+                storageType: storageType,
                 size: uploadDataArgs.size,
                 sizeEncrypted: uploadDataArgs.sizeEncrypted ?? null,
                 data: dataBuffer,
@@ -220,11 +217,11 @@ export class SecrecyCloudClient {
             dataContentCache.set(uploadData.id, localData);
             return localData;
         }
-        throw new Error(`Not implemented yet!`);
+        throw new Error(`The "${storageType}" is not implemented yet!`);
     }
-    async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storage, signal, }) {
+    async uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType = 's3', signal, }) {
         const uploadedData = await this.uploadData({
-            storage,
+            storageType,
             data,
             encryptProgress,
             uploadProgress,
@@ -299,11 +296,10 @@ export class SecrecyCloudClient {
         const users = folder.parent?.users?.filter(([u]) => u.id !== this.#client.app.userId) ??
             [];
         if (users.length > 0) {
-            await Promise.all(users.map(async ([u, rights]) => await this.shareNode({
+            await this.shareNode({
                 nodeId: folder.id,
-                rights,
-                userId: u.id,
-            })));
+                users: users.map(([user, rights]) => ({ id: user.id, rights })),
+            });
         }
         return folder;
     }
@@ -320,25 +316,35 @@ export class SecrecyCloudClient {
         });
         return apiDataToExternal(data, this.#keys);
     }
-    async shareNode({ nodeId, userId, rights, }) {
-        const publicKey = await this.#client.app.userPublicKey(userId);
-        const { ids } = await this.#apiClient.cloud.shareNode.mutate({
-            nodeId,
-            userId,
-        });
-        const shareNodes = [];
-        for (const id of ids) {
-            const shareNode = await this.perNode(id, publicKey);
-            if (shareNode !== null) {
-                shareNodes.push(shareNode);
-            }
-        }
-        const { isFinished } = await this.#apiClient.cloud.shareNodeFinish.mutate({
-            rights,
-            userId,
-            nodes: shareNodes,
-        });
-        return isFinished;
+    async shareNode(input) {
+        const userIds = 'rights' in input
+            ? Array.isArray(input.nodes)
+                ? input.nodes.map(({ userId }) => userId)
+                : 'userIds' in input.nodes
+                    ? input.nodes.userIds
+                    : [input.nodes.userId]
+            : input.users.map(({ id }) => id);
+        const nodesToShare = 'nodes' in input
+            ? input.nodes
+            : {
+                nodeId: input.nodeId,
+                userIds: input.users.map(({ id }) => id),
+            };
+        const [publicKeysMap, nodesIdsMap] = await Promise.all([
+            this.#client.app.userPublicKey(userIds),
+            this.#apiClient.cloud.shareNode.mutate(nodesToShare),
+        ]);
+        const nodesInfos = await this.encryptNodesForUsers(nodesIdsMap, publicKeysMap);
+        const sharingState = await this.#apiClient.cloud.shareNodeFinish.mutate(Object.entries(nodesInfos).map('rights' in input
+            ? ([userId, nodes]) => ({ userId, nodes, rights: input.rights })
+            : ([userId, nodes]) => {
+                const user = input.users.find((user) => user.id === userId);
+                if (!user) {
+                    throw new Error(`Unable to find rights for user: ${userId}`);
+                }
+                return { userId, nodes, rights: user.rights };
+            }));
+        return sharingState;
     }
     async updateNode({ nodeId, name, isFavorite, deletedAt, }) {
         let node = nodesCache.get(nodeId);
@@ -398,13 +404,13 @@ export class SecrecyCloudClient {
                 id: data.id,
                 size: data.size,
                 sizeEncrypted: data.sizeEncrypted,
-                storage: data.storage,
+                storageType: data.storageType,
             })),
             ...cachedData.map((data) => ({
                 id: data.id,
                 size: data.size,
                 sizeEncrypted: data.sizeEncrypted,
-                storage: data.storage,
+                storageType: data.storageType,
             })),
         ];
         const allDataContentsBytes = Number(allDataContents.reduce((curr, next) => curr + (next.sizeEncrypted ?? next.size), 0n));
@@ -523,42 +529,102 @@ export class SecrecyCloudClient {
         if (me !== undefined && ['admin', 'write'].includes(me[1])) {
             const others = node.parent?.users.filter(([u]) => u.id !== this.#client.app.userId) ??
                 [];
-            await Promise.all(others.map(async ([u, rights]) => await this.shareNode({
-                nodeId: node.id,
-                rights,
-                userId: u.id,
-            })));
+            if (others.length > 0) {
+                await this.shareNode({
+                    nodeId: node.id,
+                    users: others.map(([user, rights]) => ({ id: user.id, rights })),
+                });
+            }
         }
         return node;
     }
-    perNode = async (nodeId, publicKey) => {
-        let node = nodesCache.get(nodeId);
-        if (node === undefined || (node.type === 'FILE' && !('history' in node))) {
-            await this.node({ id: nodeId });
-            node = nodesCache.get(nodeId);
-            if (node === undefined) {
-                return null;
+    encryptNodesForUsers = async (userNodes, // { [userId]: nodeIds[] }
+    userPublicKeys) => {
+        const userIds = Object.keys(userNodes).map((userId) => userId);
+        const nodeIds = Object.values(userNodes).flatMap((nodeIds) => nodeIds);
+        const nodes = [];
+        // Pre check to ensure we get all public keys for users!
+        for (const userId of userIds) {
+            if (userPublicKeys[userId] === undefined) {
+                throw new Error(`Unable to retreive some user public keys!`);
             }
         }
-        if (node.type === 'FILE' &&
-            (!('history' in node) || node.history.length === 0)) {
-            throw new Error("Can't share a node without data!");
+        // Retreive and format nodes.
+        for (const nodeId of nodeIds) {
+            let node;
+            node ??= nodesEncryptionCache.get(nodeId);
+            node ??= nodesCache.get(nodeId);
+            if (node &&
+                'history' in node &&
+                node.history.length > 0 &&
+                node.access.nameKey) {
+                nodes.push({
+                    id: nodeId,
+                    name: node.name,
+                    type: node.type,
+                    access: { nameKey: node.access.nameKey },
+                    history: node.history.map((data) => {
+                        if (!data.key) {
+                            throw new Error('Unable to retreive data key!');
+                        }
+                        return { id: data.id, key: data.key };
+                    }),
+                });
+            }
         }
-        const nameKey = node.access?.nameKey;
-        return {
-            id: node.id,
-            nameKey: nameKey !== null
-                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey))
-                : null,
-            data: 'history' in node
-                ? node.history.map((f) => ({
-                    id: f.id,
-                    key: f.key
-                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey))
+        // Retreive all missing nodes from cache to api.
+        const missingNodeIds = nodeIds.filter((nodeId) => !nodes.some((node) => node.id === nodeId));
+        const fetchedNodes = await this.#apiClient.cloud.nodesForEncryption.query({
+            ids: missingNodeIds,
+        });
+        if (fetchedNodes.length !== missingNodeIds.length) {
+            const diff = missingNodeIds.filter((id) => !fetchedNodes.some((node) => node.id === id));
+            throw new Error(`Unable to fetch some node infos (${diff.join(', ')})`);
+        }
+        nodes.push(...fetchedNodes.map((node) => {
+            return {
+                id: node.id,
+                type: node.type,
+                name: node.name,
+                access: { nameKey: node.access.nameKey },
+                history: node.history.map((data) => ({
+                    id: data.id,
+                    key: data.access.key,
+                })),
+            };
+        }));
+        const nodesMappedUsers = {};
+        for (const userId in userNodes) {
+            nodesMappedUsers[userId] ??= [];
+            for (const nodeId of userNodes[userId]) {
+                const node = nodes.find((node) => node.id === nodeId);
+                if (!node) {
+                    throw new Error('Unable to retreive node from ram');
+                }
+                if (node.type === 'FILE' &&
+                    (!('history' in node) || node.history.length === 0)) {
+                    throw new Error(`Can't share a node without data (${node.id})!`);
+                }
+                const nameKey = node.access?.nameKey;
+                const publicKey = userPublicKeys[userId];
+                nodesEncryptionCache.set(node.id, node);
+                nodesMappedUsers[userId].push({
+                    id: node.id,
+                    nameKey: nameKey !== null
+                        ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(nameKey), publicKey, this.#keys.privateKey))
                         : null,
-                }))
-                : [],
-        };
+                    data: 'history' in node
+                        ? node.history.map((f) => ({
+                            id: f.id,
+                            key: f.key
+                                ? sodium.to_hex(encryptCryptoBox(sodium.from_hex(f.key), publicKey, this.#keys.privateKey))
+                                : null,
+                        }))
+                        : [],
+                });
+            }
+        }
+        return nodesMappedUsers;
     };
     async reportData({ id, reasons, }) {
         const [rawData, secrecy] = await Promise.all([
@@ -574,18 +640,13 @@ export class SecrecyCloudClient {
                 : null,
         });
     }
-    async updateDataStorage(input) {
+    async updateDataStorageType(input) {
         const data = dataContentCache.get(input.dataId);
         if (data) {
-            if (data.storage.protocol === input.protocol &&
-                data.storage.provider === input.provider &&
-                data.storage.mode === input.mode &&
-                data.storage.region === input.region) {
-                throw new Error(`The data is already on "${data.storage}`);
+            if (data.storageType === input.storageType) {
+                throw new Error(`The data is already on "${data.storageType}`);
             }
-            if (data.storage.protocol === 's3' &&
-                data.storage.mode === 'glacier' &&
-                input.protocol === 'mongo') {
+            if (data.storageType === 'cold' && input.storageType === 'lite') {
                 throw new Error("It's not possible to transfer a cold stored data to a lite storage!");
             }
         }
@@ -597,6 +658,9 @@ export class SecrecyCloudClient {
     getPublicDataLinks(input) {
         return this.#apiClient.cloud.dataLinks.query(input);
     }
+    checkAccesses(input) {
+        return this.#apiClient.cloud.checkAccesses.query(input);
+    }
     createPublicDataLink(input) {
         if (input.expireAt && input.expireAt <= new Date()) {
             throw new Error('Unable to create public link using a past expireAt date!');
@@ -647,25 +711,19 @@ export class SecrecyCloudClient {
                 .sort((a, b) => a.order - b.order)
                 .map((p) => p.data));
         };
-        const encryptedContent = dataContent.type === 'mongo'
-            ? new Uint8Array(dataContent.bytes)
-            : dataContent.type === 's3'
+        const encryptedContent = dataContent.type === 'lite'
+            ? new Uint8Array(dataContent.content)
+            : dataContent.type === 'cloud'
                 ? await encryptedContentFromParts({
                     dataId: dataContent.id,
-                    dataParts: dataContent.parts.map(({ url, ...part }) => ({
-                        ...part,
-                        contentUrl: url,
-                    })),
+                    dataParts: dataContent.parts,
                 })
-                : dataContent.maybeBytes !== null
-                    ? new Uint8Array(dataContent.maybeBytes)
+                : dataContent.maybeContent !== null
+                    ? new Uint8Array(dataContent.maybeContent)
                     : dataContent.maybeParts !== null
                         ? await encryptedContentFromParts({
                             dataId: dataContent.id,
-                            dataParts: dataContent.maybeParts.map(({ url, ...part }) => ({
-                                ...part,
-                                contentUrl: url,
-                            })),
+                            dataParts: dataContent.maybeParts,
                         })
                         : null;
         if (encryptedContent === null) {
@@ -678,7 +736,7 @@ export class SecrecyCloudClient {
         const key = dataContent.key
             ? decryptCryptoBox(sodium.from_hex(dataContent.key), dataContent.type === 'received_mail'
                 ? dataContent.senderPublicKey
-                : dataContent.type === 's3'
+                : dataContent.type === 'cloud' || dataContent.type === 'lite'
                     ? dataContent.publicKey
                     : this.#keys.publicKey, this.#keys.privateKey)
             : null;
@@ -690,20 +748,11 @@ export class SecrecyCloudClient {
             throw new Error(`Content does not match`);
         }
         const decompressed = decompress(src);
-        const storageOptions = dataContent.storage.protocol === 'mongo'
-            ? dataContent.storage.mongoStorageOptions
-            : dataContent.storage.s3StorageOptions;
-        const storage = {
-            protocol: dataContent.storage.protocol,
-            provider: dataContent.storage.provider,
-            mode: storageOptions.mode,
-            region: storageOptions.region,
-        };
         dataContentCache.set(dataContent.id, {
             id: dataContent.id,
             size: dataContent.size,
             sizeEncrypted: dataContent.sizeEncrypted,
-            storage: storage,
+            storageType: dataContent.storageType,
             data: decompressed,
             mime: dataContent.mime ?? undefined,
             ext: dataContent.ext ?? undefined,
@@ -712,7 +761,7 @@ export class SecrecyCloudClient {
             id: dataContent.id,
             size: dataContent.size,
             sizeEncrypted: dataContent.sizeEncrypted,
-            storage: storage,
+            storageType: dataContent.storageType,
             data: decompressed,
             mime: dataContent.mime ?? undefined,
             ext: dataContent.ext ?? undefined,

package/dist/lib/client/convert/node.js

@@ -3,7 +3,7 @@ import { decryptCryptoBox } from '../../crypto/index.js';
 import { nodesCache } from '../../cache.js';
 import { decryptSecretStream } from '../../crypto/data.js';
 import { apiDataToInternal, internalDataToExternalData } from './data.js';
-export async function apiNodeToInternal(apiNode, keyPair) {
+async function apiNodeToInternal(apiNode, keyPair) {
     const internal = {
         id: apiNode.id,
         type: apiNode.type,
@@ -58,7 +58,7 @@ export async function apiNodeFullToInternalFull(apiNodeFull, keyPair) {
     nodesCache.set(f.id, nodeFull);
     return nodeFull;
 }
-export function internalNodeToNode(internal) {
+function internalNodeToNode(internal) {
     const node = {
         ...internal,
         breadcrumb: internal.breadcrumb.map((b) => ({

package/dist/types/cache.d.ts

@@ -1,7 +1,8 @@
-import type { InternalNode, InternalData, InternalNodeFull, LocalData } from './client/types/index.js';
+import type { InternalNode, InternalData, InternalNodeFull, LocalData, InternalMinimalNodeForEncryption } from './client/types/index.js';
 import { LRUCache } from 'lru-cache';
 export declare const dataCache: Map<string, InternalData>;
 export declare const nodesCache: Map<string, InternalNode | InternalNodeFull>;
+export declare const nodesEncryptionCache: Map<string, InternalMinimalNodeForEncryption>;
 export declare const usersCache: Map<string, {
     id: string;
     lastname: string;

package/dist/types/client/SecrecyAppClient.d.ts

@@ -16,6 +16,7 @@ export declare class SecrecyAppClient {
     updateNotifications(notifications: Partial<UserAppNotifications>): Promise<UserAppNotifications>;
     notifications(): Promise<UserAppNotifications>;
     userPublicKey(userId: string): Promise<string>;
+    userPublicKey(userId: string[]): Promise<Record<string, string>>;
     settings(): Promise<UserAppSettings>;
     updateSettings(settings: Partial<UserAppSettings>): Promise<UserAppSettings>;
 }

package/dist/types/client/SecrecyCloudClient.d.ts

@@ -1,5 +1,5 @@
 import type { ProgressCallback, SecrecyClient } from '../index.js';
-import type { DataMetadata, DataStorageInput, KeyPair, LocalData, Node, NodeFull, NodeType, Rights } from './types/index.js';
+import type { DataMetadata, DataStorageType, KeyPair, LocalData, Node, NodeFull, NodeType, Rights } from './types/index.js';
 import { type RouterInputs, type ApiClient, type RouterOutputs } from '../client.js';
 import { type DownloadProgress } from '../types.js';
 import { FileTypeResult } from 'file-type';
@@ -10,8 +10,8 @@ export declare class SecrecyCloudClient {
         dataId: string;
         nodeId: string;
     }): Promise<NodeFull>;
-    uploadData({ storage, data, encrypted, encryptProgress, uploadProgress, signal, meta, }: {
-        storage: DataStorageInput;
+    uploadData({ storageType, data, encrypted, encryptProgress, uploadProgress, signal, meta, }: {
+        storageType: DataStorageType;
         data: globalThis.File | Uint8Array;
         encrypted?: boolean;
         encryptProgress?: ProgressCallback;
@@ -19,14 +19,14 @@ export declare class SecrecyCloudClient {
         signal?: AbortSignal;
         meta?: FileTypeResult | true;
     }): Promise<LocalData>;
-    uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storage, signal, }: {
+    uploadDataInCloud({ data, name, nodeId, encryptProgress, uploadProgress, storageType, signal, }: {
         data: globalThis.File | Uint8Array;
         name: string;
         nodeId?: string;
         encryptProgress?: ProgressCallback;
         uploadProgress?: ProgressCallback;
         signal?: AbortSignal;
-        storage: DataStorageInput;
+        storageType?: DataStorageType;
     }): Promise<NodeFull>;
     deletedNodes(): Promise<Node[]>;
     sharedNodes(): Promise<Node[]>;
@@ -54,11 +54,28 @@ export declare class SecrecyCloudClient {
     dataMetadata({ id }: {
         id: string;
     }): Promise<DataMetadata>;
-    shareNode({ nodeId, userId, rights, }: {
-        nodeId: string;
-        userId: string;
+    shareNode(input: {
         rights: Rights;
-    }): Promise<boolean>;
+        nodes: {
+            nodeId: string;
+            userId: string;
+        }[] | {
+            nodeId: string;
+            userIds: string[];
+        } | {
+            nodeIds: string[];
+            userId: string;
+        } | {
+            nodeIds: string[];
+            userIds: string[];
+        };
+    } | {
+        nodeId: string;
+        users: {
+            id: string;
+            rights: Rights;
+        }[];
+    }): Promise<RouterOutputs['cloud']['shareNodeFinish']>;
     updateNode({ nodeId, name, isFavorite, deletedAt, }: {
         nodeId: string;
         name?: string | null | undefined;
@@ -100,16 +117,12 @@ export declare class SecrecyCloudClient {
         name: string;
         nodeId?: string;
     }): Promise<NodeFull>;
-    private readonly perNode;
+    private readonly encryptNodesForUsers;
     reportData({ id, reasons, }: Omit<RouterInputs['cloud']['reportData'], 'encryptedDataKey'>): Promise<RouterOutputs['cloud']['reportData']>;
-    updateDataStorage(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
+    updateDataStorageType(input: RouterInputs['cloud']['moveToStorageType']): Promise<{
         isMoved: boolean;
-        fromProtocol?: "s3" | "mongo" | undefined;
-        fromMode?: "standard" | "glacier" | undefined;
-        fromRegion?: string | undefined;
-        toProtocol?: "s3" | "mongo" | undefined;
-        toMode?: "standard" | "glacier" | undefined;
-        toRegion?: string | undefined;
+        fromType: "s3" | "cold" | "lite";
+        toType: "s3" | "cold" | "lite";
     }>;
     getPublicDataLink(input: RouterInputs['cloud']['dataLink']): Promise<{
         name: string;
@@ -125,6 +138,28 @@ export declare class SecrecyCloudClient {
         expireAt: Date | null;
         slug: string;
     }[]>;
+    checkAccesses(input: RouterInputs['cloud']['checkAccesses']): Promise<{
+        isMatching: true;
+    } | {
+        details: {
+            missingNodeAccesses: {
+                userId: string;
+                nodeId: string;
+            }[];
+            missingDataAccesses: {
+                userId: string;
+                dataId: string;
+                nodeId: string;
+            }[];
+            invalidRightsAccesses: {
+                userId: string;
+                current: "admin" | "write" | "read";
+                nodeId: string;
+                expect: "admin" | "write" | "read";
+            }[];
+        };
+        isMatching: false;
+    }>;
     createPublicDataLink(input: RouterInputs['cloud']['createDataLink']): Promise<{
         name: string;
         id: string;