@unchainedshop/admin-ui 4.8.18 → 4.8.20

package/dist/modules/accounts.js

@@ -0,0 +1,1013 @@
+import { useConfirmMediaUpload_default, PUTMedia_default } from '../chunk-45H2WVIC.js';
+import { UserFragment_default, MD5MetaDataFragment_default } from '../chunk-UFYR5WZT.js';
+export { useCurrentUser_default as useCurrentUser } from '../chunk-UFYR5WZT.js';
+import { useUnchainedContext_default } from '../chunk-IAQPLRXZ.js';
+import '../chunk-4VNS5WPM.js';
+import { gql } from '@apollo/client';
+import { useMutation, useQuery } from '@apollo/client/react';
+
+var logOut = async (apollo, router = null) => {
+  await apollo.mutate({
+    mutation: gql`
+      mutation Logout {
+        logout {
+          success
+        }
+      }
+    `
+  });
+  try {
+    await apollo.resetStore();
+  } catch (e) {
+    if (e?.name !== "AbortError") throw e;
+  }
+  if (router) {
+    router.push("/log-in");
+  } else if (typeof window !== "undefined") {
+    window.location.href = "/log-in";
+  }
+};
+var logOut_default = logOut;
+var AddEmailMutation = gql`
+  mutation AddEmail($email: String!, $userId: ID) {
+    addEmail(email: $email, userId: $userId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useAddEmail = () => {
+  const [addEmailMutation] = useMutation(AddEmailMutation);
+  const addEmail = async ({ email, userId }) => {
+    return addEmailMutation({
+      variables: { email, userId }
+    });
+  };
+  return {
+    addEmail
+  };
+};
+var useAddEmail_default = useAddEmail;
+var AddWeb3AddressMutation = gql`
+  mutation AddWeb3Address($address: String!) {
+    addWeb3Address(address: $address) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useAddWeb3Address = () => {
+  const [addWeb3AddressMutation] = useMutation(AddWeb3AddressMutation);
+  const addWeb3Address = async ({
+    address
+  }) => {
+    return addWeb3AddressMutation({
+      variables: {
+        address
+      }
+    });
+  };
+  return {
+    addWeb3Address
+  };
+};
+var useAddWeb3Address_default = useAddWeb3Address;
+var AddWebAuthnCredentialsMutation = gql`
+  mutation AddWebAuthnCredentials($credentials: JSON!) {
+    addWebAuthnCredentials(credentials: $credentials) {
+      ...UserFragment
+      webAuthnCredentials {
+        _id
+        created
+        aaguid
+        counter
+        mdsMetadata {
+          ...MD5MetaDataFragment
+        }
+      }
+    }
+  }
+  ${UserFragment_default}
+  ${MD5MetaDataFragment_default}
+`;
+var useAddWebAuthnCredentials = () => {
+  const [addWebAuthnCredentialsMutation] = useMutation(AddWebAuthnCredentialsMutation);
+  const addWebAuthnCredentials = async ({
+    credentials
+  }) => {
+    return addWebAuthnCredentialsMutation({
+      variables: { credentials }
+    });
+  };
+  return {
+    addWebAuthnCredentials
+  };
+};
+var useAddWebAuthnCredentials_default = useAddWebAuthnCredentials;
+var ChangePasswordMutation = gql`
+  mutation ChangePassword($oldPassword: String!, $newPassword: String!) {
+    changePassword(oldPassword: $oldPassword, newPassword: $newPassword) {
+      success
+    }
+  }
+`;
+var useChangePassword = () => {
+  const [changePasswordMutation] = useMutation(ChangePasswordMutation);
+  const changePassword = async ({
+    oldPassword = void 0,
+    newPassword = void 0
+  }) => {
+    return changePasswordMutation({
+      variables: { oldPassword, newPassword }
+    });
+  };
+  return {
+    changePassword
+  };
+};
+var useChangePassword_default = useChangePassword;
+var CreateUserMutation = gql`
+  mutation CreateUser(
+    $username: String
+    $email: String
+    $plainPassword: String
+    $profile: UserProfileInput
+    $webAuthnPublicKeyCredentials: JSON
+  ) {
+    createUser(
+      username: $username
+      email: $email
+      password: $plainPassword
+      profile: $profile
+      webAuthnPublicKeyCredentials: $webAuthnPublicKeyCredentials
+    ) {
+      _id
+      tokenExpires
+    }
+  }
+`;
+var useCreateUser = () => {
+  const [createUserMutation, { data, error, loading, client }] = useMutation(CreateUserMutation);
+  const createUser = async ({
+    username,
+    email,
+    plainPassword,
+    profile,
+    webAuthnPublicKeyCredentials
+  }) => {
+    const variables = {
+      username: null,
+      email: null,
+      profile,
+      plainPassword: null,
+      webAuthnPublicKeyCredentials
+    };
+    if (email) {
+      variables.email = email;
+    }
+    if (username) {
+      variables.username = username;
+    }
+    variables.plainPassword = plainPassword;
+    const result = await createUserMutation({
+      variables,
+      refetchQueries: ["Users", "ShopStatus", "ShopInfo"]
+    });
+    await client.resetStore();
+    return result;
+  };
+  const newUser = data?.createUser;
+  return {
+    createUser,
+    newUser,
+    error,
+    loading
+  };
+};
+var useCreateUser_default = useCreateUser;
+var CreateWebAuthnCredentialCreationOptionsMutation = gql`
+  mutation CreateWebAuthnCredentialCreationOptions($username: String!) {
+    createWebAuthnCredentialCreationOptions(username: $username)
+  }
+`;
+var useCreateWebAuthnCredentialCreationOptions = () => {
+  const [createWebAuthnCredentialCreationOptionsMutation] = useMutation(CreateWebAuthnCredentialCreationOptionsMutation);
+  const createWebAuthnCredentialCreationOptions = async ({
+    username
+  }) => {
+    return createWebAuthnCredentialCreationOptionsMutation({
+      variables: { username }
+    });
+  };
+  return { createWebAuthnCredentialCreationOptions };
+};
+var useCreateWebAuthnCredentialCreationOptions_default = useCreateWebAuthnCredentialCreationOptions;
+var CreateWebAuthnCredentialRequestOptionsMutation = gql`
+  mutation CreateWebAuthnCredentialRequestOptions($username: String) {
+    createWebAuthnCredentialRequestOptions(username: $username)
+  }
+`;
+var useCreateWebAuthnCredentialRequestOptions = () => {
+  const [createWebAuthnCredentialRequestOptionsMutation] = useMutation(CreateWebAuthnCredentialRequestOptionsMutation);
+  const createWebAuthnCredentialRequestOptions = async ({
+    username
+  }) => {
+    return createWebAuthnCredentialRequestOptionsMutation({
+      variables: { username }
+    });
+  };
+  return { createWebAuthnCredentialRequestOptions };
+};
+var useCreateWebAuthnCredentialRequestOptions_default = useCreateWebAuthnCredentialRequestOptions;
+var DeleteUserMutation = gql`
+  mutation DeleteUser($userId: ID) {
+    removeUser(userId: $userId) {
+      _id
+    }
+  }
+`;
+var useDeleteUser = () => {
+  const [deleteUserMutation] = useMutation(DeleteUserMutation);
+  const deleteUser = async (userId = void 0) => {
+    return deleteUserMutation({
+      variables: {
+        userId
+      }
+    });
+  };
+  return {
+    deleteUser
+  };
+};
+var useDeleteUser_default = useDeleteUser;
+var ForgotPasswordMutation = gql`
+  mutation ForgotPassword($email: String!) {
+    forgotPassword(email: $email) {
+      success
+    }
+  }
+`;
+var useForgotPassword = () => {
+  const [forgotPasswordMutation] = useMutation(ForgotPasswordMutation);
+  const forgotPassword = async ({
+    email
+  }) => {
+    return forgotPasswordMutation({
+      variables: { email }
+    });
+  };
+  return {
+    forgotPassword
+  };
+};
+var useForgotPassword_default = useForgotPassword;
+
+// src/modules/common/utils/base64ToArrayBuffer.ts
+var base64ToArrayBuffer = (b64) => {
+  if (window.atob && Uint8Array) {
+    const base64 = b64.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const binaryString = window.atob(padded);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i += 1) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+  throw new Error("The atob and Uint8Array methods are not available");
+};
+var base64ToArrayBuffer_default = base64ToArrayBuffer;
+
+// src/modules/accounts/hooks/useGenerateLoginCredentials.ts
+var arrayBufferToBase64url = (buffer) => {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+  const base64 = window.btoa(String.fromCharCode(...bytes));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var useGenerateLoginCredentials = () => {
+  const { createWebAuthnCredentialRequestOptions } = useCreateWebAuthnCredentialRequestOptions_default();
+  const generateLoginCredentials = async ({ username }) => {
+    const { data } = await createWebAuthnCredentialRequestOptions({
+      username
+    });
+    const publicKey = data?.createWebAuthnCredentialRequestOptions;
+    if (!publicKey?.allowCredentials?.length) return null;
+    publicKey.challenge = base64ToArrayBuffer_default(publicKey.challenge);
+    publicKey.allowCredentials = publicKey.allowCredentials?.map(({ id: id2, ...rest }) => ({
+      id: base64ToArrayBuffer_default(id2),
+      ...rest
+    })) || [];
+    const PublicKeyCredentials = await navigator.credentials.get({
+      publicKey
+    });
+    const authenticatorData = arrayBufferToBase64url(
+      PublicKeyCredentials.response.authenticatorData
+    );
+    const signature = arrayBufferToBase64url(
+      PublicKeyCredentials.response.signature
+    );
+    const userHandle = PublicKeyCredentials.response.userHandle ? arrayBufferToBase64url(PublicKeyCredentials.response.userHandle) : arrayBufferToBase64url(new TextEncoder().encode(username));
+    const clientDataJSON = arrayBufferToBase64url(
+      PublicKeyCredentials.response.clientDataJSON
+    );
+    const id = arrayBufferToBase64url(PublicKeyCredentials.rawId);
+    return {
+      requestId: publicKey.requestId,
+      id,
+      response: {
+        clientDataJSON,
+        authenticatorData,
+        signature,
+        userHandle
+      }
+    };
+  };
+  return { generateLoginCredentials };
+};
+var useGenerateLoginCredentials_default = useGenerateLoginCredentials;
+
+// src/modules/accounts/hooks/useGenerateWebAuthCredentials.ts
+var arrayBufferToBase64url2 = (buffer) => {
+  const base64 = window.btoa(String.fromCharCode(...new Uint8Array(buffer)));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+};
+var useGenerateWebAuthCredentials = () => {
+  const { createWebAuthnCredentialCreationOptions } = useCreateWebAuthnCredentialCreationOptions_default();
+  const generateWebAuthCredentials = async ({ username }) => {
+    const { data } = await createWebAuthnCredentialCreationOptions({
+      username
+    });
+    const { createWebAuthnCredentialCreationOptions: publicKey } = data;
+    const textEncoder = new TextEncoder();
+    publicKey.challenge = base64ToArrayBuffer_default(publicKey.challenge);
+    publicKey.user = {
+      id: textEncoder.encode(username),
+      name: username,
+      displayName: username
+    };
+    const publicKeyCredentials = await navigator.credentials.create({
+      publicKey
+    });
+    const attestationObject = arrayBufferToBase64url2(
+      publicKeyCredentials.response.attestationObject
+    );
+    const clientDataJSON = arrayBufferToBase64url2(
+      publicKeyCredentials.response.clientDataJSON
+    );
+    const rawId = arrayBufferToBase64url2(publicKeyCredentials.rawId);
+    const authenticatorData = publicKeyCredentials.response.getAuthenticatorData ? arrayBufferToBase64url2(
+      publicKeyCredentials.response.getAuthenticatorData()
+    ) : "";
+    const responsePublicKey = publicKeyCredentials.response.getPublicKey ? arrayBufferToBase64url2(publicKeyCredentials.response.getPublicKey()) : "";
+    const publicKeyAlgorithm = publicKeyCredentials.response.getPublicKeyAlgorithm ? publicKeyCredentials.response.getPublicKeyAlgorithm() : -7;
+    const transports = publicKeyCredentials.response.getTransports ? publicKeyCredentials.response.getTransports() : ["internal"];
+    return {
+      id: rawId,
+      rawId,
+      response: {
+        clientDataJSON,
+        attestationObject,
+        authenticatorData,
+        publicKey: responsePublicKey,
+        publicKeyAlgorithm,
+        transports
+      },
+      authenticatorAttachment: publicKeyCredentials.authenticatorAttachment || "platform",
+      clientExtensionResults: publicKeyCredentials.getClientExtensionResults?.() || {},
+      type: "public-key",
+      user: {
+        id: username,
+        name: username,
+        displayName: username
+      }
+    };
+  };
+  return { generateWebAuthCredentials };
+};
+var useGenerateWebAuthCredentials_default = useGenerateWebAuthCredentials;
+
+// src/modules/common/utils/isEmail.ts
+var regexExp = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z]{2,})+$/i;
+var isEmail = (str) => typeof str === "string" && regexExp.test(str.trim());
+var isEmail_default = isEmail;
+
+// src/modules/accounts/hooks/useLoginWithPassword.ts
+var LogInWithPasswordMutation = gql`
+  mutation LoginWithPassword(
+    $username: String
+    $email: String
+    $password: String!
+  ) {
+    loginWithPassword(username: $username, email: $email, password: $password) {
+      _id
+      tokenExpires
+      user {
+        _id
+        allowedActions
+        roles
+      }
+    }
+  }
+`;
+var useLoginWithPassword = () => {
+  const [logInWithPasswordMutation, { client }] = useMutation(LogInWithPasswordMutation, {
+    errorPolicy: "all"
+  });
+  const logInWithPassword = async ({ usernameOrEmail, password }) => {
+    const variables = {
+      username: null,
+      email: null,
+      password: null
+    };
+    if (isEmail_default(usernameOrEmail)) {
+      const normalizedEmail = usernameOrEmail?.trim();
+      variables.email = normalizedEmail;
+    } else {
+      variables.username = usernameOrEmail;
+    }
+    variables.password = password;
+    const result = await logInWithPasswordMutation({
+      variables,
+      awaitRefetchQueries: true
+    });
+    if (result?.data?.loginWithPassword) {
+      await client.resetStore();
+    }
+    return result;
+  };
+  return {
+    logInWithPassword
+  };
+};
+var useLoginWithPassword_default = useLoginWithPassword;
+var LogWithWebAuthnMutation = gql`
+  mutation LoginWithWebAuthn($webAuthnPublicKeyCredentials: JSON!) {
+    loginWithWebAuthn(
+      webAuthnPublicKeyCredentials: $webAuthnPublicKeyCredentials
+    ) {
+      _id
+      tokenExpires
+    }
+  }
+`;
+var useLoginWithWebAuthn = () => {
+  const [loginWithWebAuthnMutation, { client }] = useMutation(LogWithWebAuthnMutation);
+  const loginWithWebAuthn = async ({
+    webAuthnPublicKeyCredentials
+  }) => {
+    const result = await loginWithWebAuthnMutation({
+      variables: { webAuthnPublicKeyCredentials },
+      awaitRefetchQueries: true
+    });
+    await client.resetStore();
+    return result;
+  };
+  return { loginWithWebAuthn };
+};
+var useLoginWithWebAuthn_default = useLoginWithWebAuthn;
+var RemoveEmailMutation = gql`
+  mutation RemoveEmail($email: String!, $userId: ID) {
+    removeEmail(email: $email, userId: $userId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useRemoveEmail = () => {
+  const [removeEmailMutation] = useMutation(RemoveEmailMutation);
+  const removeEmail = async ({
+    email,
+    userId
+  }) => {
+    return removeEmailMutation({
+      variables: {
+        email,
+        userId
+      }
+    });
+  };
+  return {
+    removeEmail
+  };
+};
+var useRemoveEmail_default = useRemoveEmail;
+var RemoveWeb3AddressMutation = gql`
+  mutation RemoveWeb3Address($address: String!) {
+    removeWeb3Address(address: $address) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useRemoveWeb3Address = () => {
+  const [removeWeb3AddressMutation] = useMutation(RemoveWeb3AddressMutation);
+  const removeWeb3Address = async ({
+    address
+  }) => {
+    return removeWeb3AddressMutation({
+      variables: {
+        address
+      }
+    });
+  };
+  return {
+    removeWeb3Address
+  };
+};
+var useRemoveWeb3Address_default = useRemoveWeb3Address;
+var RemoveWebAuthCredentialsMutation = gql`
+  mutation removeWebAuthCredentials($credentialsId: ID!) {
+    removeWebAuthnCredentials(credentialsId: $credentialsId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useRemoveWebAuthCredentials = () => {
+  const [removeWebAuthCredentialsMutation] = useMutation(RemoveWebAuthCredentialsMutation);
+  const removeWebAuthCredentials = async ({
+    credentialsId
+  }) => {
+    return removeWebAuthCredentialsMutation({
+      variables: { credentialsId }
+    });
+  };
+  return {
+    removeWebAuthCredentials
+  };
+};
+var useRemoveWebAuthCredentials_default = useRemoveWebAuthCredentials;
+var ResetPasswordMutation = gql`
+  mutation ResetPassword($newPlainPassword: String!, $token: String!) {
+    resetPassword(newPassword: $newPlainPassword, token: $token) {
+      _id
+      tokenExpires
+    }
+  }
+`;
+var useResetPassword = () => {
+  const [resetPasswordMutation, { client }] = useMutation(ResetPasswordMutation);
+  const resetPassword = async ({
+    newPlainPassword,
+    token
+  }) => {
+    const variables = {
+      token,
+      newPlainPassword: null
+    };
+    variables.newPlainPassword = newPlainPassword;
+    const result = await resetPasswordMutation({
+      variables,
+      awaitRefetchQueries: true
+    });
+    await client.resetStore();
+    return result;
+  };
+  return {
+    resetPassword
+  };
+};
+var useResetPassword_default = useResetPassword;
+var SendVerificationEmailMutation = gql`
+  mutation SendVerificationEmail($email: String) {
+    sendVerificationEmail(email: $email) {
+      success
+    }
+  }
+`;
+var useSendVerificationEmail = () => {
+  const [sendVerificationEmailMutation] = useMutation(SendVerificationEmailMutation);
+  const sendVerificationEmail = async ({
+    email
+  }) => {
+    return sendVerificationEmailMutation({
+      variables: { email }
+    });
+  };
+  return {
+    sendVerificationEmail
+  };
+};
+var useSendVerificationEmail_default = useSendVerificationEmail;
+var SetPasswordMutation = gql`
+  mutation SetPassword($newPlainPassword: String!, $userId: ID!) {
+    setPassword(newPassword: $newPlainPassword, userId: $userId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useSetPassword = () => {
+  const [setPasswordMutation] = useMutation(SetPasswordMutation);
+  const setPassword = async ({
+    newPlainPassword = void 0,
+    userId
+  }) => {
+    const variables = { newPlainPassword, userId };
+    return setPasswordMutation({ variables });
+  };
+  return {
+    setPassword
+  };
+};
+var useSetPassword_default = useSetPassword;
+var SetRoleMutation = gql`
+  mutation SetRoles($roles: [String!]!, $userId: ID!) {
+    setRoles(roles: $roles, userId: $userId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useSetRoles = () => {
+  const [setRoleMutation] = useMutation(SetRoleMutation);
+  const setRoles = async ({
+    roles = [],
+    userId = null
+  }) => {
+    return setRoleMutation({
+      variables: {
+        roles,
+        userId
+      },
+      refetchQueries: ["User"]
+    });
+  };
+  return {
+    setRoles
+  };
+};
+var useSetRoles_default = useSetRoles;
+var SetUserTagsMutation = gql`
+  mutation SetUserTags($tags: [LowerCaseString]!, $userId: ID!) {
+    setUserTags(tags: $tags, userId: $userId) {
+      _id
+      tags
+    }
+  }
+`;
+var useSetUserTags = () => {
+  const [setUserTagsMutation] = useMutation(SetUserTagsMutation);
+  const setUserTags = async ({
+    tags = [],
+    userId = null
+  }) => {
+    return setUserTagsMutation({
+      variables: {
+        tags,
+        userId
+      },
+      refetchQueries: ["Users", "User", "ShopStatus", "ShopInfo"]
+    });
+  };
+  return {
+    setUserTags
+  };
+};
+var useSetUserTags_default = useSetUserTags;
+var SetUserNameMutation = gql`
+  mutation SetUsername($username: String!, $userId: ID!) {
+    setUsername(username: $username, userId: $userId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useSetUserName = () => {
+  const [setUserNameMutation] = useMutation(SetUserNameMutation);
+  const setUserName = async ({
+    username,
+    userId
+  }) => {
+    return setUserNameMutation({
+      variables: {
+        username,
+        userId
+      },
+      refetchQueries: ["User"]
+    });
+  };
+  return {
+    setUserName
+  };
+};
+var useSetUsername_default = useSetUserName;
+var PrepareUserAvatarUploadMutation = gql`
+  mutation PrepareUserAvatarUpload($mediaName: String!, $userId: ID) {
+    prepareUserAvatarUpload(mediaName: $mediaName, userId: $userId) {
+      _id
+      putURL
+      expires
+    }
+  }
+`;
+var useUpdateUserAvatar = () => {
+  const [prepareUserAvatarUploadMutation] = useMutation(PrepareUserAvatarUploadMutation);
+  const { confirmMediaUpload } = useConfirmMediaUpload_default({
+    refetchQueries: ["User", "CurrentUser"]
+  });
+  const updateUserAvatar = async ({ avatar, userId = null }) => {
+    const { data } = await prepareUserAvatarUploadMutation({
+      variables: {
+        mediaName: avatar.name,
+        userId
+      }
+    });
+    const { prepareUserAvatarUpload } = data;
+    await PUTMedia_default(avatar, prepareUserAvatarUpload.putURL);
+    await confirmMediaUpload({
+      mediaUploadTicketId: prepareUserAvatarUpload._id,
+      size: avatar.size,
+      type: avatar.type
+    });
+  };
+  return {
+    updateUserAvatar
+  };
+};
+var useUpdateUserAvatar_default = useUpdateUserAvatar;
+var UpdateUserProfileMutation = gql`
+  mutation UpdateUserProfile($profile: UserProfileInput!, $userId: ID) {
+    updateUserProfile(profile: $profile, userId: $userId) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useUpdateUserProfile = () => {
+  const [updateUserProfileMutation] = useMutation(UpdateUserProfileMutation);
+  const updateUserProfile = async ({
+    profile,
+    userId = null
+  }) => {
+    return updateUserProfileMutation({
+      variables: {
+        profile,
+        userId
+      }
+    });
+  };
+  return {
+    updateUserProfile
+  };
+};
+var useUpdateUserProfile_default = useUpdateUserProfile;
+var GetUserQuery = (inlineFragment = "") => gql`
+  query User($userId: ID) {
+    user(userId: $userId) {
+      ${inlineFragment}
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useUser = ({ userId = null } = {}) => {
+  const { customProperties, hydrateFragment } = useUnchainedContext_default();
+  const { data, loading, error } = useQuery(
+    GetUserQuery(customProperties?.User),
+    {
+      skip: !userId,
+      variables: { userId }
+    }
+  );
+  const user = data?.user;
+  const extendedData = hydrateFragment(customProperties?.User, user);
+  return {
+    user,
+    loading,
+    error,
+    extendedData
+  };
+};
+var useUser_default = useUser;
+var UserWebAuthnCredentialsQuery = gql`
+  query UserWebAuthnCredentials($userId: ID!) {
+    user(userId: $userId) {
+      _id
+      webAuthnCredentials {
+        _id
+        created
+        aaguid
+        counter
+        mdsMetadata {
+          ...MD5MetaDataFragment
+        }
+      }
+    }
+  }
+  ${MD5MetaDataFragment_default}
+`;
+var useUserWebAuthnCredentials = ({
+  userId
+}) => {
+  const { data, loading, error } = useQuery(UserWebAuthnCredentialsQuery, {
+    variables: { userId }
+  });
+  return {
+    webAuthnCredentials: data?.user?.webAuthnCredentials,
+    loading,
+    error
+  };
+};
+var useUserWebAuthnCredentials_default = useUserWebAuthnCredentials;
+var UsersQuery = gql`
+  query Users(
+    $limit: Int
+    $offset: Int
+    $includeGuests: Boolean
+    $queryString: String
+    $lastLogin: DateFilterInput
+    $emailVerified: Boolean
+    $tags: [LowerCaseString!]
+  ) {
+    users(
+      limit: $limit
+      offset: $offset
+      includeGuests: $includeGuests
+      queryString: $queryString
+      lastLogin: $lastLogin
+      emailVerified: $emailVerified
+      tags: $tags
+    ) {
+      ...UserFragment
+    }
+    usersCount(
+      includeGuests: $includeGuests
+      queryString: $queryString
+      lastLogin: $lastLogin
+      emailVerified: $emailVerified
+      tags: $tags
+    )
+  }
+  ${UserFragment_default}
+`;
+var useUsers = ({
+  limit = 20,
+  offset = 0,
+  includeGuests = false,
+  queryString = null,
+  lastLogin = null,
+  emailVerified = null,
+  tags = null
+}) => {
+  const { data, loading, error, fetchMore } = useQuery(UsersQuery, {
+    variables: {
+      limit,
+      offset,
+      includeGuests,
+      queryString,
+      lastLogin,
+      emailVerified,
+      tags
+    }
+  });
+  const users = data?.users || [];
+  const usersCount = data?.usersCount;
+  const hasMore = users?.length < usersCount;
+  const loadMore = () => {
+    fetchMore({
+      variables: { offset: users?.length }
+    });
+  };
+  return {
+    users,
+    usersCount,
+    hasMore,
+    loading,
+    error,
+    loadMore
+  };
+};
+var useUsers_default = useUsers;
+var UsersCountQuery = gql`
+  query UsersCount(
+    $includeGuests: Boolean
+    $queryString: String
+    $lastLogin: DateFilterInput
+    $emailVerified: Boolean
+  ) {
+    usersCount(
+      includeGuests: $includeGuests
+      queryString: $queryString
+      lastLogin: $lastLogin
+      emailVerified: $emailVerified
+    )
+  }
+`;
+var useUsersCount = ({
+  includeGuests = false,
+  queryString = null,
+  lastLogin = null,
+  emailVerified = null
+} = {}) => {
+  const { data, loading, error } = useQuery(UsersCountQuery, {
+    errorPolicy: "all",
+    variables: {
+      includeGuests,
+      queryString,
+      lastLogin,
+      emailVerified
+    }
+  });
+  return {
+    usersCount: data?.usersCount || 0,
+    loading,
+    error
+  };
+};
+var useUsersCount_default = useUsersCount;
+var ValidateVerifyEmailToken = gql`
+  query ValidateVerifyEmailToken($token: String!) {
+    validateVerifyEmailToken(token: $token)
+  }
+`;
+var useValidateEmailVerificationToken = ({ token }) => {
+  const { data, loading, error, previousData } = useQuery(ValidateVerifyEmailToken, {
+    skip: !token,
+    variables: {
+      token
+    },
+    fetchPolicy: "network-only"
+  });
+  return {
+    loading,
+    error,
+    isValid: previousData?.validateVerifyEmailToken || data?.validateVerifyEmailToken
+  };
+};
+var useValidateEmailVerificationToken_default = useValidateEmailVerificationToken;
+var VALIDATE_RESET_PASSWORD_TOKEN_QUERY = gql`
+  query ValidateResetPasswordToken($token: String!) {
+    validateResetPasswordToken(token: $token)
+  }
+`;
+var useValidateResetPasswordToken = ({ token }) => {
+  const { data, loading, error, previousData } = useQuery(VALIDATE_RESET_PASSWORD_TOKEN_QUERY, {
+    skip: !token,
+    variables: {
+      token
+    },
+    fetchPolicy: "network-only"
+  });
+  return {
+    loading,
+    error,
+    isValid: previousData?.validateResetPasswordToken || data?.validateResetPasswordToken
+  };
+};
+var useValidateResetPasswordToken_default = useValidateResetPasswordToken;
+var VerifyEmailMutation = gql`
+  mutation VerifyEmail($token: String!) {
+    verifyEmail(token: $token) {
+      _id
+      tokenExpires
+      user {
+        ...UserFragment
+      }
+    }
+  }
+  ${UserFragment_default}
+`;
+var useVerifyEmail = () => {
+  const [verifyEmailMutation, { client }] = useMutation(VerifyEmailMutation);
+  const verifyEmail = async ({ token }) => {
+    const result = await verifyEmailMutation({
+      variables: { token }
+    });
+    await client.resetStore();
+    return result;
+  };
+  return {
+    verifyEmail
+  };
+};
+var useVerifyEmail_default = useVerifyEmail;
+var VerifyWeb3AddressMutation = gql`
+  mutation VerifyWeb3Address($address: String!, $hash: String!) {
+    verifyWeb3Address(address: $address, hash: $hash) {
+      ...UserFragment
+    }
+  }
+  ${UserFragment_default}
+`;
+var useVerifyWeb3Address = () => {
+  const [verifyWeb3AddressMutation] = useMutation(VerifyWeb3AddressMutation);
+  const verifyWeb3Address = async ({
+    address,
+    hash
+  }) => {
+    return verifyWeb3AddressMutation({
+      variables: {
+        address,
+        hash
+      }
+    });
+  };
+  return {
+    verifyWeb3Address
+  };
+};
+var useVerifyWeb3Address_default = useVerifyWeb3Address;
+
+export { logOut_default as logOut, useAddEmail_default as useAddEmail, useAddWeb3Address_default as useAddWeb3Address, useAddWebAuthnCredentials_default as useAddWebAuthnCredentials, useChangePassword_default as useChangePassword, useCreateUser_default as useCreateUser, useCreateWebAuthnCredentialCreationOptions_default as useCreateWebAuthnCredentialCreationOptions, useCreateWebAuthnCredentialRequestOptions_default as useCreateWebAuthnCredentialRequestOptions, useDeleteUser_default as useDeleteUser, useForgotPassword_default as useForgotPassword, useGenerateLoginCredentials_default as useGenerateLoginCredentials, useGenerateWebAuthCredentials_default as useGenerateWebAuthCredentials, useLoginWithPassword_default as useLoginWithPassword, useLoginWithWebAuthn_default as useLoginWithWebAuthn, useRemoveEmail_default as useRemoveEmail, useRemoveWeb3Address_default as useRemoveWeb3Address, useRemoveWebAuthCredentials_default as useRemoveWebAuthCredentials, useResetPassword_default as useResetPassword, useSendVerificationEmail_default as useSendVerificationEmail, useSetPassword_default as useSetPassword, useSetRoles_default as useSetRoles, useSetUserTags_default as useSetUserTags, useSetUsername_default as useSetUsername, useUpdateUserAvatar_default as useUpdateUserAvatar, useUpdateUserProfile_default as useUpdateUserProfile, useUser_default as useUser, useUserWebAuthnCredentials_default as useUserWebAuthnCredentials, useUsers_default as useUsers, useUsersCount_default as useUsersCount, useValidateEmailVerificationToken_default as useValidateEmailVerificationToken, useValidateResetPasswordToken_default as useValidateResetPasswordToken, useVerifyEmail_default as useVerifyEmail, useVerifyWeb3Address_default as useVerifyWeb3Address };