@secrecy/lib 1.0.0-dev.9 → 1.0.0

package/dist/client/convert/node.js

@@ -0,0 +1,101 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { sodium } from "../../sodium.js";
+import { decryptCryptoBox } from "../../crypto/index.js";
+import { nodesCache } from "../../cache.js";
+import { decryptSecretstream } from "../../crypto/file.js";
+import { gqlFileToInternal, internalFileToFile } from "./file.js";
+export async function gqlNodeToInternal(gql, keyPair) {
+  if (!gql.access) {
+    throw "Can't access Node " + gql.id;
+  }
+
+  const internal = {
+    id: gql.id,
+    type: gql.type,
+    access: gql.access,
+    name: gql.name,
+    isFavorite: gql.isFavorite,
+    breadcrumb: gql.breadcrumb,
+    createdBy: gql.createdBy.user,
+    createdAt: new Date(gql.createdAt),
+    updatedAt: new Date(gql.updatedAt),
+    deletedAt: gql.deletedAt ? new Date(gql.deletedAt) : null,
+    users: gql.accesses.map(u => [u.userApp.user, u.rights]),
+    history: gql.history.map(f => gqlFileToInternal(f, keyPair))
+  };
+
+  if (gql.current) {
+    internal.current = gqlFileToInternal(gql.current, keyPair);
+  }
+
+  internal.access = _objectSpread({}, gql.access);
+
+  if (gql.access.nameKey) {
+    if (!gql.access.sharedBy.keyPair) {
+      throw new Error("Can't find keyPair for access");
+    }
+
+    const key = decryptCryptoBox(sodium.from_hex(gql.access.nameKey), gql.createdBy.user.publicKey, keyPair.privateKey);
+    internal.name = sodium.to_string(await decryptSecretstream(key, sodium.from_hex(internal.name)));
+    internal.access.nameKey = sodium.to_hex(key);
+  }
+
+  for (const b of internal.breadcrumb) {
+    if (!b.nameKey) {
+      continue;
+    }
+
+    const key = decryptCryptoBox(sodium.from_hex(b.nameKey), b.pubKey, keyPair.privateKey);
+    b.nameKey = sodium.to_hex(key);
+    b.name = sodium.to_string(await decryptSecretstream(key, sodium.from_hex(b.name)));
+  }
+
+  nodesCache.set(internal.id, internal);
+  return internal;
+}
+export async function gqlNodeFullToInternalFull(gql, keyPair) {
+  const f = await gqlNodeToInternal(gql, keyPair);
+  return _objectSpread(_objectSpread({}, f), {}, {
+    parent: gql.parent ? await gqlNodeToInternal(gql.parent, keyPair) : null,
+    children: await Promise.all(gql.children.map(s => gqlNodeToInternal(s, keyPair)))
+  });
+}
+export function internalNodeToNode(internal) {
+  var _node$access;
+
+  const node = _objectSpread(_objectSpread({}, internal), {}, {
+    access: internal.access ? _objectSpread({}, internal.access) : undefined,
+    history: internal.history.map(f => internalFileToFile(f))
+  });
+
+  if (internal.current) {
+    node.current = internalFileToFile(internal.current);
+  }
+
+  for (const b of node.breadcrumb) {
+    // @ts-ignore
+    delete b.pubKey;
+  } // @ts-ignore
+
+
+  (_node$access = node.access) == null ? true : delete _node$access.nameKey;
+  return node;
+}
+export function internalNodeFullToNodeFull(internal) {
+  return _objectSpread(_objectSpread({}, internalNodeToNode(internal)), {}, {
+    parent: internal.parent ? internalNodeToNode(internal.parent) : null,
+    children: internal.children.map(internalNodeToNode)
+  });
+}
+export async function gqlNodeToExternalNodeFull(gql, keyPair) {
+  return internalNodeFullToNodeFull(await gqlNodeFullToInternalFull(gql, keyPair));
+}
+export async function gqlNodeToExternal(gql, keyPair) {
+  return internalNodeToNode(await gqlNodeToInternal(gql, keyPair));
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["sodium","decryptCryptoBox","nodesCache","decryptSecretstream","gqlFileToInternal","internalFileToFile","gqlNodeToInternal","gql","keyPair","access","id","internal","type","name","isFavorite","breadcrumb","createdBy","user","createdAt","Date","updatedAt","deletedAt","users","accesses","map","u","userApp","rights","history","f","current","nameKey","sharedBy","Error","key","from_hex","publicKey","privateKey","to_string","to_hex","b","pubKey","set","gqlNodeFullToInternalFull","parent","children","Promise","all","s","internalNodeToNode","node","undefined","internalNodeFullToNodeFull","gqlNodeToExternalNodeFull","gqlNodeToExternal"],"sources":["../../../src/client/convert/node.ts"],"sourcesContent":["import { sodium } from \"../../sodium.js\";\nimport type { KeyPair } from \"../../crypto/index.js\";\nimport { decryptCryptoBox } from \"../../crypto/index.js\";\nimport type { Node } from \"../types/index.js\";\nimport type {\n  GQLNode,\n  InternalNode,\n  GQLNodeFull,\n  InternalNodeFull,\n  NodeFull\n} from \"../types/index.js\";\nimport { nodesCache } from \"../../cache.js\";\nimport { decryptSecretstream } from \"../../crypto/file.js\";\nimport { gqlFileToInternal, internalFileToFile } from \"./file.js\";\n\nexport async function gqlNodeToInternal(\n  gql: GQLNode,\n  keyPair: KeyPair\n): Promise<InternalNode> {\n  if (!gql.access) {\n    throw `Can't access Node ${gql.id}`;\n  }\n\n  const internal: InternalNode = {\n    id: gql.id,\n    type: gql.type,\n    access: gql.access,\n    name: gql.name,\n    isFavorite: gql.isFavorite,\n    breadcrumb: gql.breadcrumb,\n    createdBy: gql.createdBy.user,\n    createdAt: new Date(gql.createdAt as string),\n    updatedAt: new Date(gql.updatedAt as string),\n    deletedAt: gql.deletedAt ? new Date(gql.deletedAt as string) : null,\n    users: gql.accesses.map(u => [u.userApp.user, u.rights]),\n    history: gql.history.map(f => gqlFileToInternal(f, keyPair))\n  };\n\n  if (gql.current) {\n    internal.current = gqlFileToInternal(gql.current, keyPair);\n  }\n\n  internal.access = { ...gql.access };\n\n  if (gql.access.nameKey) {\n    if (!gql.access.sharedBy.keyPair) {\n      throw new Error(`Can't find keyPair for access`);\n    }\n    const key = decryptCryptoBox(\n      sodium.from_hex(gql.access.nameKey),\n      gql.createdBy.user.publicKey,\n      keyPair.privateKey\n    );\n    internal.name = sodium.to_string(\n      await decryptSecretstream(key, sodium.from_hex(internal.name))\n    );\n\n    internal.access.nameKey = sodium.to_hex(key);\n  }\n\n  for (const b of internal.breadcrumb) {\n    if (!b.nameKey) {\n      continue;\n    }\n    const key = decryptCryptoBox(\n      sodium.from_hex(b.nameKey),\n      b.pubKey,\n      keyPair.privateKey\n    );\n    b.nameKey = sodium.to_hex(key);\n\n    b.name = sodium.to_string(\n      await decryptSecretstream(key, sodium.from_hex(b.name))\n    );\n  }\n\n  nodesCache.set(internal.id, internal);\n  return internal;\n}\n\nexport async function gqlNodeFullToInternalFull(\n  gql: GQLNodeFull,\n  keyPair: KeyPair\n): Promise<InternalNodeFull> {\n  const f = await gqlNodeToInternal(gql, keyPair);\n  return {\n    ...f,\n    parent: gql.parent ? await gqlNodeToInternal(gql.parent, keyPair) : null,\n    children: await Promise.all(\n      gql.children.map(s => gqlNodeToInternal(s, keyPair))\n    )\n  };\n}\n\nexport function internalNodeToNode(internal: InternalNode): Node {\n  const node: Node = {\n    ...internal,\n    access: internal.access ? { ...internal.access } : undefined,\n    history: internal.history.map(f => internalFileToFile(f))\n  };\n\n  if (internal.current) {\n    node.current = internalFileToFile(internal.current);\n  }\n\n  for (const b of node.breadcrumb) {\n    // @ts-ignore\n    delete b.pubKey;\n  }\n  // @ts-ignore\n  delete node.access?.nameKey;\n  return node;\n}\n\nexport function internalNodeFullToNodeFull(\n  internal: InternalNodeFull\n): NodeFull {\n  return {\n    ...internalNodeToNode(internal),\n    parent: internal.parent ? internalNodeToNode(internal.parent) : null,\n    children: internal.children.map(internalNodeToNode)\n  };\n}\n\nexport async function gqlNodeToExternalNodeFull(\n  gql: GQLNodeFull,\n  keyPair: KeyPair\n): Promise<NodeFull> {\n  return internalNodeFullToNodeFull(\n    await gqlNodeFullToInternalFull(gql, keyPair)\n  );\n}\n\nexport async function gqlNodeToExternal(\n  gql: GQLNode,\n  keyPair: KeyPair\n): Promise<Node> {\n  return internalNodeToNode(await gqlNodeToInternal(gql, keyPair));\n}\n"],"mappings":"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"}

package/{lib → dist}/client/helpers.d.ts

@@ -11,7 +11,7 @@ export declare type HashInfos = {
         email: boolean;
     };
 };
-export declare type SecrecyEnv = "dev" | "staging" | "prod";
+export declare type SecrecyEnv = "dev" | "prod";
 export declare type UseSecrecyParams = Omit<HashInfos, "appUrl"> & {
     env: SecrecyEnv;
     session?: boolean | undefined;

package/dist/client/helpers.js

@@ -0,0 +1,114 @@
+import { SecrecyClient } from "./index.js";
+import { popup } from "../PopupTools.js";
+import { getStorage } from "./storage.js";
+export function parseInfos() {
+  if (!window.location.hash) {
+    return null;
+  }
+
+  const hash = window.location.hash.substr(1);
+
+  try {
+    const res = JSON.parse(atob(hash));
+    window.location.hash = ""; // TODO Add object content validation
+
+    return res;
+  } catch {
+    return null;
+  }
+}
+export function getSecrecyClient(env, session) {
+  const storage = getStorage(session);
+  const uaSession = storage.userAppSession.load();
+  const uaKeys = storage.userAppKeys.load();
+  const uaJwt = storage.jwt.load();
+
+  if (!uaSession || !uaKeys || !uaJwt) {
+    const infos = parseInfos();
+
+    if (infos) {
+      storage.userAppKeys.save(infos.keys);
+      storage.userAppSession.save(infos.uaSession);
+      storage.jwt.save(infos.jwt);
+      return new SecrecyClient(infos.uaSession, infos.keys, infos.jwt, env);
+    }
+
+    return null;
+  }
+
+  return new SecrecyClient(uaSession, uaKeys, uaJwt, env);
+}
+export function login(_temp) {
+  let {
+    appCode,
+    path,
+    redirect,
+    scopes,
+    backPath,
+    env,
+    session
+  } = _temp === void 0 ? {} : _temp;
+  return new Promise((resolve, reject) => {
+    const appUrl = window.location.origin;
+
+    if (appCode && !appUrl.includes("localhost")) {
+      return reject("Can't use appCode if not in localhost");
+    }
+
+    const client = getSecrecyClient(env);
+
+    if (!client) {
+      const infos = {
+        appUrl,
+        appCode,
+        redirect,
+        path,
+        scopes,
+        backPath
+      };
+      const data = btoa(JSON.stringify(infos)).replaceAll("=", "");
+      let envStr = "";
+
+      if (env === "dev") {
+        envStr = "dev.";
+      }
+
+      const lang = document.documentElement.lang;
+      const url = process.env.NEXT_PUBLIC_SECRECY_API_URL ? "http://localhost:3002" + (lang ? "/" + lang : "") + "/login#" + data : "https://auth." + envStr + "secrecy.me" + (lang ? "/" + lang : "") + "/login#" + data;
+
+      const validate = infos => {
+        const storage = getStorage(session);
+        storage.userAppSession.save(infos.uaSession);
+        storage.userAppKeys.save(infos.keys);
+        storage.jwt.save(infos.jwt);
+        return resolve(new SecrecyClient(infos.uaSession, infos.keys, infos.jwt, env));
+      };
+
+      if (redirect) {
+        const infos = parseInfos();
+
+        if (infos) {
+          return validate(infos);
+        } else {
+          window.location.href = url;
+          return resolve(null);
+        }
+      } else {
+        popup(url, "Secrecy Login", {}, (err, data) => {
+          if (err) {
+            return reject(err);
+          } else {
+            const infos = data;
+
+            if (infos) {
+              return validate(infos);
+            }
+          }
+        });
+      }
+    } else {
+      return resolve(client);
+    }
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SecrecyClient","popup","getStorage","parseInfos","window","location","hash","substr","res","JSON","parse","atob","getSecrecyClient","env","session","storage","uaSession","userAppSession","load","uaKeys","userAppKeys","uaJwt","jwt","infos","save","keys","login","appCode","path","redirect","scopes","backPath","Promise","resolve","reject","appUrl","origin","includes","client","data","btoa","stringify","replaceAll","envStr","lang","document","documentElement","url","process","NEXT_PUBLIC_SECRECY_API_URL","validate","href","err"],"sources":["../../src/client/helpers.ts"],"sourcesContent":["import { SecrecyClient } from \"./index.js\";\nimport { popup } from \"../PopupTools.js\";\nimport type { SecrecyUserApp } from \"./types/index.js\";\nimport { getStorage } from \"./storage.js\";\n\nexport function parseInfos(): SecrecyUserApp | null {\n  if (!window.location.hash) {\n    return null;\n  }\n  const hash = window.location.hash.substr(1);\n  try {\n    const res = JSON.parse(atob(hash));\n    window.location.hash = \"\";\n    // TODO Add object content validation\n    return res;\n  } catch {\n    return null;\n  }\n}\n\nexport type HashInfos = {\n  appUrl: string;\n  backPath?: string;\n  appCode?: string | null | undefined;\n  path?: string | null | undefined;\n  redirect?: boolean;\n  scopes?: {\n    email: boolean;\n  };\n};\nexport type SecrecyEnv = \"dev\" | \"prod\";\nexport type UseSecrecyParams = Omit<HashInfos, \"appUrl\"> & {\n  env: SecrecyEnv;\n  session?: boolean | undefined;\n};\n\nexport type Value<T extends UseSecrecyParams> = T extends { redirect: true }\n  ? SecrecyClient | null\n  : SecrecyClient;\n\nexport function getSecrecyClient(\n  env: SecrecyEnv,\n  session?: boolean | undefined\n): SecrecyClient | null {\n  const storage = getStorage(session);\n  const uaSession = storage.userAppSession.load();\n  const uaKeys = storage.userAppKeys.load();\n  const uaJwt = storage.jwt.load();\n  if (!uaSession || !uaKeys || !uaJwt) {\n    const infos = parseInfos();\n    if (infos) {\n      storage.userAppKeys.save(infos.keys);\n      storage.userAppSession.save(infos.uaSession);\n      storage.jwt.save(infos.jwt);\n      return new SecrecyClient(infos.uaSession, infos.keys, infos.jwt, env);\n    }\n    return null;\n  }\n\n  return new SecrecyClient(uaSession, uaKeys, uaJwt, env);\n}\n\nexport function login<T extends UseSecrecyParams>(\n  { appCode, path, redirect, scopes, backPath, env, session }: T = {} as T\n): Promise<Value<T>> {\n  return new Promise((resolve, reject) => {\n    const appUrl = window.location.origin;\n    if (appCode && !appUrl.includes(\"localhost\")) {\n      return reject(\"Can't use appCode if not in localhost\");\n    }\n    const client = getSecrecyClient(env);\n\n    if (!client) {\n      const infos: HashInfos = {\n        appUrl,\n        appCode,\n        redirect,\n        path,\n        scopes,\n        backPath\n      };\n      const data = btoa(JSON.stringify(infos)).replaceAll(\"=\", \"\");\n\n      let envStr = \"\";\n      if (env === \"dev\") {\n        envStr = \"dev.\";\n      }\n\n      const lang = document.documentElement.lang;\n\n      const url = process.env.NEXT_PUBLIC_SECRECY_API_URL\n        ? `http://localhost:3002${lang ? `/${lang}` : \"\"}/login#${data}`\n        : `https://auth.${envStr}secrecy.me${\n            lang ? `/${lang}` : \"\"\n          }/login#${data}`;\n\n      const validate = (infos: SecrecyUserApp): void => {\n        const storage = getStorage(session);\n        storage.userAppSession.save(infos.uaSession);\n        storage.userAppKeys.save(infos.keys);\n        storage.jwt.save(infos.jwt);\n        return resolve(\n          new SecrecyClient(\n            infos.uaSession,\n            infos.keys,\n            infos.jwt,\n            env\n          ) as Value<T>\n        );\n      };\n\n      if (redirect) {\n        const infos = parseInfos();\n        if (infos) {\n          return validate(infos);\n        } else {\n          window.location.href = url;\n          return resolve(null as Value<T>);\n        }\n      } else {\n        popup(url, \"Secrecy Login\", {}, (err, data) => {\n          if (err) {\n            return reject(err);\n          } else {\n            const infos = data as SecrecyUserApp;\n            if (infos) {\n              return validate(infos);\n            }\n          }\n        });\n      }\n    } else {\n      return resolve(client as Value<T>);\n    }\n  });\n}\n"],"mappings":"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"}

package/dist/client/index.d.ts

@@ -0,0 +1,164 @@
+import type { MailType, NodeType } from "./../zeus/index";
+import type { DownloadProgress } from "ky";
+import type { FolderSize, SuccessResponse, UserData } from "../BaseClient.js";
+import { BaseClient } from "../BaseClient.js";
+import type { Progress } from "../crypto/file.js";
+import type { ReceivedMail, SentMail, Node, NodeFull, UserAppSettings, UserAppNotifications, FileMetadata as SecrecyFile, WaitingReceivedMail, DraftMail, Mail } from "./types/index.js";
+import type { KeyPair } from "../crypto/index.js";
+import type { SecrecyEnv } from "./helpers.js";
+import type { Rights } from "../zeus/index.js";
+import type { JwtPayload } from "jsonwebtoken";
+import type { ErrorAccessDenied, ErrorNotFound, ErrorBasic, ErrorNotExist, ErrorLimit } from "../error.js";
+export declare type NewMail = {
+    body: string;
+    subject: string;
+    files: {
+        id: string;
+        name: string;
+    }[];
+    recipientsIds: string[];
+    replyTo?: string | null | undefined;
+};
+export declare type ProgressCallback = (progress: Progress) => Promise<void>;
+export declare class SecrecyClient extends BaseClient {
+    #private;
+    jwt: string;
+    jwtDecoded: JwtPayload;
+    constructor(uaSession: string, uaKeys: KeyPair, uaJwt: string, env: SecrecyEnv);
+    get publicKey(): string;
+    get appUserId(): string;
+    addFileToHistory({ fileId, nodeId }: {
+        fileId: string;
+        nodeId: string;
+    }): Promise<SuccessResponse<Node> | ErrorAccessDenied | ErrorNotExist | null>;
+    uploadFile({ file, encryptProgress, uploadProgress, signal }: {
+        file: globalThis.File | Uint8Array;
+        encryptProgress?: ProgressCallback;
+        uploadProgress?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<SuccessResponse<string> | ErrorAccessDenied | ErrorLimit | ErrorNotFound | null>;
+    uploadFileInCloud({ file, name, nodeId, encryptProgress, uploadProgress, signal }: {
+        file: globalThis.File | Uint8Array;
+        name: string;
+        nodeId?: string;
+        encryptProgress?: ProgressCallback;
+        uploadProgress?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<SuccessResponse<NodeFull> | ErrorAccessDenied | ErrorLimit | ErrorNotFound | ErrorBasic | ErrorNotExist | null>;
+    logout(sessionId?: string | null | undefined): Promise<void>;
+    createFolder({ name, parentFolderId }: {
+        name: string;
+        parentFolderId?: string | null;
+    }): Promise<SuccessResponse<NodeFull> | ErrorAccessDenied | ErrorNotExist | null>;
+    node({ id, deleted }?: {
+        id?: string | null | undefined;
+        deleted?: boolean | null | undefined;
+    }): Promise<SuccessResponse<NodeFull> | ErrorAccessDenied | null>;
+    file({ id }: {
+        id: string;
+    }): Promise<SuccessResponse<SecrecyFile> | ErrorAccessDenied | null>;
+    mail({ id }: {
+        id: string;
+    }): Promise<SuccessResponse<Mail> | ErrorAccessDenied | null>;
+    deletedNodes(): Promise<SuccessResponse<Node[]> | ErrorAccessDenied | null>;
+    sharedNodes(): Promise<SuccessResponse<Node[]> | ErrorAccessDenied | null>;
+    nodesSharedWithMe(type?: NodeType | null | undefined): Promise<SuccessResponse<Node[]> | ErrorAccessDenied | null>;
+    deleteNodeSharing({ nodeId, userId }: {
+        nodeId: string;
+        userId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    duplicateNode({ nodeId, folderId, customName }: {
+        nodeId: string;
+        folderId?: string | null | undefined;
+        customName?: string | null | undefined;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorNotFound | null>;
+    deleteNodeCloudTrash({ ids }: {
+        ids: Array<string>;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    shareNode({ nodeId, userId, rights }: {
+        nodeId: string;
+        userId: string;
+        rights: Rights;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorNotFound | null>;
+    updateNode({ nodeId, name, isFavorite, deletedAt }: {
+        nodeId: string;
+        name?: string | null | undefined;
+        isFavorite?: boolean | null | undefined;
+        deletedAt?: Date | null | undefined;
+    }): Promise<SuccessResponse<NodeFull> | ErrorAccessDenied | ErrorNotExist | null>;
+    deletedMails({ mailType }: {
+        mailType: MailType;
+    }): Promise<SuccessResponse<Mail[]> | ErrorAccessDenied | null>;
+    updateAppNotifications(notifications: Partial<UserAppNotifications>): Promise<SuccessResponse<UserAppNotifications> | ErrorAccessDenied | null>;
+    appNotifications(): Promise<SuccessResponse<UserAppNotifications> | ErrorAccessDenied | ErrorNotFound | null>;
+    createMail(data: NewMail, customMessage?: string | null | undefined): Promise<SuccessResponse<boolean> | ErrorBasic | ErrorAccessDenied | null>;
+    waitingReceivedMails(): Promise<SuccessResponse<WaitingReceivedMail[]> | ErrorNotFound | null>;
+    updateDraftMail(draftId: string, { body, subject, files, recipientsIds, replyTo }: Partial<NewMail>): Promise<SuccessResponse<DraftMail> | ErrorNotFound | ErrorAccessDenied | ErrorBasic | null>;
+    deleteDraftMail(draftId: string): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    deleteMailTrash({ ids }: {
+        ids: Array<string>;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    emptyMailTrash(): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    emptyCloudTrash(): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    recoverNode(id: string): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorNotExist | null>;
+    recoverMail({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null>;
+    deleteFile({ fileId, nodeId }: {
+        fileId: string;
+        nodeId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorNotExist | null>;
+    deleteNode({ nodeId }: {
+        nodeId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    moveNodes({ nodeIds, parentNodeId }: {
+        nodeIds: string[];
+        parentNodeId?: string | null | undefined;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    folderSize({ folderId }: {
+        folderId?: string | null | undefined;
+    }): Promise<SuccessResponse<FolderSize> | ErrorAccessDenied | null>;
+    deleteMail({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    saveInCloud({ fileId, name, nodeId }: {
+        fileId: string;
+        name: string;
+        nodeId?: string;
+    }): Promise<SuccessResponse<NodeFull> | ErrorAccessDenied | ErrorBasic | ErrorLimit | ErrorNotFound | ErrorNotExist | null>;
+    dbGet<U>({ field, userId }: {
+        field: string;
+        userId?: string | null | undefined;
+    }): Promise<SuccessResponse<U> | ErrorAccessDenied | ErrorNotExist | ErrorNotFound | null>;
+    dbSet<T extends UserData, U extends Document>({ value, userId }: {
+        value: U;
+        userId?: string | null | undefined;
+    }): Promise<SuccessResponse<T> | ErrorAccessDenied | ErrorNotFound | null>;
+    dbSearch<T>({ search, field }: {
+        field: string;
+        search: string;
+    }): Promise<SuccessResponse<T[]> | ErrorAccessDenied | ErrorBasic | ErrorNotExist | null>;
+    sendDraftMail(draftId: string, customMessage?: string | null | undefined): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null>;
+    sendWaitingEmails(): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | null>;
+    createDraftMail({ body, subject, files, recipientsIds, replyTo }: NewMail): Promise<SuccessResponse<DraftMail> | ErrorAccessDenied | ErrorBasic | null>;
+    fileContent({ fileId, onDownloadProgress, progressDecrypt, signal }: {
+        fileId: string;
+        onDownloadProgress?: (progress: DownloadProgress) => void;
+        progressDecrypt?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<SuccessResponse<Uint8Array> | ErrorAccessDenied | ErrorBasic | null>;
+    readMail({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | ErrorNotFound | null>;
+    unreadMail({ mailId }: {
+        mailId: string;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorBasic | ErrorNotFound | null>;
+    appSettings(): Promise<SuccessResponse<UserAppSettings> | ErrorNotFound | null>;
+    updateAppSettings(settings: Partial<UserAppSettings>): Promise<SuccessResponse<UserAppSettings> | ErrorAccessDenied | ErrorBasic | null>;
+    receivedMails(): Promise<SuccessResponse<ReceivedMail[]> | ErrorNotFound | null>;
+    sentMails(): Promise<SuccessResponse<SentMail[]> | ErrorNotFound | null>;
+    draftMails(): Promise<SuccessResponse<DraftMail[]> | ErrorNotFound | null>;
+    private perNode;
+    unreadReceivedMailsCount(): Promise<SuccessResponse<number> | ErrorAccessDenied | null>;
+    private _eachUser;
+}