@anzar-auth/client 1.3.6

package/dist/index.cjs

@@ -0,0 +1,970 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Anzar: () => Anzar
+});
+module.exports = __toCommonJS(src_exports);
+var import_axios6 = __toESM(require("axios"), 1);
+
+// src/adapters/memory_storage.ts
+var MemoryStorage = class {
+  acessToken = null;
+  refreshToken = null;
+  getToken() {
+    return this.acessToken;
+  }
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  onTokenRefresh(tokens) {
+    this.acessToken = tokens.access;
+    this.refreshToken = tokens.refresh;
+  }
+  onSessionExpired() {
+    this.acessToken = null;
+    this.refreshToken = null;
+  }
+  onLogout() {
+    this.acessToken = null;
+    this.refreshToken = null;
+  }
+};
+
+// src/api/auth.ts
+var import_axios = __toESM(require("axios"), 1);
+var AuthModule = class {
+  constructor(authApi, userApi, strategy, options) {
+    this.authApi = authApi;
+    this.userApi = userApi;
+    this.strategy = strategy;
+    this.options = options;
+  }
+  async login(body) {
+    const response = await this.authApi.login(body);
+    const auth_response = response.data;
+    if (auth_response.tokens) {
+      this.options?.storage.onTokenRefresh?.(auth_response.tokens);
+    }
+    return {
+      user: auth_response.user,
+      verification: auth_response.verification
+    };
+  }
+  async register(body) {
+    const response = await this.authApi.register(body);
+    const auth_response = response.data;
+    if (auth_response.tokens) {
+      this.options?.storage.onTokenRefresh?.(auth_response.tokens);
+    }
+    return {
+      user: auth_response.user,
+      verification: auth_response.verification
+    };
+  }
+  async logout() {
+    const refreshToken = this.options?.storage.getRefreshToken();
+    await this.authApi.logout({ refresh_token: refreshToken ?? "" });
+    this.options?.storage.onLogout?.();
+  }
+  resetPassword(body) {
+    this.authApi.requestPasswordReset(body);
+  }
+  async isAuthenticated() {
+    try {
+      const response = await this.userApi.findUser();
+      return !!response.data.username;
+    } catch (error) {
+      if (import_axios.default.isAxiosError(error) && error.response?.status === 401) {
+        return false;
+      }
+      throw false;
+    }
+  }
+  async session() {
+    if (this.strategy !== "Session" /* Session */) {
+      throw new Error("session() is only available with Session auth strategy");
+    }
+    const response = await this.authApi.getSession();
+    return response.data;
+  }
+};
+
+// src/api/interceptor.ts
+var JwtInterceptor = class {
+  isRefreshing = false;
+  waitingQueue = [];
+  drainQueue(token) {
+    this.waitingQueue.forEach(({ resolve }) => resolve(token));
+    this.waitingQueue = [];
+  }
+  rejectQueue(error) {
+    this.waitingQueue.forEach(({ reject }) => reject(error));
+    this.waitingQueue = [];
+  }
+  apply(axiosInstance, options) {
+    const REFRESH_URI = "/auth/refresh-token";
+    axiosInstance.interceptors.request.use(
+      (config) => {
+        const accessToken = options?.storage.getToken();
+        if (!config.url?.includes(REFRESH_URI) && accessToken) {
+          config.headers.Authorization = `Bearer ${accessToken}`;
+        }
+        return config;
+      },
+      (error) => {
+        return Promise.reject(error);
+      }
+    );
+    axiosInstance.interceptors.response.use(
+      (response) => response,
+      async (error) => {
+        const originalRequest = error.config;
+        if (error.response?.status !== 401 || originalRequest._retry || originalRequest.url?.includes(REFRESH_URI)) {
+          return Promise.reject(error);
+        }
+        if (this.isRefreshing) {
+          return new Promise((resolve, reject) => {
+            this.waitingQueue.push({ resolve, reject });
+          }).then((newToken) => {
+            originalRequest.headers.Authorization = `Bearer ${newToken}`;
+            return axiosInstance(originalRequest);
+          });
+        }
+        originalRequest._retry = true;
+        this.isRefreshing = true;
+        try {
+          const refreshToken = options?.storage.getRefreshToken();
+          if (!refreshToken) return Promise.reject(error);
+          const response = await axiosInstance.post(REFRESH_URI, {
+            refresh_token: refreshToken
+          });
+          const auth_response = response.data;
+          if (auth_response.tokens) {
+            options?.storage.onTokenRefresh?.(auth_response.tokens);
+          }
+          this.drainQueue(auth_response.tokens?.access);
+          originalRequest.headers.Authorization = `Bearer ${auth_response.tokens?.access}`;
+          return axiosInstance(originalRequest);
+        } catch (e) {
+          this.rejectQueue(e);
+          options?.storage.onSessionExpired?.();
+          return Promise.reject(e);
+        } finally {
+          this.isRefreshing = false;
+        }
+      }
+    );
+  }
+};
+
+// src/generated/api/auth-api.ts
+var import_axios3 = __toESM(require("axios"), 1);
+
+// src/generated/base.ts
+var import_axios2 = __toESM(require("axios"), 1);
+var BASE_PATH = "http://localhost".replace(/\/+$/, "");
+var BaseAPI = class {
+  constructor(configuration, basePath = BASE_PATH, axios3 = import_axios2.default) {
+    this.basePath = basePath;
+    this.axios = axios3;
+    if (configuration) {
+      this.configuration = configuration;
+      this.basePath = configuration.basePath ?? basePath;
+    }
+  }
+  configuration;
+};
+var RequiredError = class extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+    this.name = "RequiredError";
+  }
+};
+var operationServerMap = {};
+
+// src/generated/common.ts
+var DUMMY_BASE_URL = "https://example.com";
+var assertParamExists = function(functionName, paramName, paramValue) {
+  if (paramValue === null || paramValue === void 0) {
+    throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
+  }
+};
+var setBearerAuthToObject = async function(object, configuration) {
+  if (configuration && configuration.accessToken) {
+    const accessToken = typeof configuration.accessToken === "function" ? await configuration.accessToken() : await configuration.accessToken;
+    object["Authorization"] = "Bearer " + accessToken;
+  }
+};
+function setFlattenedQueryParams(urlSearchParams, parameter, key = "") {
+  if (parameter == null) return;
+  if (typeof parameter === "object") {
+    if (Array.isArray(parameter) || parameter instanceof Set) {
+      parameter.forEach((item) => setFlattenedQueryParams(urlSearchParams, item, key));
+    } else {
+      Object.keys(parameter).forEach(
+        (currentKey) => setFlattenedQueryParams(urlSearchParams, parameter[currentKey], `${key}${key !== "" ? "." : ""}${currentKey}`)
+      );
+    }
+  } else {
+    if (urlSearchParams.has(key)) {
+      urlSearchParams.append(key, parameter);
+    } else {
+      urlSearchParams.set(key, parameter);
+    }
+  }
+}
+var setSearchParams = function(url, ...objects) {
+  const searchParams = new URLSearchParams(url.search);
+  setFlattenedQueryParams(searchParams, objects);
+  url.search = searchParams.toString();
+};
+var replaceWithSerializableTypeIfNeeded = function(key, value) {
+  if (value instanceof Set) {
+    return Array.from(value);
+  } else {
+    return value;
+  }
+};
+var serializeDataIfNeeded = function(value, requestOptions, configuration) {
+  const nonString = typeof value !== "string";
+  const needsSerialization = nonString && configuration && configuration.isJsonMime ? configuration.isJsonMime(requestOptions.headers["Content-Type"]) : nonString;
+  return needsSerialization ? JSON.stringify(value !== void 0 ? value : {}, replaceWithSerializableTypeIfNeeded) : value || "";
+};
+var toPathString = function(url) {
+  return url.pathname + url.search + url.hash;
+};
+var createRequestFunction = function(axiosArgs, globalAxios5, BASE_PATH2, configuration) {
+  return (axios3 = globalAxios5, basePath = BASE_PATH2) => {
+    const axiosRequestArgs = { ...axiosArgs.options, url: (axios3.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
+    return axios3.request(axiosRequestArgs);
+  };
+};
+
+// src/generated/api/auth-api.ts
+var AuthApiAxiosParamCreator = function(configuration) {
+  return {
+    /**
+     * Returns the currently authenticated user\'s session data. Requires a valid Bearer token.
+     * @summary Get current session
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getSession: async (options = {}) => {
+      const localVarPath = `/auth/session`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setBearerAuthToObject(localVarHeaderParameter, configuration);
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Authenticates a user with email and password. Returns an access token and refresh token on success.
+     * @summary User login
+     * @param {LoginRequest} loginRequest User login credentials
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    login: async (loginRequest, options = {}) => {
+      assertParamExists("login", "loginRequest", loginRequest);
+      const localVarPath = `/auth/login`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(loginRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Invalidates the current session and refresh token. The client should discard stored tokens.
+     * @summary Logout
+     * @param {RefreshTokenRequest} refreshTokenRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    logout: async (refreshTokenRequest, options = {}) => {
+      assertParamExists("logout", "refreshTokenRequest", refreshTokenRequest);
+      const localVarPath = `/auth/logout`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setBearerAuthToObject(localVarHeaderParameter, configuration);
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(refreshTokenRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Issues a new access token using a valid refresh token. Rotate refresh tokens on each call.
+     * @summary Refresh access token
+     * @param {RefreshTokenRequest} refreshTokenRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    refreshToken: async (refreshTokenRequest, options = {}) => {
+      assertParamExists("refreshToken", "refreshTokenRequest", refreshTokenRequest);
+      const localVarPath = `/auth/refresh-token`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setBearerAuthToObject(localVarHeaderParameter, configuration);
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(refreshTokenRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Creates a new user account. Sends a verification email upon successful registration.
+     * @summary Register a new user
+     * @param {RegisterRequest} registerRequest User register credentials
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    register: async (registerRequest, options = {}) => {
+      assertParamExists("register", "registerRequest", registerRequest);
+      const localVarPath = `/auth/register`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(registerRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Validates the reset token from the email link and renders the password reset form.
+     * @summary Render password reset form
+     * @param {TokenQuery} token Password reset token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    renderResetForm: async (token, options = {}) => {
+      assertParamExists("renderResetForm", "token", token);
+      const localVarPath = `/auth/password/reset`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      if (token !== void 0) {
+        for (const [key, value] of Object.entries(token)) {
+          localVarQueryParameter[key] = value;
+        }
+      }
+      localVarHeaderParameter["Accept"] = "text/html,application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Sends a password reset link to the provided email address if an account exists.
+     * @summary Request a password reset
+     * @param {EmailRequest} emailRequest Email address to send the reset link to
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    requestPasswordReset: async (emailRequest, options = {}) => {
+      assertParamExists("requestPasswordReset", "emailRequest", emailRequest);
+      const localVarPath = `/auth/password/forgot`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(emailRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    },
+    /**
+     * Submits a new password using a valid reset token. Invalidates the token after use.
+     * @summary Submit new password
+     * @param {ResetPasswordRequest} resetPasswordRequest Reset token and the new password
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    submitNewPassword: async (resetPasswordRequest, options = {}) => {
+      assertParamExists("submitNewPassword", "resetPasswordRequest", resetPasswordRequest);
+      const localVarPath = `/auth/password/reset`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      localVarHeaderParameter["Content-Type"] = "application/json";
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      localVarRequestOptions.data = serializeDataIfNeeded(resetPasswordRequest, localVarRequestOptions, configuration);
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    }
+  };
+};
+var AuthApiFp = function(configuration) {
+  const localVarAxiosParamCreator = AuthApiAxiosParamCreator(configuration);
+  return {
+    /**
+     * Returns the currently authenticated user\'s session data. Requires a valid Bearer token.
+     * @summary Get current session
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async getSession(options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.getSession(options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.getSession"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Authenticates a user with email and password. Returns an access token and refresh token on success.
+     * @summary User login
+     * @param {LoginRequest} loginRequest User login credentials
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async login(loginRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.login(loginRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.login"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Invalidates the current session and refresh token. The client should discard stored tokens.
+     * @summary Logout
+     * @param {RefreshTokenRequest} refreshTokenRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async logout(refreshTokenRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.logout(refreshTokenRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.logout"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Issues a new access token using a valid refresh token. Rotate refresh tokens on each call.
+     * @summary Refresh access token
+     * @param {RefreshTokenRequest} refreshTokenRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async refreshToken(refreshTokenRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.refreshToken(refreshTokenRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.refreshToken"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Creates a new user account. Sends a verification email upon successful registration.
+     * @summary Register a new user
+     * @param {RegisterRequest} registerRequest User register credentials
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async register(registerRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.register(registerRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.register"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Validates the reset token from the email link and renders the password reset form.
+     * @summary Render password reset form
+     * @param {TokenQuery} token Password reset token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async renderResetForm(token, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.renderResetForm(token, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.renderResetForm"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Sends a password reset link to the provided email address if an account exists.
+     * @summary Request a password reset
+     * @param {EmailRequest} emailRequest Email address to send the reset link to
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async requestPasswordReset(emailRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.requestPasswordReset(emailRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.requestPasswordReset"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Submits a new password using a valid reset token. Invalidates the token after use.
+     * @summary Submit new password
+     * @param {ResetPasswordRequest} resetPasswordRequest Reset token and the new password
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async submitNewPassword(resetPasswordRequest, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.submitNewPassword(resetPasswordRequest, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.submitNewPassword"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios3.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    }
+  };
+};
+var AuthApi = class extends BaseAPI {
+  /**
+   * Returns the currently authenticated user\'s session data. Requires a valid Bearer token.
+   * @summary Get current session
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  getSession(options) {
+    return AuthApiFp(this.configuration).getSession(options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Authenticates a user with email and password. Returns an access token and refresh token on success.
+   * @summary User login
+   * @param {LoginRequest} loginRequest User login credentials
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  login(loginRequest, options) {
+    return AuthApiFp(this.configuration).login(loginRequest, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Invalidates the current session and refresh token. The client should discard stored tokens.
+   * @summary Logout
+   * @param {RefreshTokenRequest} refreshTokenRequest 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  logout(refreshTokenRequest, options) {
+    return AuthApiFp(this.configuration).logout(refreshTokenRequest, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Issues a new access token using a valid refresh token. Rotate refresh tokens on each call.
+   * @summary Refresh access token
+   * @param {RefreshTokenRequest} refreshTokenRequest 
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  refreshToken(refreshTokenRequest, options) {
+    return AuthApiFp(this.configuration).refreshToken(refreshTokenRequest, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Creates a new user account. Sends a verification email upon successful registration.
+   * @summary Register a new user
+   * @param {RegisterRequest} registerRequest User register credentials
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  register(registerRequest, options) {
+    return AuthApiFp(this.configuration).register(registerRequest, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Validates the reset token from the email link and renders the password reset form.
+   * @summary Render password reset form
+   * @param {TokenQuery} token Password reset token
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  renderResetForm(token, options) {
+    return AuthApiFp(this.configuration).renderResetForm(token, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Sends a password reset link to the provided email address if an account exists.
+   * @summary Request a password reset
+   * @param {EmailRequest} emailRequest Email address to send the reset link to
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  requestPasswordReset(emailRequest, options) {
+    return AuthApiFp(this.configuration).requestPasswordReset(emailRequest, options).then((request) => request(this.axios, this.basePath));
+  }
+  /**
+   * Submits a new password using a valid reset token. Invalidates the token after use.
+   * @summary Submit new password
+   * @param {ResetPasswordRequest} resetPasswordRequest Reset token and the new password
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  submitNewPassword(resetPasswordRequest, options) {
+    return AuthApiFp(this.configuration).submitNewPassword(resetPasswordRequest, options).then((request) => request(this.axios, this.basePath));
+  }
+};
+
+// src/generated/api/email-api.ts
+var import_axios4 = __toESM(require("axios"), 1);
+var EmailApiAxiosParamCreator = function(configuration) {
+  return {
+    /**
+     * Validates the email token and update the user account.
+     * @summary Verify user email
+     * @param {TokenQuery} token Email Verification Token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    verifyEmail: async (token, options = {}) => {
+      assertParamExists("verifyEmail", "token", token);
+      const localVarPath = `/email`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      if (token !== void 0) {
+        for (const [key, value] of Object.entries(token)) {
+          localVarQueryParameter[key] = value;
+        }
+      }
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    }
+  };
+};
+var EmailApiFp = function(configuration) {
+  const localVarAxiosParamCreator = EmailApiAxiosParamCreator(configuration);
+  return {
+    /**
+     * Validates the email token and update the user account.
+     * @summary Verify user email
+     * @param {TokenQuery} token Email Verification Token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async verifyEmail(token, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.verifyEmail(token, options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["EmailApi.verifyEmail"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios4.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    }
+  };
+};
+var EmailApi = class extends BaseAPI {
+  /**
+   * Validates the email token and update the user account.
+   * @summary Verify user email
+   * @param {TokenQuery} token Email Verification Token
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  verifyEmail(token, options) {
+    return EmailApiFp(this.configuration).verifyEmail(token, options).then((request) => request(this.axios, this.basePath));
+  }
+};
+
+// src/generated/api/users-api.ts
+var import_axios5 = __toESM(require("axios"), 1);
+var UsersApiAxiosParamCreator = function(configuration) {
+  return {
+    /**
+     * Returns the currently authenticated user\'s data. Requires a valid Bearer token.
+     * @summary Get current User
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    findUser: async (options = {}) => {
+      const localVarPath = `/user`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
+      }
+      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
+      const localVarHeaderParameter = {};
+      const localVarQueryParameter = {};
+      await setBearerAuthToObject(localVarHeaderParameter, configuration);
+      localVarHeaderParameter["Accept"] = "application/json";
+      setSearchParams(localVarUrlObj, localVarQueryParameter);
+      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+      return {
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
+      };
+    }
+  };
+};
+var UsersApiFp = function(configuration) {
+  const localVarAxiosParamCreator = UsersApiAxiosParamCreator(configuration);
+  return {
+    /**
+     * Returns the currently authenticated user\'s data. Requires a valid Bearer token.
+     * @summary Get current User
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async findUser(options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.findUser(options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["UsersApi.findUser"]?.[localVarOperationServerIndex]?.url;
+      return (axios3, basePath) => createRequestFunction(localVarAxiosArgs, import_axios5.default, BASE_PATH, configuration)(axios3, localVarOperationServerBasePath || basePath);
+    }
+  };
+};
+var UsersApi = class extends BaseAPI {
+  /**
+   * Returns the currently authenticated user\'s data. Requires a valid Bearer token.
+   * @summary Get current User
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  findUser(options) {
+    return UsersApiFp(this.configuration).findUser(options).then((request) => request(this.axios, this.basePath));
+  }
+};
+
+// src/generated/configuration.ts
+var Configuration = class {
+  /**
+   * parameter for apiKey security
+   * @param name security name
+   */
+  apiKey;
+  /**
+   * parameter for basic security
+   */
+  username;
+  /**
+   * parameter for basic security
+   */
+  password;
+  /**
+   * parameter for oauth2 security
+   * @param name security name
+   * @param scopes oauth2 scope
+   */
+  accessToken;
+  /**
+   * parameter for aws4 signature security
+   * @param {Object} AWS4Signature - AWS4 Signature security
+   * @param {string} options.region - aws region
+   * @param {string} options.service - name of the service.
+   * @param {string} credentials.accessKeyId - aws access key id
+   * @param {string} credentials.secretAccessKey - aws access key
+   * @param {string} credentials.sessionToken - aws session token
+   * @memberof Configuration
+   */
+  awsv4;
+  /**
+   * override base path
+   */
+  basePath;
+  /**
+   * override server index
+   */
+  serverIndex;
+  /**
+   * base options for axios calls
+   */
+  baseOptions;
+  /**
+   * The FormData constructor that will be used to create multipart form data
+   * requests. You can inject this here so that execution environments that
+   * do not support the FormData class can still run the generated client.
+   *
+   * @type {new () => FormData}
+   */
+  formDataCtor;
+  constructor(param = {}) {
+    this.apiKey = param.apiKey;
+    this.username = param.username;
+    this.password = param.password;
+    this.accessToken = param.accessToken;
+    this.awsv4 = param.awsv4;
+    this.basePath = param.basePath;
+    this.serverIndex = param.serverIndex;
+    this.baseOptions = {
+      ...param.baseOptions,
+      headers: {
+        ...param.baseOptions?.headers
+      }
+    };
+    this.formDataCtor = param.formDataCtor;
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    const jsonMime = new RegExp("^(application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(;.*)?$", "i");
+    return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === "application/json-patch+json");
+  }
+};
+
+// src/index.ts
+var DEFAULT_OPTIONS = {
+  storage: new MemoryStorage()
+};
+var Anzar = class {
+  Auth;
+  User;
+  Email;
+  constructor(anzarConfig, options = DEFAULT_OPTIONS) {
+    const basePath = anzarConfig.api_url;
+    const axiosInstance = this.createAxiosInstance(basePath);
+    const configuration = new Configuration({ basePath });
+    if (anzarConfig.auth?.strategy === "Jwt" /* Jwt */) {
+      new JwtInterceptor().apply(axiosInstance, options);
+    }
+    const apis = this.createApis(configuration, basePath, axiosInstance);
+    this.Auth = new AuthModule(
+      apis.auth,
+      apis.user,
+      anzarConfig.auth?.strategy ?? "Session" /* Session */,
+      options
+    );
+    this.User = apis.user;
+    this.Email = apis.email;
+    const originalFetch = window.fetch;
+    window.fetch = async (url, _options = {}) => {
+      const accessToken = options.storage.getToken();
+      if (!accessToken) return originalFetch(url, _options);
+      return originalFetch(url, {
+        ..._options,
+        headers: {
+          ..._options.headers,
+          Authorization: `Bearer ${accessToken}`
+        }
+      });
+    };
+  }
+  createAxiosInstance(baseURL) {
+    return import_axios6.default.create({
+      baseURL,
+      withCredentials: true,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    });
+  }
+  createApis(configuration, basePath, axiosInstance) {
+    return {
+      auth: new AuthApi(configuration, basePath, axiosInstance),
+      user: new UsersApi(configuration, basePath, axiosInstance),
+      email: new EmailApi(configuration, basePath, axiosInstance)
+    };
+  }
+};