@secrecy/lib 1.0.0-dev.9 → 1.0.0

package/dist/BaseClient.js

@@ -0,0 +1,1124 @@
+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; }
+
+/* eslint-disable @typescript-eslint/naming-convention */
+import { getLink } from "@secrecy/lib-utils";
+import { usersCache } from "./cache.js";
+import { getStorage } from "./client/storage.js";
+import { Selector } from "./zeus/index.js";
+import { createThunder } from "./ZeusThunder.js";
+
+function internalToPaymentInfos(p) {
+  return _objectSpread(_objectSpread({}, p), {}, {
+    currentSubscription: _objectSpread(_objectSpread({}, p.currentSubscription), {}, {
+      state: p.currentSubscription.state,
+      collectionMethod: p.currentSubscription.collectionMethod
+    }),
+    invoices: p.invoices.map(i => _objectSpread(_objectSpread({}, i), {}, {
+      status: i.status
+    }))
+  });
+}
+
+const plansCodes = ["basic_month", "advanced_month", "pro_month", "basic_year", "advanced_year", "pro_year"];
+export function isValidPlan(planCode) {
+  return plansCodes.includes(planCode);
+}
+
+const getUserSelector = (userId, withPublicKey) => {
+  const {
+    user
+  } = Selector("Query")({
+    user: [{
+      userId
+    }, {
+      "...on ErrorNotFound": {
+        __typename: true,
+        message: true,
+        field: true
+      },
+      "...on UserResponse": {
+        __typename: true,
+        user: {
+          id: true,
+          firstname: true,
+          lastname: true,
+          lang: true,
+          publicKey: withPublicKey ? true : undefined,
+          email: true,
+          phone: true,
+          role: true,
+          deletedAt: true,
+          lastLogin: true
+        }
+      }
+    }]
+  });
+  return user;
+};
+
+async function getUser(params) {
+  var _params$userId;
+
+  const selector = getUserSelector((_params$userId = params.userId) != null ? _params$userId : params.userEmail, params.withPublicKey);
+  const {
+    user: userResponse
+  } = await params.client("query", {
+    scalars: {
+      Json: {
+        encode: e => JSON.stringify(e),
+        decode: e => JSON.parse(e)
+      },
+      DateTime: {
+        decode: e => new Date(e),
+        encode: e => e.toISOString()
+      },
+      BigInt: {
+        decode: e => BigInt(e),
+        encode: e => e.toString()
+      }
+    }
+  })({
+    user: selector
+  });
+
+  if (!userResponse) {
+    return null;
+  }
+
+  if (userResponse.__typename === "ErrorNotFound") {
+    return userResponse;
+  }
+
+  if (!userResponse.user) {
+    return null;
+  }
+
+  return {
+    __typename: "SuccessResponse",
+    data: userResponse.user
+  };
+}
+
+export class BaseClient {
+  constructor(session, env) {
+    this.sessionId = session;
+    this.client = BaseClient._getBaseClient(env, session);
+  }
+
+  async sessions() {
+    const data = await this.client("query", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          field: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          user: {
+            sessions: {
+              id: true,
+              lastActivity: true,
+              userAgent: true,
+              ip: true,
+              city: true,
+              country: true,
+              appSessions: {
+                id: true,
+                lastActivity: true,
+                userAgent: true,
+                ip: true,
+                city: true,
+                country: true,
+                userApp: {
+                  app: {
+                    name: true
+                  }
+                }
+              }
+            }
+          }
+        }
+      }]
+    });
+
+    if (!data.user) {
+      return null;
+    }
+
+    const userResponse = data.user;
+
+    if (userResponse.__typename === "UserResponse") {
+      var _userResponse$user$se;
+
+      if (!userResponse.user) {
+        return null;
+      }
+
+      const sessions = (_userResponse$user$se = userResponse.user.sessions.map(s => ({
+        id: s.id,
+        ip: s.ip,
+        city: s.city,
+        country: s.country,
+        lastActivity: s.lastActivity ? new Date(s.lastActivity) : undefined,
+        userAgent: s.userAgent,
+        appSessions: s.appSessions.map(a => {
+          var _a$userApp$app$name, _a$userApp;
+
+          return {
+            id: a.id,
+            ip: a.ip,
+            city: a.city,
+            country: a.country,
+            lastActivity: a.lastActivity ? new Date(a.lastActivity) : undefined,
+            userAgent: a.userAgent,
+            app: (_a$userApp$app$name = (_a$userApp = a.userApp) == null ? void 0 : _a$userApp.app.name) != null ? _a$userApp$app$name : ""
+          };
+        })
+      }))) != null ? _userResponse$user$se : [];
+      return {
+        __typename: "SuccessResponse",
+        data: sessions
+      };
+    }
+
+    return userResponse;
+  }
+
+  async logout(sessionId) {
+    if (!sessionId) {
+      const local = getStorage(false);
+      const session = getStorage(true);
+      local.jwt.clear();
+      local.userAppKeys.clear();
+      local.userAppSession.clear();
+      session.jwt.clear();
+      session.userAppKeys.clear();
+      session.userAppSession.clear();
+      usersCache.clear();
+    }
+
+    try {
+      await this.client("mutation")({
+        logout: [{
+          sessionId: sessionId
+        }, {
+          "...on ErrorAccessDenied": {
+            __typename: true,
+            message: true
+          },
+          "...on ErrorBasic": {
+            __typename: true,
+            message: true
+          },
+          "...on LogoutResponse": {
+            __typename: true,
+            logout: true
+          }
+        }]
+      });
+    } catch {//
+    }
+  }
+
+  async me(params) {
+    return this.user(params || {
+      withPublicKey: true
+    });
+  }
+
+  static async user(params, sessionId) {
+    var _params$userId2;
+
+    const user = await getUser({
+      client: this._getBaseClient(params.env, sessionId),
+      userId: (_params$userId2 = params.userId) != null ? _params$userId2 : params.userEmail,
+      withPublicKey: params.withPublicKey
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (user) {
+      usersCache.set(user.data.id, user.data);
+    }
+
+    return user;
+  }
+
+  async user(params) {
+    var _params$userId3;
+
+    const user = await getUser({
+      client: this.client,
+      userId: (_params$userId3 = params.userId) != null ? _params$userId3 : params.userEmail,
+      withPublicKey: params.withPublicKey
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    if (user) {
+      usersCache.set(user.data.id, user.data);
+    }
+
+    return user;
+  }
+
+  async updateProfile(_ref) {
+    let {
+      firstname,
+      lastname,
+      lang
+    } = _ref;
+    const {
+      updateProfile
+    } = await this.client("mutation", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      updateProfile: [{
+        firstname,
+        lastname,
+        lang
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UpdateProfileResponse": {
+          __typename: true,
+          updateProfile: {
+            id: true,
+            firstname: true,
+            lastname: true,
+            lang: true,
+            email: true,
+            phone: true,
+            role: true,
+            deletedAt: true,
+            lastLogin: true
+          }
+        }
+      }]
+    });
+
+    if (!updateProfile) {
+      return null;
+    }
+
+    if (updateProfile.__typename === "ErrorAccessDenied") {
+      return updateProfile;
+    }
+
+    if (updateProfile.__typename === "ErrorNotFound") {
+      return updateProfile;
+    }
+
+    if (!updateProfile.updateProfile) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: updateProfile.updateProfile
+    };
+  }
+
+  static async plans(env, sessionId) {
+    const {
+      plans
+    } = await BaseClient._getBaseClient(env, sessionId)("query", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      plans: {
+        "...on PlanResponse": {
+          __typename: true,
+          plan: {
+            kind: true,
+            codes: true,
+            limits: {
+              downloadBandwidth: true,
+              downloadCount: true,
+              hardFileCount: true,
+              hardFileSize: true,
+              perFileSize: true,
+              uploadBandwidth: true,
+              uploadCount: true,
+              receivedMails: {
+                count: true,
+                fileCount: true,
+                fileSize: true,
+                hardCount: true,
+                hardFileCount: true,
+                hardFileSize: true,
+                perFileSize: true
+              },
+              sentMails: {
+                count: true,
+                fileCount: true,
+                fileSize: true,
+                hardCount: true,
+                hardFileCount: true,
+                hardFileSize: true,
+                perFileSize: true
+              }
+            }
+          }
+        }
+      }
+    });
+
+    if (!plans) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: plans.plan
+    };
+  }
+
+  async pay(planCode, input, autoRenew) {
+    var _pay$pay;
+
+    const {
+      pay
+    } = await this.client("mutation")({
+      pay: [{
+        input,
+        planCode,
+        autoRenew
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on PayResponse": {
+          __typename: true,
+          pay: true
+        }
+      }]
+    });
+
+    if (!pay) {
+      return null;
+    }
+
+    if (pay.__typename === "ErrorAccessDenied") {
+      return pay;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: (_pay$pay = pay.pay) != null ? _pay$pay : false
+    };
+  }
+
+  async cancelPayment() {
+    var _cancelPayment$cancel;
+
+    const {
+      cancelPayment
+    } = await this.client("mutation")({
+      cancelPayment: {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on CancelPaymentResponse": {
+          __typename: true,
+          cancelPayment: true
+        }
+      }
+    });
+
+    if (!cancelPayment) {
+      return null;
+    }
+
+    if (cancelPayment.__typename === "ErrorAccessDenied") {
+      return cancelPayment;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: (_cancelPayment$cancel = cancelPayment.cancelPayment) != null ? _cancelPayment$cancel : false
+    };
+  }
+
+  async paymentInfos() {
+    const {
+      paymentInfos
+    } = await this.client("query", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      paymentInfos: {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on PaymentInfosResponse": {
+          __typename: true,
+          paymentInfos: {
+            hostedUrl: true,
+            currentSubscription: {
+              autorenew: true,
+              activatedAt: true,
+              currentPeriodEndsAt: true,
+              currentPeriodStartedAt: true,
+              canceledAt: true,
+              createdAt: true,
+              expiresAt: true,
+              pausedAt: true,
+              trialEndsAt: true,
+              trialStartedAt: true,
+              updatedAt: true,
+              state: true,
+              collectionMethod: true,
+              plan: true,
+              planCode: true,
+              total: true
+            },
+            invoices: {
+              pdf: true,
+              date: true,
+              due: true,
+              status: true,
+              total: true,
+              name: true,
+              currency: true
+            }
+          }
+        }
+      }
+    });
+
+    if (!paymentInfos) {
+      return null;
+    }
+
+    if (paymentInfos.__typename === "ErrorAccessDenied") {
+      return paymentInfos;
+    }
+
+    if (!paymentInfos.paymentInfos) {
+      return null;
+    }
+
+    const result = internalToPaymentInfos(paymentInfos.paymentInfos);
+    return {
+      __typename: "SuccessResponse",
+      data: result
+    };
+  }
+
+  async limits() {
+    const {
+      limits
+    } = await this.client("query", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      limits: {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorLimit": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotExist": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on QueryLimits": {
+          __typename: true,
+          cloud: {
+            size: true,
+            maxSize: true,
+            count: true,
+            maxCount: true
+          },
+          mail: {
+            received: {
+              count: true,
+              maxCount: true,
+              fileCount: true,
+              maxFileCount: true,
+              fileSize: true,
+              maxFileSize: true
+            },
+            sent: {
+              count: true,
+              maxCount: true,
+              fileCount: true,
+              maxFileCount: true,
+              fileSize: true,
+              maxFileSize: true
+            }
+          }
+        }
+      }
+    });
+
+    if (!limits) {
+      return null;
+    }
+
+    if (limits.__typename === "ErrorAccessDenied") {
+      return limits;
+    }
+
+    if (limits.__typename === "ErrorNotExist") {
+      return limits;
+    }
+
+    if (limits.__typename === "ErrorLimit") {
+      return limits;
+    }
+
+    if (limits.__typename === "ErrorNotFound") {
+      return limits;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: limits
+    };
+  }
+
+  async godFatherAndChildren() {
+    const {
+      user
+    } = await this.client("query")({
+      user: [{}, {
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on UserResponse": {
+          __typename: true,
+          godChildren: {
+            id: true,
+            firstname: true,
+            lastname: true,
+            email: true,
+            phone: true
+          },
+          godFather: {
+            id: true,
+            firstname: true,
+            lastname: true,
+            email: true,
+            phone: true
+          }
+        }
+      }]
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    if (user.__typename === "ErrorNotFound") {
+      return user;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: {
+        godChildren: user.godChildren,
+        godFather: user.godFather
+      }
+    };
+  }
+
+  static async updateAppDBConfig(_ref2) {
+    let {
+      appCode,
+      config,
+      env,
+      sessionId
+    } = _ref2;
+    const {
+      dbConfigMutation
+    } = await BaseClient._getBaseClient(env, sessionId)("mutation")({
+      dbConfigMutation: [{
+        appCode,
+        config: JSON.stringify(config)
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on DbConfigMutationResponse": {
+          __typename: true,
+          dbConfigMutation: true
+        }
+      }]
+    });
+
+    if (!dbConfigMutation) {
+      return null;
+    }
+
+    if (dbConfigMutation.__typename === "ErrorAccessDenied") {
+      return dbConfigMutation;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: dbConfigMutation.dbConfigMutation
+    };
+  }
+
+  static async getAppDBConfig(appCode, env, sessionId) {
+    const {
+      dbConfig
+    } = await BaseClient._getBaseClient(env, sessionId)("query")({
+      dbConfig: [{
+        appCode
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotExist": {
+          __typename: true,
+          message: true
+        },
+        "...on DbConfigResponse": {
+          __typename: true,
+          json: true
+        }
+      }]
+    });
+
+    if (!dbConfig) {
+      return null;
+    }
+
+    if (dbConfig.__typename === "ErrorAccessDenied") {
+      return dbConfig;
+    }
+
+    if (dbConfig.__typename === "ErrorNotFound") {
+      return dbConfig;
+    }
+
+    if (dbConfig.__typename === "ErrorNotExist") {
+      return dbConfig;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: dbConfig.json
+    };
+  }
+
+  static async getFAQ(_ref3) {
+    let {
+      lang,
+      env,
+      sessionId
+    } = _ref3;
+    const {
+      faq
+    } = await BaseClient._getBaseClient(env, sessionId)("query")({
+      faq: [{
+        lang
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on FaqResponse": {
+          __typename: true,
+          faq: {
+            answer: true,
+            order: true,
+            question: true
+          }
+        }
+      }]
+    });
+
+    if (!faq) {
+      return null;
+    }
+
+    if (faq.__typename === "ErrorAccessDenied") {
+      return faq;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: faq.faq
+    };
+  }
+
+  static async getBlog(_ref4) {
+    let {
+      env,
+      lang,
+      sessionId
+    } = _ref4;
+    const {
+      blog
+    } = await BaseClient._getBaseClient(env, sessionId)("query", {
+      scalars: {
+        Json: {
+          encode: e => JSON.stringify(e),
+          decode: e => JSON.parse(e)
+        },
+        DateTime: {
+          decode: e => new Date(e),
+          encode: e => e.toISOString()
+        },
+        BigInt: {
+          decode: e => BigInt(e),
+          encode: e => e.toString()
+        }
+      }
+    })({
+      blog: [{
+        lang
+      }, {
+        "...on ErrorLangNotExist": {
+          __typename: true,
+          message: true
+        },
+        "...on BlogResponse": {
+          __typename: true,
+          blogItems: {
+            id: true,
+            blogId: true,
+            author: true,
+            body: true,
+            date: true,
+            image: true,
+            imageAlt: true,
+            summary: true,
+            title: true,
+            order: true
+          }
+        }
+      }]
+    });
+
+    if (!blog) {
+      return null;
+    }
+
+    if (blog.__typename === "ErrorLangNotExist") {
+      return blog;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: blog.blogItems
+    };
+  }
+
+  async reportUser(reportedUserId, customMessage) {
+    const {
+      sendReport
+    } = await this.client("mutation")({
+      sendReport: [{
+        reportedUserId,
+        customMessage
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on SendReportResponse": {
+          __typename: true,
+          sendReport: {
+            id: true,
+            customMessage: true,
+            user: {
+              id: true,
+              firstname: true,
+              lastname: true,
+              email: true
+            },
+            reportedUser: {
+              id: true,
+              firstname: true,
+              lastname: true,
+              email: true
+            }
+          }
+        }
+      }]
+    });
+
+    if (!sendReport) {
+      return null;
+    }
+
+    if (sendReport.__typename === "ErrorAccessDenied") {
+      return sendReport;
+    }
+
+    if (sendReport.__typename === "ErrorNotFound") {
+      return sendReport;
+    }
+
+    if (!sendReport.sendReport) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: sendReport.sendReport
+    };
+  }
+
+  static async deleteUser(_ref5) {
+    let {
+      sessionId,
+      userId,
+      env
+    } = _ref5;
+    const {
+      deleteUser
+    } = await BaseClient._getBaseClient(env, sessionId)("mutation")({
+      deleteUser: [{
+        userId
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on DeleteUserResponse": {
+          __typename: true,
+          deleteUser: true
+        }
+      }]
+    });
+
+    if (!deleteUser) {
+      return null;
+    }
+
+    if (deleteUser.__typename === "ErrorAccessDenied") {
+      return deleteUser;
+    }
+
+    if (!deleteUser.deleteUser) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: deleteUser.deleteUser
+    };
+  }
+
+  async getSponsorshipLink(_ref6) {
+    let {
+      backUrl
+    } = _ref6;
+    const me = await this.me({
+      withPublicKey: false
+    });
+
+    if (!me) {
+      return null;
+    }
+
+    if (me.__typename === "ErrorNotFound") {
+      return null;
+    }
+
+    return getLink({
+      app: "auth",
+      path: "/sign-up?gf=" + btoa(me.data.email) + "&au=" + btoa(backUrl)
+    });
+  }
+
+  async updateAutoDisconnectDelay(_ref7) {
+    let {
+      id,
+      delay
+    } = _ref7;
+    const {
+      updateAutoDisconnectDelay
+    } = await this.client("mutation")({
+      updateAutoDisconnectDelay: [{
+        userId: id,
+        delay: delay != null ? delay : null
+      }, {
+        "...on ErrorAccessDenied": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorNotFound": {
+          __typename: true,
+          message: true
+        },
+        "...on ErrorBasic": {
+          __typename: true,
+          message: true
+        },
+        "...on UpdateAutoDisconnectDelayResponse": {
+          __typename: true,
+          updateAutoDisconnectDelay: true
+        }
+      }]
+    });
+
+    if (!updateAutoDisconnectDelay) {
+      return null;
+    }
+
+    if (updateAutoDisconnectDelay.__typename === "ErrorAccessDenied") {
+      return updateAutoDisconnectDelay;
+    }
+
+    if (updateAutoDisconnectDelay.__typename === "ErrorBasic") {
+      return updateAutoDisconnectDelay;
+    }
+
+    if (updateAutoDisconnectDelay.__typename === "ErrorNotFound") {
+      return updateAutoDisconnectDelay;
+    }
+
+    if (!updateAutoDisconnectDelay.updateAutoDisconnectDelay) {
+      return null;
+    }
+
+    return {
+      __typename: "SuccessResponse",
+      data: updateAutoDisconnectDelay.updateAutoDisconnectDelay
+    };
+  }
+
+}
+
+BaseClient.getBaseUrl = function (env, graphcdn) {
+  if (env === void 0) {
+    env = "prod";
+  }
+
+  if (graphcdn === void 0) {
+    graphcdn = true;
+  }
+
+  const apiUrl = process.env.NEXT_PUBLIC_SECRECY_API_URL;
+
+  if (apiUrl) {
+    return apiUrl;
+  }
+
+  switch (env) {
+    case "prod":
+      return graphcdn ? "https://secrecy.graphcdn.app" : "https://api.secrecy.me/graphql";
+
+    case "dev":
+    default:
+      return "https://api.dev.secrecy.me/graphql";
+  }
+};
+
+BaseClient._getBaseClient = (env, session) => createThunder(BaseClient.getBaseUrl(env), session);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["getLink","usersCache","getStorage","Selector","createThunder","internalToPaymentInfos","p","currentSubscription","state","collectionMethod","invoices","map","i","status","plansCodes","isValidPlan","planCode","includes","getUserSelector","userId","withPublicKey","user","__typename","message","field","id","firstname","lastname","lang","publicKey","undefined","email","phone","role","deletedAt","lastLogin","getUser","params","selector","userEmail","userResponse","client","scalars","Json","encode","e","JSON","stringify","decode","parse","DateTime","Date","toISOString","BigInt","toString","data","BaseClient","constructor","session","env","sessionId","_getBaseClient","sessions","lastActivity","userAgent","ip","city","country","appSessions","userApp","app","name","s","a","logout","local","jwt","clear","userAppKeys","userAppSession","me","set","updateProfile","plans","plan","kind","codes","limits","downloadBandwidth","downloadCount","hardFileCount","hardFileSize","perFileSize","uploadBandwidth","uploadCount","receivedMails","count","fileCount","fileSize","hardCount","sentMails","pay","input","autoRenew","cancelPayment","paymentInfos","hostedUrl","autorenew","activatedAt","currentPeriodEndsAt","currentPeriodStartedAt","canceledAt","createdAt","expiresAt","pausedAt","trialEndsAt","trialStartedAt","updatedAt","total","pdf","date","due","currency","result","cloud","size","maxSize","maxCount","mail","received","maxFileCount","maxFileSize","sent","godFatherAndChildren","godChildren","godFather","updateAppDBConfig","appCode","config","dbConfigMutation","getAppDBConfig","dbConfig","json","getFAQ","faq","answer","order","question","getBlog","blog","blogItems","blogId","author","body","image","imageAlt","summary","title","reportUser","reportedUserId","customMessage","sendReport","reportedUser","deleteUser","getSponsorshipLink","backUrl","path","btoa","updateAutoDisconnectDelay","delay","getBaseUrl","graphcdn","apiUrl","process","NEXT_PUBLIC_SECRECY_API_URL"],"sources":["../src/BaseClient.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\nimport type { DownloadProgress as DLProgress } from \"ky\";\nimport { getLink } from \"@secrecy/lib-utils\";\nimport { usersCache } from \"./cache.js\";\nimport type { UserSession } from \"./client/types/index.js\";\nimport type { SecrecyEnv } from \"./client/helpers.js\";\nimport { getStorage } from \"./client/storage.js\";\nimport type {\n  Lang,\n  PayInputType,\n  PlanKind,\n  Thunder,\n  UserRole\n} from \"./zeus/index.js\";\nimport { Selector } from \"./zeus/index.js\";\nimport { createThunder } from \"./ZeusThunder.js\";\nimport type {\n  ErrorAccessDenied,\n  ErrorLimit,\n  ErrorNotFound,\n  ErrorNotExist,\n  ErrorLangNotExist,\n  ErrorBasic\n} from \"./error.js\";\n\nexport type SuccessResponse<T> = {\n  __typename: \"SuccessResponse\";\n  data: T;\n};\n\nexport type DownloadProgress = DLProgress;\n\nexport type PayInput = {\n  type: PayInputType;\n  token: string;\n  firstName: string;\n  lastName: string;\n  street: string;\n  postalCode: string;\n  city: string;\n  country: string;\n  month: string;\n  year: string;\n  cvv: string;\n  number: string;\n};\n\nexport type MailLimits = {\n  count?: bigint | undefined;\n  fileCount?: bigint | undefined;\n  fileSize?: bigint | undefined;\n  hardCount?: bigint | undefined;\n  hardFileCount?: bigint | undefined;\n  hardFileSize?: bigint | undefined;\n  perFileSize?: bigint | undefined;\n};\n\nexport type Limits = {\n  downloadBandwidth?: bigint | undefined;\n  downloadCount?: bigint | undefined;\n  hardFileCount?: bigint | undefined;\n  hardFileSize?: bigint | undefined;\n  perFileSize?: bigint | undefined;\n  receivedMails: MailLimits;\n  sentMails: MailLimits;\n  uploadBandwidth?: bigint | undefined;\n  uploadCount?: bigint | undefined;\n};\n\nexport type GodUser = {\n  id: string;\n  firstname: string;\n  lastname: string;\n  email: string;\n  phone: string;\n};\n\nexport type GodFatherAndChildren = {\n  godFather: GodUser | null;\n  godChildren: GodUser[];\n};\n\nexport type Plan = {\n  codes: string[];\n  kind: PlanKind;\n  limits: Limits;\n};\n\nexport type SubscriptionState =\n  | \"active\"\n  | \"canceled\"\n  | \"paused\"\n  | \"expired\"\n  | \"future\"\n  | \"in_trial\"\n  | \"live\"\n  | \"past_due\";\n\nexport type SubscriptionCollectionMethod = \"automatic\" | \"manual\";\n\ntype InternalSubscription = {\n  autorenew: boolean;\n  activatedAt?: Date | null | undefined;\n  currentPeriodEndsAt?: Date | null | undefined;\n  currentPeriodStartedAt?: Date | null | undefined;\n  canceledAt?: Date | null | undefined;\n  createdAt?: Date | null | undefined;\n  expiresAt?: Date | null | undefined;\n  pausedAt?: Date | null | undefined;\n  trialEndsAt?: Date | null | undefined;\n  trialStartedAt?: Date | null | undefined;\n  updatedAt?: Date | null | undefined;\n  collectionMethod: string;\n  state: string;\n  plan?: string | null | undefined;\n  planCode?: string | null | undefined;\n  total?: number | null | undefined;\n};\n\ntype RecurlyInvoiceStatus =\n  | \"pending\"\n  | \"paid\"\n  | \"failed\"\n  | \"past_due\"\n  | \"open\"\n  | \"closed\"\n  | \"voided\"\n  | \"processing\";\n\ntype InternalRecurlyInvoices = {\n  pdf: string;\n  date: Date;\n  due: Date;\n  status: string;\n  total: number;\n  name: string;\n  currency: string;\n};\n\ntype InternalPaymentInfos = {\n  hostedUrl: string;\n  currentSubscription: InternalSubscription;\n  invoices: InternalRecurlyInvoices[];\n};\n\nexport type Subscription = InternalSubscription & {\n  collectionMethod: SubscriptionCollectionMethod;\n  state: SubscriptionState;\n};\n\nexport type RecurlyInvoices = InternalRecurlyInvoices & {\n  status: RecurlyInvoiceStatus;\n};\n\nexport type PaymentInfos = {\n  hostedUrl: string;\n  currentSubscription: Subscription;\n  invoices: RecurlyInvoices[];\n};\n\nexport type SendReport = {\n  id: string;\n  user: {\n    id: string;\n    firstname: string;\n    lastname: string;\n    email: string;\n  };\n  reportedUser: {\n    id: string;\n    firstname: string;\n    lastname: string;\n    email: string;\n  };\n  customMessage?: string | undefined;\n};\n\nfunction internalToPaymentInfos(p: InternalPaymentInfos): PaymentInfos {\n  return {\n    ...p,\n    currentSubscription: {\n      ...p.currentSubscription,\n      state: p.currentSubscription.state as SubscriptionState,\n      collectionMethod: p.currentSubscription\n        .collectionMethod as SubscriptionCollectionMethod\n    },\n    invoices: p.invoices.map(i => ({\n      ...i,\n      status: i.status as RecurlyInvoiceStatus\n    }))\n  };\n}\n\nconst plansCodes = [\n  \"basic_month\",\n  \"advanced_month\",\n  \"pro_month\",\n  \"basic_year\",\n  \"advanced_year\",\n  \"pro_year\"\n] as const;\n\nexport type SecrecyPlansCodes = typeof plansCodes[number];\n\nexport function isValidPlan(planCode: string): planCode is SecrecyPlansCodes {\n  return plansCodes.includes(planCode as SecrecyPlansCodes);\n}\n\nexport type UserData<\n  T extends Record<string, unknown> = Record<string, unknown>\n> = {\n  isSuperuser: boolean;\n  isSearchable: boolean;\n} & T;\n\nexport type FolderSize = { size: bigint; sizeBefore: bigint };\n\nconst getUserSelector = (\n  userId: string | null | undefined,\n  withPublicKey: boolean | undefined\n) => {\n  const { user } = Selector(\"Query\")({\n    user: [\n      { userId },\n      {\n        \"...on ErrorNotFound\": {\n          __typename: true,\n          message: true,\n          field: true\n        },\n        \"...on UserResponse\": {\n          __typename: true,\n          user: {\n            id: true,\n            firstname: true,\n            lastname: true,\n            lang: true,\n            publicKey: withPublicKey ? true : undefined,\n            email: true,\n            phone: true,\n            role: true,\n            deletedAt: true,\n            lastLogin: true\n          }\n        }\n      }\n    ]\n  });\n  return user;\n};\n\nexport type AppDBConfigField = {\n  name: string;\n  type: \"string\" | \"number\" | \"boolean\" | \"object\";\n  isArray?: boolean | undefined;\n  isNullable?: boolean | undefined;\n  isEditable?: boolean | undefined;\n  isKey?: boolean | undefined;\n  default?: unknown;\n};\n\nexport type AppDBConfig = {\n  fields: AppDBConfigField[];\n};\n\nexport type FaqItem = {\n  order: number;\n  question: string;\n  answer: string;\n};\n\nexport type BlogItem = {\n  id: string;\n  blogId: string;\n  order: number;\n  author: string;\n  body: string;\n  date: Date;\n  image: string;\n  imageAlt: string;\n  summary: string;\n  title: string;\n};\n\nexport type UserBase = {\n  email: string;\n  phone: string;\n  lastname: string;\n  role: UserRole;\n  firstname: string;\n  id: string;\n  deletedAt?: Date;\n  lastLogin: Date;\n  lang: Lang;\n};\n\ntype WithPublicKey = { withPublicKey?: boolean };\n\nexport type User<T extends WithPublicKey = WithPublicKey> = T extends {\n  withPublicKey: true;\n}\n  ? UserBase & { publicKey: string }\n  : UserBase;\n\ntype ClassGetUserParams = WithPublicKey & {\n  userId?: string;\n  userEmail?: string;\n};\ntype GetUserParams = ClassGetUserParams & {\n  client: ReturnType<typeof Thunder>;\n};\n\ntype StaticGetUserParams = ClassGetUserParams & {\n  env: SecrecyEnv;\n};\n\nasync function getUser<U extends WithPublicKey>(\n  params: GetUserParams\n): Promise<SuccessResponse<User<U>> | ErrorNotFound | null> {\n  const selector = getUserSelector(\n    params.userId ?? params.userEmail,\n    params.withPublicKey\n  );\n  const { user: userResponse } = await params.client(\"query\", {\n    scalars: {\n      Json: {\n        encode: (e: unknown) => JSON.stringify(e),\n        decode: (e: unknown) => JSON.parse(e as string)\n      },\n      DateTime: {\n        decode: (e: unknown) => new Date(e as string),\n        encode: (e: unknown) => (e as Date).toISOString()\n      },\n      BigInt: {\n        decode: (e: unknown) => BigInt(e as string),\n        encode: (e: unknown) => (e as bigint).toString()\n      }\n    }\n  })({\n    user: selector\n  });\n\n  if (!userResponse) {\n    return null;\n  }\n\n  if (userResponse.__typename === \"ErrorNotFound\") {\n    return userResponse;\n  }\n\n  if (!userResponse.user) {\n    return null;\n  }\n\n  return {\n    __typename: \"SuccessResponse\",\n    data: userResponse.user\n  };\n}\n\nexport type CloudLimits = {\n  count: bigint;\n  maxCount?: bigint | undefined;\n  size: bigint;\n  maxSize?: bigint | undefined;\n};\n\nexport type MailLimitsValues = {\n  count: bigint;\n  maxCount?: bigint | undefined;\n  fileSize: bigint;\n  maxFileSize?: bigint | undefined;\n  fileCount: bigint;\n  maxFileCount?: bigint | undefined;\n};\n\nexport type QueryLimits = {\n  cloud: CloudLimits;\n  mail: {\n    sent: MailLimitsValues;\n    received: MailLimitsValues;\n  };\n};\n\nexport class BaseClient {\n  public static readonly getBaseUrl = (\n    env: SecrecyEnv = \"prod\",\n    graphcdn = true\n  ): string => {\n    const apiUrl = process.env.NEXT_PUBLIC_SECRECY_API_URL;\n    if (apiUrl) {\n      return apiUrl;\n    }\n\n    switch (env) {\n      case \"prod\":\n        return graphcdn\n          ? \"https://secrecy.graphcdn.app\"\n          : \"https://api.secrecy.me/graphql\";\n      case \"dev\":\n      default:\n        return \"https://api.dev.secrecy.me/graphql\";\n    }\n  };\n\n  private static readonly _getBaseClient = (\n    env: SecrecyEnv,\n    session?: string | null | undefined\n  ): ReturnType<typeof Thunder> =>\n    createThunder(BaseClient.getBaseUrl(env), session);\n\n  protected client: ReturnType<typeof Thunder>;\n\n  public sessionId: string;\n\n  constructor(session: string, env: SecrecyEnv) {\n    this.sessionId = session;\n    this.client = BaseClient._getBaseClient(env, session);\n  }\n\n  async sessions(): Promise<\n    SuccessResponse<UserSession[]> | ErrorNotFound | null\n  > {\n    const data = await this.client(\"query\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            field: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            user: {\n              sessions: {\n                id: true,\n                lastActivity: true,\n                userAgent: true,\n                ip: true,\n                city: true,\n                country: true,\n                appSessions: {\n                  id: true,\n                  lastActivity: true,\n                  userAgent: true,\n                  ip: true,\n                  city: true,\n                  country: true,\n                  userApp: {\n                    app: {\n                      name: true\n                    }\n                  }\n                }\n              }\n            }\n          }\n        }\n      ]\n    });\n\n    if (!data.user) {\n      return null;\n    }\n    const userResponse = data.user;\n    if (userResponse.__typename === \"UserResponse\") {\n      if (!userResponse.user) {\n        return null;\n      }\n      const sessions: UserSession[] =\n        userResponse.user.sessions.map(s => ({\n          id: s.id,\n          ip: s.ip,\n          city: s.city,\n          country: s.country,\n          lastActivity: s.lastActivity ? new Date(s.lastActivity) : undefined,\n          userAgent: s.userAgent,\n          appSessions: s.appSessions.map(a => ({\n            id: a.id,\n            ip: a.ip,\n            city: a.city,\n            country: a.country,\n            lastActivity: a.lastActivity ? new Date(a.lastActivity) : undefined,\n            userAgent: a.userAgent,\n            app: a.userApp?.app.name ?? \"\"\n          }))\n        })) ?? [];\n      return {\n        __typename: \"SuccessResponse\",\n        data: sessions\n      };\n    }\n\n    return userResponse;\n  }\n\n  async logout(sessionId?: string | null | undefined): Promise<void> {\n    if (!sessionId) {\n      const local = getStorage(false);\n      const session = getStorage(true);\n      local.jwt.clear();\n      local.userAppKeys.clear();\n      local.userAppSession.clear();\n      session.jwt.clear();\n      session.userAppKeys.clear();\n      session.userAppSession.clear();\n      usersCache.clear();\n    }\n    try {\n      await this.client(\"mutation\")({\n        logout: [\n          {\n            sessionId: sessionId\n          },\n          {\n            \"...on ErrorAccessDenied\": {\n              __typename: true,\n              message: true\n            },\n            \"...on ErrorBasic\": {\n              __typename: true,\n              message: true\n            },\n            \"...on LogoutResponse\": {\n              __typename: true,\n              logout: true\n            }\n          }\n        ]\n      });\n    } catch {\n      //\n    }\n  }\n\n  async me<T extends WithPublicKey = WithPublicKey>(\n    params?: T\n  ): Promise<SuccessResponse<User<T>> | ErrorNotFound | null> {\n    return this.user(params || ({ withPublicKey: true } as T));\n  }\n\n  static async user<T extends StaticGetUserParams>(\n    params: T,\n    sessionId?: string | null | undefined\n  ): Promise<SuccessResponse<User<T>> | ErrorNotFound | null> {\n    const user = await getUser<T>({\n      client: this._getBaseClient(params.env, sessionId),\n      userId: params.userId ?? params.userEmail,\n      withPublicKey: params.withPublicKey\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (user) {\n      usersCache.set(user.data.id, user.data);\n    }\n\n    return user;\n  }\n\n  async user<T extends ClassGetUserParams>(\n    params: T\n  ): Promise<SuccessResponse<User<T>> | ErrorNotFound | null> {\n    const user = await getUser<T>({\n      client: this.client,\n      userId: params.userId ?? params.userEmail,\n      withPublicKey: params.withPublicKey\n    });\n\n    if (!user) {\n      return null;\n    }\n\n    if (user.__typename === \"ErrorNotFound\") {\n      return user;\n    }\n\n    if (user) {\n      usersCache.set(user.data.id, user.data);\n    }\n\n    return user;\n  }\n\n  async updateProfile({\n    firstname,\n    lastname,\n    lang\n  }: {\n    firstname: string | null;\n    lastname: string | null;\n    lang: Lang | null;\n  }): Promise<\n    SuccessResponse<User> | ErrorNotFound | ErrorAccessDenied | null\n  > {\n    const { updateProfile } = await this.client(\"mutation\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      updateProfile: [\n        {\n          firstname,\n          lastname,\n          lang\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UpdateProfileResponse\": {\n            __typename: true,\n            updateProfile: {\n              id: true,\n              firstname: true,\n              lastname: true,\n              lang: true,\n              email: true,\n              phone: true,\n              role: true,\n              deletedAt: true,\n              lastLogin: true\n            }\n          }\n        }\n      ]\n    });\n\n    if (!updateProfile) {\n      return null;\n    }\n\n    if (updateProfile.__typename === \"ErrorAccessDenied\") {\n      return updateProfile;\n    }\n\n    if (updateProfile.__typename === \"ErrorNotFound\") {\n      return updateProfile;\n    }\n\n    if (!updateProfile.updateProfile) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: updateProfile.updateProfile\n    };\n  }\n\n  static async plans(\n    env: SecrecyEnv,\n    sessionId?: string | null | undefined\n  ): Promise<SuccessResponse<Plan[]> | null> {\n    const { plans } = await BaseClient._getBaseClient(env, sessionId)(\"query\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      plans: {\n        \"...on PlanResponse\": {\n          __typename: true,\n          plan: {\n            kind: true,\n            codes: true,\n            limits: {\n              downloadBandwidth: true,\n              downloadCount: true,\n              hardFileCount: true,\n              hardFileSize: true,\n              perFileSize: true,\n              uploadBandwidth: true,\n              uploadCount: true,\n              receivedMails: {\n                count: true,\n                fileCount: true,\n                fileSize: true,\n                hardCount: true,\n                hardFileCount: true,\n                hardFileSize: true,\n                perFileSize: true\n              },\n              sentMails: {\n                count: true,\n                fileCount: true,\n                fileSize: true,\n                hardCount: true,\n                hardFileCount: true,\n                hardFileSize: true,\n                perFileSize: true\n              }\n            }\n          }\n        }\n      }\n    });\n\n    if (!plans) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: plans.plan\n    };\n  }\n\n  async pay(\n    planCode: SecrecyPlansCodes,\n    input: PayInput,\n    autoRenew?: boolean | null | undefined\n  ): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null> {\n    const { pay } = await this.client(\"mutation\")({\n      pay: [\n        {\n          input,\n          planCode,\n          autoRenew\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on PayResponse\": {\n            __typename: true,\n            pay: true\n          }\n        }\n      ]\n    });\n\n    if (!pay) {\n      return null;\n    }\n\n    if (pay.__typename === \"ErrorAccessDenied\") {\n      return pay;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: pay.pay ?? false\n    };\n  }\n\n  async cancelPayment(): Promise<\n    SuccessResponse<boolean> | ErrorAccessDenied | null\n  > {\n    const { cancelPayment } = await this.client(\"mutation\")({\n      cancelPayment: {\n        \"...on ErrorAccessDenied\": {\n          __typename: true,\n          message: true\n        },\n        \"...on CancelPaymentResponse\": {\n          __typename: true,\n          cancelPayment: true\n        }\n      }\n    });\n\n    if (!cancelPayment) {\n      return null;\n    }\n\n    if (cancelPayment.__typename === \"ErrorAccessDenied\") {\n      return cancelPayment;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: cancelPayment.cancelPayment ?? false\n    };\n  }\n\n  async paymentInfos(): Promise<\n    SuccessResponse<PaymentInfos> | ErrorAccessDenied | null\n  > {\n    const { paymentInfos } = await this.client(\"query\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      paymentInfos: {\n        \"...on ErrorAccessDenied\": {\n          __typename: true,\n          message: true\n        },\n        \"...on PaymentInfosResponse\": {\n          __typename: true,\n          paymentInfos: {\n            hostedUrl: true,\n            currentSubscription: {\n              autorenew: true,\n              activatedAt: true,\n              currentPeriodEndsAt: true,\n              currentPeriodStartedAt: true,\n              canceledAt: true,\n              createdAt: true,\n              expiresAt: true,\n              pausedAt: true,\n              trialEndsAt: true,\n              trialStartedAt: true,\n              updatedAt: true,\n              state: true,\n              collectionMethod: true,\n              plan: true,\n              planCode: true,\n              total: true\n            },\n            invoices: {\n              pdf: true,\n              date: true,\n              due: true,\n              status: true,\n              total: true,\n              name: true,\n              currency: true\n            }\n          }\n        }\n      }\n    });\n\n    if (!paymentInfos) {\n      return null;\n    }\n\n    if (paymentInfos.__typename === \"ErrorAccessDenied\") {\n      return paymentInfos;\n    }\n\n    if (!paymentInfos.paymentInfos) {\n      return null;\n    }\n    const result = internalToPaymentInfos(paymentInfos.paymentInfos);\n    return {\n      __typename: \"SuccessResponse\",\n      data: result\n    };\n  }\n\n  async limits(): Promise<\n    | SuccessResponse<QueryLimits>\n    | ErrorAccessDenied\n    | ErrorNotExist\n    | ErrorLimit\n    | ErrorNotFound\n    | null\n  > {\n    const { limits } = await this.client(\"query\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      limits: {\n        \"...on ErrorAccessDenied\": {\n          __typename: true,\n          message: true\n        },\n        \"...on ErrorLimit\": {\n          __typename: true,\n          message: true\n        },\n        \"...on ErrorNotExist\": {\n          __typename: true,\n          message: true\n        },\n        \"...on ErrorNotFound\": {\n          __typename: true,\n          message: true\n        },\n        \"...on QueryLimits\": {\n          __typename: true,\n          cloud: {\n            size: true,\n            maxSize: true,\n            count: true,\n            maxCount: true\n          },\n          mail: {\n            received: {\n              count: true,\n              maxCount: true,\n              fileCount: true,\n              maxFileCount: true,\n              fileSize: true,\n              maxFileSize: true\n            },\n            sent: {\n              count: true,\n              maxCount: true,\n              fileCount: true,\n              maxFileCount: true,\n              fileSize: true,\n              maxFileSize: true\n            }\n          }\n        }\n      }\n    });\n\n    if (!limits) {\n      return null;\n    }\n\n    if (limits.__typename === \"ErrorAccessDenied\") {\n      return limits;\n    }\n    if (limits.__typename === \"ErrorNotExist\") {\n      return limits;\n    }\n    if (limits.__typename === \"ErrorLimit\") {\n      return limits;\n    }\n    if (limits.__typename === \"ErrorNotFound\") {\n      return limits;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: limits\n    };\n  }\n\n  async godFatherAndChildren(): Promise<\n    SuccessResponse<GodFatherAndChildren> | ErrorNotFound | null\n  > {\n    const { user } = await this.client(\"query\")({\n      user: [\n        {},\n        {\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UserResponse\": {\n            __typename: true,\n            godChildren: {\n              id: true,\n              firstname: true,\n              lastname: true,\n              email: true,\n              phone: true\n            },\n            godFather: {\n              id: true,\n              firstname: true,\n              lastname: true,\n              email: true,\n              phone: true\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    return {\n      __typename: \"SuccessResponse\",\n      data: {\n        godChildren: user.godChildren,\n        godFather: user.godFather\n      }\n    };\n  }\n\n  static async updateAppDBConfig({\n    appCode,\n    config,\n    env,\n    sessionId\n  }: {\n    appCode: string;\n    config: AppDBConfig;\n    env: SecrecyEnv;\n    sessionId?: string | null | undefined;\n  }): Promise<SuccessResponse<AppDBConfig> | ErrorAccessDenied | null> {\n    const { dbConfigMutation } = await BaseClient._getBaseClient(\n      env,\n      sessionId\n    )(\"mutation\")({\n      dbConfigMutation: [\n        {\n          appCode,\n          config: JSON.stringify(config)\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DbConfigMutationResponse\": {\n            __typename: true,\n            dbConfigMutation: true\n          }\n        }\n      ]\n    });\n\n    if (!dbConfigMutation) {\n      return null;\n    }\n\n    if (dbConfigMutation.__typename === \"ErrorAccessDenied\") {\n      return dbConfigMutation;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: dbConfigMutation.dbConfigMutation as AppDBConfig\n    };\n  }\n\n  static async getAppDBConfig(\n    appCode: string,\n    env: SecrecyEnv,\n    sessionId?: string | null | undefined\n  ): Promise<\n    | SuccessResponse<AppDBConfig>\n    | ErrorAccessDenied\n    | ErrorNotFound\n    | ErrorNotExist\n    | null\n  > {\n    const { dbConfig } = await BaseClient._getBaseClient(\n      env,\n      sessionId\n    )(\"query\")({\n      dbConfig: [\n        {\n          appCode\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotExist\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DbConfigResponse\": {\n            __typename: true,\n            json: true\n          }\n        }\n      ]\n    });\n\n    if (!dbConfig) {\n      return null;\n    }\n\n    if (dbConfig.__typename === \"ErrorAccessDenied\") {\n      return dbConfig;\n    }\n\n    if (dbConfig.__typename === \"ErrorNotFound\") {\n      return dbConfig;\n    }\n\n    if (dbConfig.__typename === \"ErrorNotExist\") {\n      return dbConfig;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: dbConfig.json as AppDBConfig\n    };\n  }\n\n  static async getFAQ({\n    lang,\n    env,\n    sessionId\n  }: {\n    lang?: Lang;\n    env: SecrecyEnv;\n    sessionId?: string | null | undefined;\n  }): Promise<SuccessResponse<FaqItem[]> | ErrorAccessDenied | null> {\n    const { faq } = await BaseClient._getBaseClient(env, sessionId)(\"query\")({\n      faq: [\n        {\n          lang\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on FaqResponse\": {\n            __typename: true,\n            faq: {\n              answer: true,\n              order: true,\n              question: true\n            }\n          }\n        }\n      ]\n    });\n\n    if (!faq) {\n      return null;\n    }\n\n    if (faq.__typename === \"ErrorAccessDenied\") {\n      return faq;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: faq.faq\n    };\n  }\n\n  static async getBlog({\n    env,\n    lang,\n    sessionId\n  }: {\n    env: SecrecyEnv;\n    lang?: Lang | null | undefined;\n    sessionId?: string | null | undefined;\n  }): Promise<SuccessResponse<BlogItem[]> | ErrorLangNotExist | null> {\n    const { blog } = await BaseClient._getBaseClient(env, sessionId)(\"query\", {\n      scalars: {\n        Json: {\n          encode: (e: unknown) => JSON.stringify(e),\n          decode: (e: unknown) => JSON.parse(e as string)\n        },\n        DateTime: {\n          decode: (e: unknown) => new Date(e as string),\n          encode: (e: unknown) => (e as Date).toISOString()\n        },\n        BigInt: {\n          decode: (e: unknown) => BigInt(e as string),\n          encode: (e: unknown) => (e as bigint).toString()\n        }\n      }\n    })({\n      blog: [\n        {\n          lang\n        },\n        {\n          \"...on ErrorLangNotExist\": {\n            __typename: true,\n            message: true\n          },\n          \"...on BlogResponse\": {\n            __typename: true,\n            blogItems: {\n              id: true,\n              blogId: true,\n              author: true,\n              body: true,\n              date: true,\n              image: true,\n              imageAlt: true,\n              summary: true,\n              title: true,\n              order: true\n            }\n          }\n        }\n      ]\n    });\n\n    if (!blog) {\n      return null;\n    }\n\n    if (blog.__typename === \"ErrorLangNotExist\") {\n      return blog;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: blog.blogItems\n    };\n  }\n\n  async reportUser(\n    reportedUserId: string,\n    customMessage?: string\n  ): Promise<\n    SuccessResponse<SendReport> | ErrorAccessDenied | ErrorNotFound | null\n  > {\n    const { sendReport } = await this.client(\"mutation\")({\n      sendReport: [\n        {\n          reportedUserId,\n          customMessage\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on SendReportResponse\": {\n            __typename: true,\n            sendReport: {\n              id: true,\n              customMessage: true,\n              user: {\n                id: true,\n                firstname: true,\n                lastname: true,\n                email: true\n              },\n              reportedUser: {\n                id: true,\n                firstname: true,\n                lastname: true,\n                email: true\n              }\n            }\n          }\n        }\n      ]\n    });\n\n    if (!sendReport) {\n      return null;\n    }\n\n    if (sendReport.__typename === \"ErrorAccessDenied\") {\n      return sendReport;\n    }\n\n    if (sendReport.__typename === \"ErrorNotFound\") {\n      return sendReport;\n    }\n\n    if (!sendReport.sendReport) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: sendReport.sendReport\n    };\n  }\n\n  static async deleteUser({\n    sessionId,\n    userId,\n    env\n  }: {\n    sessionId: string;\n    userId?: string;\n    env: SecrecyEnv;\n  }): Promise<SuccessResponse<boolean> | ErrorAccessDenied | null> {\n    const { deleteUser } = await BaseClient._getBaseClient(\n      env,\n      sessionId\n    )(\"mutation\")({\n      deleteUser: [\n        {\n          userId\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on DeleteUserResponse\": {\n            __typename: true,\n            deleteUser: true\n          }\n        }\n      ]\n    });\n\n    if (!deleteUser) {\n      return null;\n    }\n\n    if (deleteUser.__typename === \"ErrorAccessDenied\") {\n      return deleteUser;\n    }\n\n    if (!deleteUser.deleteUser) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: deleteUser.deleteUser\n    };\n  }\n\n  async getSponsorshipLink({\n    backUrl\n  }: {\n    backUrl: string;\n  }): Promise<string | null> {\n    const me = await this.me({ withPublicKey: false });\n\n    if (!me) {\n      return null;\n    }\n\n    if (me.__typename === \"ErrorNotFound\") {\n      return null;\n    }\n\n    return getLink({\n      app: \"auth\",\n      path: `/sign-up?gf=${btoa(me.data.email)}&au=${btoa(backUrl)}`\n    });\n  }\n\n  async updateAutoDisconnectDelay({\n    id,\n    delay\n  }: {\n    id: string;\n    delay: number | null;\n  }): Promise<\n    | SuccessResponse<boolean>\n    | ErrorNotFound\n    | ErrorAccessDenied\n    | ErrorBasic\n    | null\n  > {\n    const { updateAutoDisconnectDelay } = await this.client(\"mutation\")({\n      updateAutoDisconnectDelay: [\n        {\n          userId: id,\n          delay: delay ?? null\n        },\n        {\n          \"...on ErrorAccessDenied\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorNotFound\": {\n            __typename: true,\n            message: true\n          },\n          \"...on ErrorBasic\": {\n            __typename: true,\n            message: true\n          },\n          \"...on UpdateAutoDisconnectDelayResponse\": {\n            __typename: true,\n            updateAutoDisconnectDelay: true\n          }\n        }\n      ]\n    });\n\n    if (!updateAutoDisconnectDelay) {\n      return null;\n    }\n\n    if (updateAutoDisconnectDelay.__typename === \"ErrorAccessDenied\") {\n      return updateAutoDisconnectDelay;\n    }\n\n    if (updateAutoDisconnectDelay.__typename === \"ErrorBasic\") {\n      return updateAutoDisconnectDelay;\n    }\n\n    if (updateAutoDisconnectDelay.__typename === \"ErrorNotFound\") {\n      return updateAutoDisconnectDelay;\n    }\n\n    if (!updateAutoDisconnectDelay.updateAutoDisconnectDelay) {\n      return null;\n    }\n\n    return {\n      __typename: \"SuccessResponse\",\n      data: updateAutoDisconnectDelay.updateAutoDisconnectDelay\n    };\n  }\n}\n"],"mappings":"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"}