@secrecy/lib 1.0.0-dev.54 → 1.0.0-dev.55

package/dist/client/SecrecyAppClient.d.ts

@@ -0,0 +1,17 @@
+import type { SecrecyClient, SuccessResponse, UserAppNotifications, UserAppSettings } from "../index.js";
+import type { KeyPair } from "../crypto/index.js";
+import type { ErrorAccessDenied, ErrorBasic, ErrorNotFound } from "../error.js";
+import type { Thunder } from "../zeus/index.js";
+import type { JwtPayload } from "jsonwebtoken";
+export declare class SecrecyAppClient {
+    #private;
+    jwt: string;
+    jwtDecoded: JwtPayload;
+    constructor(uaJwt: string, _client: SecrecyClient, _keys: KeyPair, thunder: ReturnType<typeof Thunder>);
+    get userId(): string;
+    getJwt(): Promise<string>;
+    updateNotifications(notifications: Partial<UserAppNotifications>): Promise<SuccessResponse<UserAppNotifications> | ErrorAccessDenied | null>;
+    notifications(): Promise<SuccessResponse<UserAppNotifications> | ErrorAccessDenied | ErrorNotFound | null>;
+    settings(): Promise<SuccessResponse<UserAppSettings> | ErrorNotFound | null>;
+    updateSettings(settings: Partial<UserAppSettings>): Promise<SuccessResponse<UserAppSettings> | ErrorAccessDenied | ErrorBasic | null>;
+}

package/dist/client/SecrecyAppClient.js

@@ -0,0 +1,258 @@
+import _classPrivateFieldLooseBase from "@babel/runtime/helpers/classPrivateFieldLooseBase";
+import _classPrivateFieldLooseKey from "@babel/runtime/helpers/classPrivateFieldLooseKey";
+
+/* eslint-disable @typescript-eslint/naming-convention */
+import { decode } from "jsonwebtoken";
+import { getStorage } from "./storage.js";
+
+var _thunder = /*#__PURE__*/_classPrivateFieldLooseKey("thunder");
+
+export class SecrecyAppClient {
+  // #client: SecrecyClient;
+  // #keys: KeyPair;
+  constructor(uaJwt, _client, _keys, thunder) {
+    Object.defineProperty(this, _thunder, {
+      writable: true,
+      value: void 0
+    });
+    this.jwt = uaJwt;
+    this.jwtDecoded = decode(uaJwt); // this.#client = client;
+    // this.#keys = keys;
+
+    _classPrivateFieldLooseBase(this, _thunder)[_thunder] = thunder;
+  }
+
+  get userId() {
+    var _this$jwtDecoded$sub;
+
+    return (_this$jwtDecoded$sub = this.jwtDecoded.sub) != null ? _this$jwtDecoded$sub : "";
+  }
+
+  async getJwt() {
+    // TODO useful?
+    // if (this.jwtDecoded.exp && this.jwtDecoded.exp * 1000 < Date.now()) {
+    //   return this.jwt;
+    // }
+    const {
+      getJwt
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query")({
+      getJwt: [{
+        includeEmail: !!this.jwtDecoded.email
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on JwtResponse": {
+          __typename: true,
+          jwt: true
+        }
+      }]
+    });
+
+    if (!getJwt) {
+      return this.jwt;
+    }
+
+    if (getJwt.__typename === "ErrorAccessDenied") {
+      throw new Error(getJwt.message);
+    }
+
+    this.jwt = getJwt.jwt;
+    this.jwtDecoded = decode(getJwt.jwt);
+    const sessionStorage = getStorage(true);
+    const localStorage = getStorage(false);
+    const sessionJwt = sessionStorage.jwt.load();
+    const localJwt = localStorage.jwt.load();
+
+    if (sessionJwt) {
+      sessionStorage.jwt.save(getJwt.jwt);
+    }
+
+    if (localJwt) {
+      localStorage.jwt.save(getJwt.jwt);
+    }
+
+    return getJwt.jwt;
+  }
+
+  async updateNotifications(notifications) {
+    const {
+      updateAppNotifications
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      updateAppNotifications: [notifications, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on UpdateAppNotificationsResponse": {
+          __typename: true,
+          updateAppNotifications: {
+            enableAll: true,
+            mail: true,
+            cloud: true,
+            disableAllUntil: true
+          }
+        }
+      }]
+    });
+
+    if (!updateAppNotifications) {
+      return null;
+    }
+
+    if (updateAppNotifications.__typename === "ErrorAccessDenied") {
+      return updateAppNotifications;
+    }
+
+    if (!updateAppNotifications.updateAppNotifications) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: updateAppNotifications.updateAppNotifications
+    };
+  }
+
+  async notifications() {
+    const {
+      appNotifications
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query", {
+      scalars: {
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        }
+      }
+    })({
+      appNotifications: {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserAppNotifications": {
+          __typename: true,
+          enableAll: true,
+          mail: true,
+          cloud: true,
+          disableAllUntil: true
+        }
+      }
+    });
+
+    if (!appNotifications) {
+      return null;
+    }
+
+    if (appNotifications.__typename === "ErrorAccessDenied") {
+      return appNotifications;
+    }
+
+    if (appNotifications.__typename === "ErrorNotFound") {
+      return appNotifications;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: appNotifications
+    };
+  }
+
+  async settings() {
+    var _user$user;
+
+    const {
+      user
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("query")({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          user: {
+            appSettings: {
+              cloudNodeDaysForDelete: true,
+              historyFileDaysForDelete: true,
+              historyMaxFileCount: true
+            }
+          }
+        }
+      }]
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (!((_user$user = user.user) != null && _user$user.appSettings)) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: user.user.appSettings
+    };
+  }
+
+  async updateSettings(settings) {
+    const {
+      updateAppSettings
+    } = await _classPrivateFieldLooseBase(this, _thunder)[_thunder]("mutation")({
+      updateAppSettings: [settings, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on UpdateAppSettingsResponse": {
+          __typename: true,
+          updateAppSettings: {
+            cloudNodeDaysForDelete: true,
+            historyFileDaysForDelete: true,
+            historyMaxFileCount: true
+          }
+        }
+      }]
+    });
+
+    if (!updateAppSettings) {
+      return null;
+    }
+
+    if (updateAppSettings.__typename === "ErrorAccessDenied") {
+      return updateAppSettings;
+    }
+
+    if (updateAppSettings.__typename === "ErrorBasic") {
+      return updateAppSettings;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: updateAppSettings.updateAppSettings
+    };
+  }
+
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["decode","getStorage","SecrecyAppClient","constructor","uaJwt","_client","_keys","thunder","jwt","jwtDecoded","userId","sub","getJwt","includeEmail","email","__typename","message","Error","sessionStorage","localStorage","sessionJwt","load","localJwt","save","updateNotifications","notifications","updateAppNotifications","scalars","DateTime","e","Date","encode","toISOString","enableAll","mail","cloud","disableAllUntil","data","appNotifications","settings","user","appSettings","cloudNodeDaysForDelete","historyFileDaysForDelete","historyMaxFileCount","updateSettings","updateAppSettings"],"sources":["../../src/client/SecrecyAppClient.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\nimport type {\n  SecrecyClient,\n  SuccessResponse,\n  UserAppNotifications,\n  UserAppSettings\n} from \"../index.js\";\nimport type { KeyPair } from \"../crypto/index.js\";\nimport type { ErrorAccessDenied, ErrorBasic, ErrorNotFound } from \"../error.js\";\nimport type { Thunder } from \"../zeus/index.js\";\nimport type { JwtPayload } from \"jsonwebtoken\";\nimport { decode } from \"jsonwebtoken\";\nimport { getStorage } from \"./storage.js\";\n\nexport class SecrecyAppClient {\n  jwt: string;\n\n  jwtDecoded: JwtPayload;\n\n  // #client: SecrecyClient;\n\n  // #keys: KeyPair;\n\n  #thunder: ReturnType<typeof Thunder>;\n\n  constructor(\n    uaJwt: string,\n    _client: SecrecyClient,\n    _keys: KeyPair,\n    thunder: ReturnType<typeof Thunder>\n  ) {\n    this.jwt = uaJwt;\n    this.jwtDecoded = decode(uaJwt) as JwtPayload;\n    // this.#client = client;\n    // this.#keys = keys;\n    this.#thunder = thunder;\n  }\n\n  get userId(): string {\n    return this.jwtDecoded.sub ?? \"\";\n  }\n\n  async getJwt(): Promise<string> {\n    // TODO useful?\n    // if (this.jwtDecoded.exp && this.jwtDecoded.exp * 1000 < Date.now()) {\n    //   return this.jwt;\n    // }\n\n    const { getJwt } = await this.#thunder(\"query\")({\n      getJwt: [\n        {\n          includeEmail: !!this.jwtDecoded.email\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on JwtResponse\": {\n            __typename: true,\n            jwt: true\n          }\n        }\n      ]\n    });\n\n    if (!getJwt) {\n      return this.jwt;\n    }\n\n    if (getJwt.__typename === \"ErrorAccessDenied\") {\n      throw new Error(getJwt.message);\n    }\n\n    this.jwt = getJwt.jwt;\n    this.jwtDecoded = decode(getJwt.jwt) as JwtPayload;\n\n    const sessionStorage = getStorage(true);\n    const localStorage = getStorage(false);\n\n    const sessionJwt = sessionStorage.jwt.load();\n    const localJwt = localStorage.jwt.load();\n\n    if (sessionJwt) {\n      sessionStorage.jwt.save(getJwt.jwt);\n    }\n\n    if (localJwt) {\n      localStorage.jwt.save(getJwt.jwt);\n    }\n\n    return getJwt.jwt;\n  }\n\n  async updateNotifications(\n    notifications: Partial<UserAppNotifications>\n  ): Promise<SuccessResponse<UserAppNotifications> | ErrorAccessDenied | null> {\n    const { updateAppNotifications } = await this.#thunder(\"mutation\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      updateAppNotifications: [\n        notifications,\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UpdateAppNotificationsResponse\": {\n            __typename: true,\n            updateAppNotifications: {\n              enableAll: true,\n              mail: true,\n              cloud: true,\n              disableAllUntil: true\n            }\n          }\n        }\n      ]\n    });\n\n    if (!updateAppNotifications) {\n      return null;\n    }\n\n    if (updateAppNotifications.__typename === \"ErrorAccessDenied\") {\n      return updateAppNotifications;\n    }\n\n    if (!updateAppNotifications.updateAppNotifications) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: updateAppNotifications.updateAppNotifications\n    };\n  }\n\n  async notifications(): Promise<\n    | SuccessResponse<UserAppNotifications>\n    | ErrorAccessDenied\n    | ErrorNotFound\n    | null\n  > {\n    const { appNotifications } = await this.#thunder(\"query\", {\n      scalars: {\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        }\n      }\n    })({\n      appNotifications: {\n        \"...on ErrorAccessDenied\": {\n          __typename: true,\n          message: true\n        },\n        \"...on ErrorNotFound\": {\n          __typename: true,\n          message: true\n        },\n        \"...on UserAppNotifications\": {\n          __typename: true,\n          enableAll: true,\n          mail: true,\n          cloud: true,\n          disableAllUntil: true\n        }\n      }\n    });\n\n    if (!appNotifications) {\n      return null;\n    }\n\n    if (appNotifications.__typename === \"ErrorAccessDenied\") {\n      return appNotifications;\n    }\n\n    if (appNotifications.__typename === \"ErrorNotFound\") {\n      return appNotifications;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: appNotifications\n    };\n  }\n\n  async settings(): Promise<\n    SuccessResponse<UserAppSettings> | ErrorNotFound | null\n  > {\n    const { user } = await this.#thunder(\"query\")({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            user: {\n              appSettings: {\n                cloudNodeDaysForDelete: true,\n                historyFileDaysForDelete: true,\n                historyMaxFileCount: true\n              }\n            }\n          }\n        }\n      ]\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (!user.user?.appSettings) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: user.user.appSettings\n    };\n  }\n\n  async updateSettings(\n    settings: Partial<UserAppSettings>\n  ): Promise<\n    SuccessResponse<UserAppSettings> | ErrorAccessDenied | ErrorBasic | null\n  > {\n    const { updateAppSettings } = await this.#thunder(\"mutation\")({\n      updateAppSettings: [\n        settings,\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UpdateAppSettingsResponse\": {\n            __typename: true,\n            updateAppSettings: {\n              cloudNodeDaysForDelete: true,\n              historyFileDaysForDelete: true,\n              historyMaxFileCount: true\n            }\n          }\n        }\n      ]\n    });\n\n    if (!updateAppSettings) {\n      return null;\n    }\n\n    if (updateAppSettings.__typename === \"ErrorAccessDenied\") {\n      return updateAppSettings;\n    }\n\n    if (updateAppSettings.__typename === \"ErrorBasic\") {\n      return updateAppSettings;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: updateAppSettings.updateAppSettings\n    };\n  }\n}\n"],"mappings":";;;AAAA;AAWA,SAASA,MAAT,QAAuB,cAAvB;AACA,SAASC,UAAT,QAA2B,cAA3B;;;;AAEA,OAAO,MAAMC,gBAAN,CAAuB;EAK5B;EAEA;EAIAC,WAAW,CACTC,KADS,EAETC,OAFS,EAGTC,KAHS,EAITC,OAJS,EAKT;IAAA;MAAA;MAAA;IAAA;IACA,KAAKC,GAAL,GAAWJ,KAAX;IACA,KAAKK,UAAL,GAAkBT,MAAM,CAACI,KAAD,CAAxB,CAFA,CAGA;IACA;;IACA,wDAAgBG,OAAhB;EACD;;EAES,IAANG,MAAM,GAAW;IAAA;;IACnB,+BAAO,KAAKD,UAAL,CAAgBE,GAAvB,mCAA8B,EAA9B;EACD;;EAEW,MAANC,MAAM,GAAoB;IAC9B;IACA;IACA;IACA;IAEA,MAAM;MAAEA;IAAF,IAAa,MAAM,sDAAc,OAAd,EAAuB;MAC9CA,MAAM,EAAE,CACN;QACEC,YAAY,EAAE,CAAC,CAAC,KAAKJ,UAAL,CAAgBK;MADlC,CADM,EAIN;QACE,2BAA2B;UACzBC,UAAU,EAAE,IADa;UAEzBC,OAAO,EAAE;QAFgB,CAD7B;QAKE,qBAAqB;UACnBD,UAAU,EAAE,IADO;UAEnBP,GAAG,EAAE;QAFc;MALvB,CAJM;IADsC,CAAvB,CAAzB;;IAkBA,IAAI,CAACI,MAAL,EAAa;MACX,OAAO,KAAKJ,GAAZ;IACD;;IAED,IAAII,MAAM,CAACG,UAAP,KAAsB,mBAA1B,EAA+C;MAC7C,MAAM,IAAIE,KAAJ,CAAUL,MAAM,CAACI,OAAjB,CAAN;IACD;;IAED,KAAKR,GAAL,GAAWI,MAAM,CAACJ,GAAlB;IACA,KAAKC,UAAL,GAAkBT,MAAM,CAACY,MAAM,CAACJ,GAAR,CAAxB;IAEA,MAAMU,cAAc,GAAGjB,UAAU,CAAC,IAAD,CAAjC;IACA,MAAMkB,YAAY,GAAGlB,UAAU,CAAC,KAAD,CAA/B;IAEA,MAAMmB,UAAU,GAAGF,cAAc,CAACV,GAAf,CAAmBa,IAAnB,EAAnB;IACA,MAAMC,QAAQ,GAAGH,YAAY,CAACX,GAAb,CAAiBa,IAAjB,EAAjB;;IAEA,IAAID,UAAJ,EAAgB;MACdF,cAAc,CAACV,GAAf,CAAmBe,IAAnB,CAAwBX,MAAM,CAACJ,GAA/B;IACD;;IAED,IAAIc,QAAJ,EAAc;MACZH,YAAY,CAACX,GAAb,CAAiBe,IAAjB,CAAsBX,MAAM,CAACJ,GAA7B;IACD;;IAED,OAAOI,MAAM,CAACJ,GAAd;EACD;;EAEwB,MAAnBgB,mBAAmB,CACvBC,aADuB,EAEoD;IAC3E,MAAM;MAAEC;IAAF,IAA6B,MAAM,sDAAc,UAAd,EAA0B;MACjEC,OAAO,EAAE;QACPC,QAAQ,EAAE;UACR5B,MAAM,EAAG6B,CAAD,IAAgB,IAAIC,IAAJ,CAASD,CAAT,CADhB;UAERE,MAAM,EAAGF,CAAD,IAAiBA,CAAD,CAAYG,WAAZ;QAFhB;MADH;IADwD,CAA1B,EAOtC;MACDN,sBAAsB,EAAE,CACtBD,aADsB,EAEtB;QACE,2BAA2B;UACzBV,UAAU,EAAE,IADa;UAEzBC,OAAO,EAAE;QAFgB,CAD7B;QAKE,wCAAwC;UACtCD,UAAU,EAAE,IAD0B;UAEtCW,sBAAsB,EAAE;YACtBO,SAAS,EAAE,IADW;YAEtBC,IAAI,EAAE,IAFgB;YAGtBC,KAAK,EAAE,IAHe;YAItBC,eAAe,EAAE;UAJK;QAFc;MAL1C,CAFsB;IADvB,CAPsC,CAAzC;;IA4BA,IAAI,CAACV,sBAAL,EAA6B;MAC3B,OAAO,IAAP;IACD;;IAED,IAAIA,sBAAsB,CAACX,UAAvB,KAAsC,mBAA1C,EAA+D;MAC7D,OAAOW,sBAAP;IACD;;IAED,IAAI,CAACA,sBAAsB,CAACA,sBAA5B,EAAoD;MAClD,OAAO,IAAP;IACD;;IAED,OAAO;MACLX,UAAU,EAAE,iBADP;MAELsB,IAAI,EAAEX,sBAAsB,CAACA;IAFxB,CAAP;EAID;;EAEkB,MAAbD,aAAa,GAKjB;IACA,MAAM;MAAEa;IAAF,IAAuB,MAAM,sDAAc,OAAd,EAAuB;MACxDX,OAAO,EAAE;QACPC,QAAQ,EAAE;UACR5B,MAAM,EAAG6B,CAAD,IAAgB,IAAIC,IAAJ,CAASD,CAAT,CADhB;UAERE,MAAM,EAAGF,CAAD,IAAiBA,CAAD,CAAYG,WAAZ;QAFhB;MADH;IAD+C,CAAvB,EAOhC;MACDM,gBAAgB,EAAE;QAChB,2BAA2B;UACzBvB,UAAU,EAAE,IADa;UAEzBC,OAAO,EAAE;QAFgB,CADX;QAKhB,uBAAuB;UACrBD,UAAU,EAAE,IADS;UAErBC,OAAO,EAAE;QAFY,CALP;QAShB,8BAA8B;UAC5BD,UAAU,EAAE,IADgB;UAE5BkB,SAAS,EAAE,IAFiB;UAG5BC,IAAI,EAAE,IAHsB;UAI5BC,KAAK,EAAE,IAJqB;UAK5BC,eAAe,EAAE;QALW;MATd;IADjB,CAPgC,CAAnC;;IA2BA,IAAI,CAACE,gBAAL,EAAuB;MACrB,OAAO,IAAP;IACD;;IAED,IAAIA,gBAAgB,CAACvB,UAAjB,KAAgC,mBAApC,EAAyD;MACvD,OAAOuB,gBAAP;IACD;;IAED,IAAIA,gBAAgB,CAACvB,UAAjB,KAAgC,eAApC,EAAqD;MACnD,OAAOuB,gBAAP;IACD;;IAED,OAAO;MACLvB,UAAU,EAAE,iBADP;MAELsB,IAAI,EAAEC;IAFD,CAAP;EAID;;EAEa,MAARC,QAAQ,GAEZ;IAAA;;IACA,MAAM;MAAEC;IAAF,IAAW,MAAM,sDAAc,OAAd,EAAuB;MAC5CA,IAAI,EAAE,CACJ,EADI,EAEJ;QACE,uBAAuB;UACrBzB,UAAU,EAAE,IADS;UAErBC,OAAO,EAAE;QAFY,CADzB;QAKE,sBAAsB;UACpBD,UAAU,EAAE,IADQ;UAEpByB,IAAI,EAAE;YACJC,WAAW,EAAE;cACXC,sBAAsB,EAAE,IADb;cAEXC,wBAAwB,EAAE,IAFf;cAGXC,mBAAmB,EAAE;YAHV;UADT;QAFc;MALxB,CAFI;IADsC,CAAvB,CAAvB;;IAsBA,IAAI,CAACJ,IAAL,EAAW;MACT,OAAO,IAAP;IACD;;IAED,IAAIA,IAAI,CAACzB,UAAL,KAAoB,eAAxB,EAAyC;MACvC,OAAOyB,IAAP;IACD;;IAED,IAAI,gBAACA,IAAI,CAACA,IAAN,aAAC,WAAWC,WAAZ,CAAJ,EAA6B;MAC3B,OAAO,IAAP;IACD;;IAED,OAAO;MACL1B,UAAU,EAAE,iBADP;MAELsB,IAAI,EAAEG,IAAI,CAACA,IAAL,CAAUC;IAFX,CAAP;EAID;;EAEmB,MAAdI,cAAc,CAClBN,QADkB,EAIlB;IACA,MAAM;MAAEO;IAAF,IAAwB,MAAM,sDAAc,UAAd,EAA0B;MAC5DA,iBAAiB,EAAE,CACjBP,QADiB,EAEjB;QACE,2BAA2B;UACzBxB,UAAU,EAAE,IADa;UAEzBC,OAAO,EAAE;QAFgB,CAD7B;QAKE,oBAAoB;UAClBD,UAAU,EAAE,IADM;UAElBC,OAAO,EAAE;QAFS,CALtB;QASE,mCAAmC;UACjCD,UAAU,EAAE,IADqB;UAEjC+B,iBAAiB,EAAE;YACjBJ,sBAAsB,EAAE,IADP;YAEjBC,wBAAwB,EAAE,IAFT;YAGjBC,mBAAmB,EAAE;UAHJ;QAFc;MATrC,CAFiB;IADyC,CAA1B,CAApC;;IAwBA,IAAI,CAACE,iBAAL,EAAwB;MACtB,OAAO,IAAP;IACD;;IAED,IAAIA,iBAAiB,CAAC/B,UAAlB,KAAiC,mBAArC,EAA0D;MACxD,OAAO+B,iBAAP;IACD;;IAED,IAAIA,iBAAiB,CAAC/B,UAAlB,KAAiC,YAArC,EAAmD;MACjD,OAAO+B,iBAAP;IACD;;IAED,OAAO;MACL/B,UAAU,EAAE,iBADP;MAELsB,IAAI,EAAES,iBAAiB,CAACA;IAFnB,CAAP;EAID;;AA5Q2B"}

package/dist/client/SecrecyCloudClient.d.ts

@@ -0,0 +1,89 @@
+import type { DownloadProgress, ProgressCallback, SecrecyClient, SuccessResponse } from "../index.js";
+import type { KeyPair } from "../crypto/index.js";
+import type { ErrorAccessDenied, ErrorBasic, ErrorLimit, ErrorNotExist, ErrorNotFound } from "../error.js";
+import type { NodeType, Rights, Thunder } from "../zeus/index.js";
+import type { FileMetadata, Node, NodeFull } from "./types/index.js";
+export declare class SecrecyCloudClient {
+    #private;
+    constructor(client: SecrecyClient, keys: KeyPair, thunder: ReturnType<typeof Thunder>);
+    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>;
+    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>;
+    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<FileMetadata> | 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>;
+    fileContent({ fileId, onDownloadProgress, progressDecrypt, signal }: {
+        fileId: string;
+        onDownloadProgress?: (progress: DownloadProgress) => void;
+        progressDecrypt?: ProgressCallback;
+        signal?: AbortSignal;
+    }): Promise<SuccessResponse<Uint8Array> | 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>;
+    emptyTrash(): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    recoverNode(id: string): Promise<SuccessResponse<boolean> | ErrorAccessDenied | ErrorNotExist | null>;
+    moveNodes({ nodeIds, parentNodeId }: {
+        nodeIds: string[];
+        parentNodeId?: string | null | undefined;
+    }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null>;
+    saveInCloud({ fileId, name, nodeId }: {
+        fileId: string;
+        name: string;
+        nodeId?: string;
+    }): Promise<SuccessResponse<NodeFull> | ErrorAccessDenied | ErrorBasic | ErrorLimit | ErrorNotFound | ErrorNotExist | null>;
+    private perNode;
+}