// @ts-nocheck
/**
 *  This is an auto generate file from fireback project.
 *  You can use this in order to communicate in backend, it gives you available actions,
 *  and their types
 *  Module: passports
 */

import { FormikHelpers } from "formik";
import React, { useCallback } from "react";
import {
  useMutation,
  useQuery,
  useQueryClient,
  QueryClient,
} from "react-query";
import { PassportActions } from "./passport-actions";
import * as passports from "./index";
import {
  execApiFn,
  RemoteRequestOption,
  IDeleteResponse,
  core,
  IResponse,
  ExecApi,
  mutationErrorsToFormik,
  IResponseList,
} from "../../core/http-tools";
/**
 * Gives you formik forms, all mutations, submit actions, and error handling,
 * and provides internal store for all changes happens through this
 * for modules
 */
export function usePassports(
  { options, query, execFn }: { options: RemoteRequestOption; query?: any },
  queryClient: QueryClient,
  execFn?: ExecApi
) {
  const caller = execFn
    ? PassportActions.fnExec(execFn(options))
    : PassportActions.fn(options);
  const Q = () =>
    caller
      .startIndex(query?.startIndex)
      .deep(query?.deep)
      .itemsPerPage(query?.itemsPerPage)
      .query(query?.query);

  const passportsQuery = useQuery(
    ["*[]passports.PassportEntity", options],
    () => Q().getPassports(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  const passportByUniqueIdQuery = useQuery(
    ["*passports.PassportEntity", options],
    (uniqueId: string) => Q().getPassportByUniqueId(uniqueId),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // post passport

  const mutationPostPassport = useMutation<
    IResponse<passports.PassportEntity>,
    IResponse<passports.PassportEntity>,
    passports.PassportEntity
  >((entity) => {
    return Q().postPassport(entity);
  });

  // Only entities are having a store in front-end

  const fnPostPassportUpdater = (
    data: IResponseList<passports.PassportEntity> | undefined,
    item: IResponse<passports.PassportEntity>
  ) => {
    return [];

    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items && item.data) {
      data.data.items = data.data.items.map((t) => {
        if (
          item.data !== undefined &&
          PassportActions.isPassportEntityEqual(t, item.data)
        ) {
          return item.data;
        }

        return t;
      });
    } else if (data?.data && item.data) {
      data.data.items = [item.data, ...(data?.data?.items || [])];
    }

    return data;
  };

  const submitPostPassport = (
    values: passports.PassportEntity,
    formikProps?: FormikHelpers<passports.PassportEntity>
  ): Promise<IResponse<passports.PassportEntity>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassport.mutate(values, {
        onSuccess(response: IResponse<passports.PassportEntity>) {
          queryClient.setQueriesData<IResponseList<passports.PassportEntity>>(
            "*[]passports.PassportEntity",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: passports.PassportEntity) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // patch passport/:uniqueId

  const mutationPatchPassportByUniqueId = useMutation<
    IResponse<passports.PassportEntity>,
    IResponse<passports.PassportEntity>,
    passports.PassportEntity
  >(
    (
      uniqueId: string,

      entity
    ) => {
      return Q().patchPassportByUniqueId(
        uniqueId,

        entity
      );
    }
  );

  // Only entities are having a store in front-end

  const fnPatchPassportByUniqueIdUpdater = (
    data: IResponseList<passports.PassportEntity> | undefined,
    item: IResponse<passports.PassportEntity>
  ) => {
    return [];

    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items && item.data) {
      data.data.items = data.data.items.map((t) => {
        if (
          item.data !== undefined &&
          PassportActions.isPassportEntityEqual(t, item.data)
        ) {
          return item.data;
        }

        return t;
      });
    } else if (data?.data && item.data) {
      data.data.items = [item.data, ...(data?.data?.items || [])];
    }

    return data;
  };

  const submitPatchPassportByUniqueId = (
    values: passports.PassportEntity,
    formikProps?: FormikHelpers<passports.PassportEntity>
  ): Promise<IResponse<passports.PassportEntity>> => {
    return new Promise((resolve, reject) => {
      mutationPatchPassportByUniqueId.mutate(values, {
        onSuccess(response: IResponse<passports.PassportEntity>) {
          queryClient.setQueriesData<IResponseList<passports.PassportEntity>>(
            "*[]passports.PassportEntity",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: passports.PassportEntity) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // Deleting an entity
  const mutationDeletePassport = useMutation<
    IDeleteResponse,
    IDeleteResponse,
    core.DeleteRequest
  >(() => {
    return Q().deletePassport();
  });

  const fnDeletePassportUpdater = (
    data: IResponseList<passports.PassportEntity> | undefined,
    deleteItemsList: string[]
  ) => {
    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items) {
      data.data.items = data.data.items.filter((t) => {
        const key = PassportActions.getPassportEntityPrimaryKey(t);

        if (!deleteItemsList.includes(key)) {
          return true;
        }

        return false;
      });
    }

    return data;
  };

  const submitDeletePassport = (
    values: string[],
    formikProps?: FormikHelpers<passports.PassportEntity>
  ) => {
    return new Promise((resolve, reject) => {
      mutationDeletePassport.mutate(values, {
        onSuccess(response: IDeleteResponse) {
          queryClient.setQueryData<IResponseList<passports.PassportEntity>>(
            "*[]passports.PassportEntity",
            (data) => fnDeletePassportUpdater(data, values)
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/signup/email

  const mutationPostPassportSignupEmail = useMutation<
    IResponse<passports.UserSessionDto>,
    IResponse<passports.UserSessionDto>,
    passports.EmailAccountSignupDto
  >((entity) => {
    return Q().postPassportSignupEmail(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportSignupEmail = (
    values: passports.EmailAccountSignupDto,
    formikProps?: FormikHelpers<passports.EmailAccountSignupDto>
  ): Promise<IResponse<passports.UserSessionDto>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportSignupEmail.mutate(values, {
        onSuccess(response: IResponse<passports.UserSessionDto>) {
          queryClient.setQueriesData<
            IResponseList<passports.EmailAccountSignupDto>
          >("*[]passports.EmailAccountSignupDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.EmailAccountSignupDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspacePublicjoinkeysQuery = useQuery(
    ["*[]passports.PublicJoinKey", options],
    () => Q().getWorkspacePublicjoinkeys(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // post workspace/publicjoinkey

  const mutationPostWorkspacePublicjoinkey = useMutation<
    IResponse<passports.PublicJoinKey>,
    IResponse<passports.PublicJoinKey>,
    passports.PublicJoinKey
  >((entity) => {
    return Q().postWorkspacePublicjoinkey(entity);
  });

  // Only entities are having a store in front-end

  const submitPostWorkspacePublicjoinkey = (
    values: passports.PublicJoinKey,
    formikProps?: FormikHelpers<passports.PublicJoinKey>
  ): Promise<IResponse<passports.PublicJoinKey>> => {
    return new Promise((resolve, reject) => {
      mutationPostWorkspacePublicjoinkey.mutate(values, {
        onSuccess(response: IResponse<passports.PublicJoinKey>) {
          queryClient.setQueriesData<IResponseList<passports.PublicJoinKey>>(
            "*[]passports.PublicJoinKey",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: passports.PublicJoinKey) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspacePublicjoinkeyByUniqueIdQuery = useQuery(
    ["*passports.PublicJoinKey", options],
    (uniqueId: string) => Q().getWorkspacePublicjoinkeyByUniqueId(uniqueId),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  const workspacePublicJoinKeyInfoByUniqueIdQuery = useQuery(
    ["*passports.PublicJoinKey", options],
    (uniqueId: string) => Q().getWorkspacePublicJoinKeyInfoByUniqueId(uniqueId),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // Deleting an entity
  const mutationDeleteWorkspacePublicjoinkey = useMutation<
    IDeleteResponse,
    IDeleteResponse,
    core.DeleteRequest
  >(() => {
    return Q().deleteWorkspacePublicjoinkey();
  });

  const fnDeleteWorkspacePublicjoinkeyUpdater = (
    data: IResponseList<passports.PublicJoinKey> | undefined,
    deleteItemsList: string[]
  ) => {
    if (!data) {
      return {
        data: { items: [] },
      };
    }

    if (data?.data?.items) {
      data.data.items = data.data.items.filter((t) => {
        const key = PassportActions.getPublicJoinKeyPrimaryKey(t);

        if (!deleteItemsList.includes(key)) {
          return true;
        }

        return false;
      });
    }

    return data;
  };

  const submitDeleteWorkspacePublicjoinkey = (
    values: string[],
    formikProps?: FormikHelpers<passports.PublicJoinKey>
  ) => {
    return new Promise((resolve, reject) => {
      mutationDeleteWorkspacePublicjoinkey.mutate(values, {
        onSuccess(response: IDeleteResponse) {
          queryClient.setQueryData<IResponseList<passports.PublicJoinKey>>(
            "*[]passports.PublicJoinKey",
            (data) => fnDeleteWorkspacePublicjoinkeyUpdater(data, values)
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // patch workspace/publicjoinkey

  const mutationPatchWorkspacePublicjoinkey = useMutation<
    IResponse<passports.PublicJoinKey>,
    IResponse<passports.PublicJoinKey>,
    passports.PublicJoinKey
  >((entity) => {
    return Q().patchWorkspacePublicjoinkey(entity);
  });

  // Only entities are having a store in front-end

  const submitPatchWorkspacePublicjoinkey = (
    values: passports.PublicJoinKey,
    formikProps?: FormikHelpers<passports.PublicJoinKey>
  ): Promise<IResponse<passports.PublicJoinKey>> => {
    return new Promise((resolve, reject) => {
      mutationPatchWorkspacePublicjoinkey.mutate(values, {
        onSuccess(response: IResponse<passports.PublicJoinKey>) {
          queryClient.setQueriesData<IResponseList<passports.PublicJoinKey>>(
            "*[]passports.PublicJoinKey",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: passports.PublicJoinKey) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/signin/email

  const mutationPostPassportSigninEmail = useMutation<
    IResponse<passports.UserSessionDto>,
    IResponse<passports.UserSessionDto>,
    passports.EmailAccountSigninDto
  >((entity) => {
    return Q().postPassportSigninEmail(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportSigninEmail = (
    values: passports.EmailAccountSigninDto,
    formikProps?: FormikHelpers<passports.EmailAccountSigninDto>
  ): Promise<IResponse<passports.UserSessionDto>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportSigninEmail.mutate(values, {
        onSuccess(response: IResponse<passports.UserSessionDto>) {
          queryClient.setQueriesData<
            IResponseList<passports.EmailAccountSigninDto>
          >("*[]passports.EmailAccountSigninDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.EmailAccountSigninDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/authorizeOs

  const mutationPostPassportAuthorizeOs = useMutation<
    IResponse<passports.UserSessionDto>,
    IResponse<passports.UserSessionDto>,
    passports.EmailAccountSigninDto
  >((entity) => {
    return Q().postPassportAuthorizeOs(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportAuthorizeOs = (
    values: passports.EmailAccountSigninDto,
    formikProps?: FormikHelpers<passports.EmailAccountSigninDto>
  ): Promise<IResponse<passports.UserSessionDto>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportAuthorizeOs.mutate(values, {
        onSuccess(response: IResponse<passports.UserSessionDto>) {
          queryClient.setQueriesData<
            IResponseList<passports.EmailAccountSigninDto>
          >("*[]passports.EmailAccountSigninDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.EmailAccountSigninDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const workspacesInviteByUniqueIdQuery = useQuery(
    ["*workspaces.WorkspaceInviteEntity", options],
    (uniqueId: string) => Q().getWorkspacesInviteByUniqueId(uniqueId),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  // post passport/signup/phoneNumber

  const mutationPostPassportSignupPhoneNumber = useMutation<
    IResponse<core.OkayResponse>,
    IResponse<core.OkayResponse>,
    passports.PhoneNumberAccountCreationDto
  >((entity) => {
    return Q().postPassportSignupPhoneNumber(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportSignupPhoneNumber = (
    values: passports.PhoneNumberAccountCreationDto,
    formikProps?: FormikHelpers<passports.PhoneNumberAccountCreationDto>
  ): Promise<IResponse<core.OkayResponse>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportSignupPhoneNumber.mutate(values, {
        onSuccess(response: IResponse<core.OkayResponse>) {
          queryClient.setQueriesData<
            IResponseList<passports.PhoneNumberAccountCreationDto>
          >("*[]passports.PhoneNumberAccountCreationDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.PhoneNumberAccountCreationDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/signup/phoneNumberConfirm

  const mutationPostPassportSignupPhoneNumberConfirm = useMutation<
    IResponse<core.OkayResponse>,
    IResponse<core.OkayResponse>,
    passports.PhoneNumberAccountCreationDto
  >((entity) => {
    return Q().postPassportSignupPhoneNumberConfirm(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportSignupPhoneNumberConfirm = (
    values: passports.PhoneNumberAccountCreationDto,
    formikProps?: FormikHelpers<passports.PhoneNumberAccountCreationDto>
  ): Promise<IResponse<core.OkayResponse>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportSignupPhoneNumberConfirm.mutate(values, {
        onSuccess(response: IResponse<core.OkayResponse>) {
          queryClient.setQueriesData<
            IResponseList<passports.PhoneNumberAccountCreationDto>
          >("*[]passports.PhoneNumberAccountCreationDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.PhoneNumberAccountCreationDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/signin/phoneNumber

  const mutationPostPassportSigninPhoneNumber = useMutation<
    IResponse<passports.UserSessionDto>,
    IResponse<passports.UserSessionDto>,
    passports.PhoneNumberAccountCreationDto
  >((entity) => {
    return Q().postPassportSigninPhoneNumber(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportSigninPhoneNumber = (
    values: passports.PhoneNumberAccountCreationDto,
    formikProps?: FormikHelpers<passports.PhoneNumberAccountCreationDto>
  ): Promise<IResponse<passports.UserSessionDto>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportSigninPhoneNumber.mutate(values, {
        onSuccess(response: IResponse<passports.UserSessionDto>) {
          queryClient.setQueriesData<
            IResponseList<passports.PhoneNumberAccountCreationDto>
          >("*[]passports.PhoneNumberAccountCreationDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.PhoneNumberAccountCreationDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post confirm/email/:uniqueId

  const mutationPostConfirmEmailByUniqueId = useMutation<
    IResponse<core.OkayResponse>,
    IResponse<core.OkayResponse>,
    core.EmptyRequest
  >(
    (
      uniqueId: string,

      entity
    ) => {
      return Q().postConfirmEmailByUniqueId(
        uniqueId,

        entity
      );
    }
  );

  // Only entities are having a store in front-end

  const submitPostConfirmEmailByUniqueId = (
    values: core.EmptyRequest,
    formikProps?: FormikHelpers<core.EmptyRequest>
  ): Promise<IResponse<core.OkayResponse>> => {
    return new Promise((resolve, reject) => {
      mutationPostConfirmEmailByUniqueId.mutate(values, {
        onSuccess(response: IResponse<core.OkayResponse>) {
          queryClient.setQueriesData<IResponseList<core.EmptyRequest>>(
            "*[]core.EmptyRequest",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: core.EmptyRequest) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/request-reset-mail-password

  const mutationPostPassportRequestResetMailPassword = useMutation<
    IResponse<passports.EmailOtpResponse>,
    IResponse<passports.EmailOtpResponse>,
    passports.OtpAuthenticateDto
  >((entity) => {
    return Q().postPassportRequestResetMailPassword(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportRequestResetMailPassword = (
    values: passports.OtpAuthenticateDto,
    formikProps?: FormikHelpers<passports.OtpAuthenticateDto>
  ): Promise<IResponse<passports.EmailOtpResponse>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportRequestResetMailPassword.mutate(values, {
        onSuccess(response: IResponse<passports.EmailOtpResponse>) {
          queryClient.setQueriesData<
            IResponseList<passports.OtpAuthenticateDto>
          >("*[]passports.OtpAuthenticateDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.OtpAuthenticateDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/authorize2

  const mutationPostPassportAuthorize2 = useMutation<
    IResponse<passports.EmailOtpResponse>,
    IResponse<passports.EmailOtpResponse>,
    passports.OtpAuthenticateDto
  >((entity) => {
    return Q().postPassportAuthorize2(entity);
  });

  // Only entities are having a store in front-end

  const submitPostPassportAuthorize2 = (
    values: passports.OtpAuthenticateDto,
    formikProps?: FormikHelpers<passports.OtpAuthenticateDto>
  ): Promise<IResponse<passports.EmailOtpResponse>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportAuthorize2.mutate(values, {
        onSuccess(response: IResponse<passports.EmailOtpResponse>) {
          queryClient.setQueriesData<
            IResponseList<passports.OtpAuthenticateDto>
          >("*[]passports.OtpAuthenticateDto", (data: any) => {
            if (!(data?.data?.items?.length > 0)) {
              return data;
            }

            data.data.items = data.data.items.map(
              (item: passports.OtpAuthenticateDto) => {
                if (item.uniqueId === response.data?.uniqueId) {
                  return response.data;
                }

                return item;
              }
            );

            return data;
          });

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  // post passport/reset-mail-password/:uniqueId

  const mutationPostPassportResetMailPasswordByUniqueId = useMutation<
    IResponse<passports.UserSessionDto>,
    IResponse<passports.UserSessionDto>,
    passports.ResetEmailDto
  >(
    (
      uniqueId: string,

      entity
    ) => {
      return Q().postPassportResetMailPasswordByUniqueId(
        uniqueId,

        entity
      );
    }
  );

  // Only entities are having a store in front-end

  const submitPostPassportResetMailPasswordByUniqueId = (
    values: passports.ResetEmailDto,
    formikProps?: FormikHelpers<passports.ResetEmailDto>
  ): Promise<IResponse<passports.UserSessionDto>> => {
    return new Promise((resolve, reject) => {
      mutationPostPassportResetMailPasswordByUniqueId.mutate(values, {
        onSuccess(response: IResponse<passports.UserSessionDto>) {
          queryClient.setQueriesData<IResponseList<passports.ResetEmailDto>>(
            "*[]passports.ResetEmailDto",
            (data: any) => {
              if (!(data?.data?.items?.length > 0)) {
                return data;
              }

              data.data.items = data.data.items.map(
                (item: passports.ResetEmailDto) => {
                  if (item.uniqueId === response.data?.uniqueId) {
                    return response.data;
                  }

                  return item;
                }
              );

              return data;
            }
          );

          resolve(response);
        },

        onError(error: any) {
          formikProps?.setErrors(mutationErrorsToFormik(error));

          reject(error);
        },
      });
    });
  };

  const passportRequestResetMailPasswordQuery = useQuery(
    ["*core.OkayResponse", options],
    () => Q().getPassportRequestResetMailPassword(),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  const passportResetMailPasswordInfoByUniqueIdQuery = useQuery(
    ["*core.OkayResponse", options],
    (uniqueId: string) =>
      Q().getPassportResetMailPasswordInfoByUniqueId(uniqueId),
    {
      cacheTime: 1000,
      enabled: !!options?.headers?.authorization,
    }
  );

  return {
    queryClient,
    passportsQuery,
    passportByUniqueIdQuery,
    mutationPostPassport,
    submitPostPassport,
    mutationPatchPassportByUniqueId,
    submitPatchPassportByUniqueId,
    mutationDeletePassport,
    submitDeletePassport,
    mutationPostPassportSignupEmail,
    submitPostPassportSignupEmail,
    workspacePublicjoinkeysQuery,
    mutationPostWorkspacePublicjoinkey,
    submitPostWorkspacePublicjoinkey,
    workspacePublicjoinkeyByUniqueIdQuery,
    workspacePublicJoinKeyInfoByUniqueIdQuery,
    mutationDeleteWorkspacePublicjoinkey,
    submitDeleteWorkspacePublicjoinkey,
    mutationPatchWorkspacePublicjoinkey,
    submitPatchWorkspacePublicjoinkey,
    mutationPostPassportSigninEmail,
    submitPostPassportSigninEmail,
    mutationPostPassportAuthorizeOs,
    submitPostPassportAuthorizeOs,
    workspacesInviteByUniqueIdQuery,
    mutationPostPassportSignupPhoneNumber,
    submitPostPassportSignupPhoneNumber,
    mutationPostPassportSignupPhoneNumberConfirm,
    submitPostPassportSignupPhoneNumberConfirm,
    mutationPostPassportSigninPhoneNumber,
    submitPostPassportSigninPhoneNumber,
    mutationPostConfirmEmailByUniqueId,
    submitPostConfirmEmailByUniqueId,
    mutationPostPassportRequestResetMailPassword,
    submitPostPassportRequestResetMailPassword,
    mutationPostPassportAuthorize2,
    submitPostPassportAuthorize2,
    mutationPostPassportResetMailPasswordByUniqueId,
    submitPostPassportResetMailPasswordByUniqueId,
    passportRequestResetMailPasswordQuery,
    passportResetMailPasswordInfoByUniqueIdQuery,
  };
}