anzar 1.1.12 → 1.2.6

package/dist/index.js

@@ -1,172 +1,730 @@
 // src/index.ts
 import axios from "axios";
 
-// src/anzar.ts
-var AnzarAuth = class {
-  httpClient;
-  config;
-  constructor(httpClient, config) {
-    this.httpClient = httpClient;
-    this.config = config;
+// src/generated/api/auth-api.ts
+import globalAxios2 from "axios";
+
+// src/generated/base.ts
+import globalAxios from "axios";
+var BASE_PATH = "http://localhost".replace(/\/+$/, "");
+var BaseAPI = class {
+  constructor(configuration, basePath = BASE_PATH, axios2 = globalAxios) {
+    this.basePath = basePath;
+    this.axios = axios2;
+    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}.`);
   }
-  // Auth methods
-  auth = {
-    login: async (email, password) => {
-      const url = "/auth/login";
-      const req = { email, password };
-      const response = await this.httpClient.post(
-        url,
-        req
+};
+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}`)
       );
-      if (response.ok) {
-        return {
-          user: response.data.user,
-          verification: response.data.verification
-        };
+    }
+  } 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 (axios2 = globalAxios5, basePath = BASE_PATH2) => {
+    const axiosRequestArgs = { ...axiosArgs.options, url: (axios2.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
+    return axios2.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;
       }
-      return response.error;
+      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
+      };
     },
-    register: async (username, email, password) => {
-      const url = "/auth/register";
-      const req = { username, email, password };
-      const response = await this.httpClient.post(url, req);
-      if (response.ok) {
-        return {
-          user: response.data.user,
-          verification: response.data.verification
-        };
+    /**
+     * 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;
       }
-      return response.error;
+      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
+      };
     },
-    logout: async () => {
-      const url = "/auth/logout";
-      const response = await this.httpClient.post(url, null);
-      if (response.ok) {
-        localStorage.removeItem(2 /* SessionToken */.toString());
-        localStorage.removeItem(0 /* AccessToken */.toString());
-        localStorage.removeItem(1 /* RefreshToken */.toString());
-        return null;
+    /**
+     * Invalidates the current session and refresh token. The client should discard stored tokens.
+     * @summary Logout
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    logout: async (options = {}) => {
+      const localVarPath = `/auth/logout`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
       }
-      return response.error;
+      const localVarRequestOptions = { method: "POST", ...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
+      };
     },
-    session: async () => {
-      const url = "/user";
-      const user_response = await this.httpClient.get(url);
-      if (!user_response.ok) {
-        return user_response.error;
-      }
-      if (this.config.auth?.strategy === "Jwt" /* Jwt */) {
-        return { user: user_response.data, session: null };
+    /**
+     * Issues a new access token using a valid refresh token. Rotate refresh tokens on each call.
+     * @summary Refresh access token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    refreshToken: async (options = {}) => {
+      const localVarPath = `/auth/refresh-token`;
+      const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+      let baseOptions;
+      if (configuration) {
+        baseOptions = configuration.baseOptions;
       }
-      const url2 = "/auth/session";
-      const session_response = await this.httpClient.get(url2);
-      if (!session_response.ok) {
-        return session_response.error;
+      const localVarRequestOptions = { method: "POST", ...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
+      };
+    },
+    /**
+     * 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 {
-        user: user_response.data,
-        session: session_response.data
+        url: toPathString(localVarUrlObj),
+        options: localVarRequestOptions
       };
     },
-    isLoggedIn: async () => {
-      if (!this.config.auth) {
-        return false;
+    /**
+     * 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;
       }
-      switch (this.config.auth.strategy) {
-        case "Session" /* Session */:
-          return localStorage.getItem(2 /* SessionToken */.toString()) != null;
-        case "Jwt" /* Jwt */:
-          return localStorage.getItem(0 /* AccessToken */.toString()) != null;
-        default:
-          return false;
+      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
+      };
     },
-    resetPassword: async (email) => {
-      const url = "auth/password/forgot";
-      const response = await this.httpClient.post(
-        url,
-        email
-      );
-      if (response.ok) {
-        return response.data;
+    /**
+     * 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;
       }
-      return response.error;
+      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
+      };
     }
   };
-  // User methods
-  // user: {
-  //   getProfile();
-  //   updateProfile();
-  //   // ...
-  // };
 };
-
-// src/types/error.ts
-var internalError = {
-  message: "Something went wrong."
+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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, 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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Invalidates the current session and refresh token. The client should discard stored tokens.
+     * @summary Logout
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async logout(options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.logout(options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.logout"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Issues a new access token using a valid refresh token. Rotate refresh tokens on each call.
+     * @summary Refresh access token
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    async refreshToken(options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.refreshToken(options);
+      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+      const localVarOperationServerBasePath = operationServerMap["AuthApi.refreshToken"]?.[localVarOperationServerIndex]?.url;
+      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, 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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, 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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, 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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, 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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
+    }
+  };
 };
-
-// src/http/client.ts
-var HttpClientImpl = class {
-  axios;
-  constructor(axios2) {
-    this.axios = axios2;
+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 {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  logout(options) {
+    return AuthApiFp(this.configuration).logout(options).then((request) => request(this.axios, this.basePath));
   }
-  async get(url) {
-    try {
-      const response = await this.axios.get(url);
-      if (response.status in [200, 201]) {
-        return { ok: true, data: JSON.parse(response.data) };
+  /**
+   * Issues a new access token using a valid refresh token. Rotate refresh tokens on each call.
+   * @summary Refresh access token
+   * @param {*} [options] Override http request option.
+   * @throws {RequiredError}
+   */
+  refreshToken(options) {
+    return AuthApiFp(this.configuration).refreshToken(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
+import globalAxios3 from "axios";
+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;
       }
-      return { ok: false, error: { message: response.data } };
-    } catch (error) {
-      console.log(error);
-      return { ok: false, error: internalError };
+      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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios3, BASE_PATH, configuration)(axios2, 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));
   }
-  async post(url, obj) {
-    try {
-      const response = await this.axios.post(url, obj);
-      console.log("ANZAR: ", response);
-      if (response.status in [200, 201]) {
-        return { ok: true, data: JSON.parse(response.data) };
+};
+
+// src/generated/api/users-api.ts
+import globalAxios4 from "axios";
+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;
       }
-      return { ok: false, error: { message: response.data } };
-    } catch (error) {
-      console.log(error);
-      return { ok: false, error: internalError };
+      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 (axios2, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios4, BASE_PATH, configuration)(axios2, 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/http/jwt_interceptor.ts
-var ENDPOINTS = /* @__PURE__ */ new Map([
-  ["/auth/login", null],
-  ["/auth/register", null],
-  ["/auth/refreshToken", 1 /* RefreshToken */],
-  ["/auth/logout", 1 /* RefreshToken */]
-]);
-var endpointConfig = {
-  "/auth/login": null,
-  "/auth/register": null,
-  "/auth/refreshToken": 1 /* RefreshToken */,
-  "/auth/logout": 1 /* RefreshToken */
+// 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/http/jwt_interceptor.ts
 var JwtInterceptor = class {
-  // TODO add AnzarConfig as an arg to apply
-  apply(axiosInstance) {
-    function _extractTokenFromCache(tokenType) {
-      const token = localStorage.getItem(tokenType.toString());
-      return token ? { value: token, tokenType } : null;
-    }
+  apply(axiosInstance, options) {
+    const REFRESH_URI = "/auth/refreshToken";
     axiosInstance.interceptors.request.use(
       (config) => {
-        const url = config.url;
-        if (!url) return config;
-        const tokenType = endpointConfig[url] ?? 0 /* AccessToken */;
-        const token = tokenType ? _extractTokenFromCache(tokenType) : null;
-        if (token) {
-          config.headers.Authorization = `Bearer ${token}`;
+        const accessToken = options?.getToken();
+        if (!config.url?.includes(REFRESH_URI) && accessToken) {
+          config.headers.Authorization = `Bearer ${accessToken}`;
         }
         return config;
       },
@@ -176,61 +734,26 @@ var JwtInterceptor = class {
       }
     );
     axiosInstance.interceptors.response.use(
-      (response) => {
-        const url = response.config.url;
-        if (!url) return response;
-        if (url === "/auth/logout") {
-          localStorage.removeItem(0 /* AccessToken */.toString());
-          localStorage.removeItem(1 /* RefreshToken */.toString());
-          return response;
-        }
-        const value = ENDPOINTS.get(url);
-        const token_type = value === void 0 ? 0 /* AccessToken */ : value;
-        if (token_type === 0 /* AccessToken */) {
-          return response;
-        }
-        const auth_response = response.data;
-        if (auth_response.tokens) {
-          localStorage.setItem(
-            0 /* AccessToken */.toString(),
-            auth_response.tokens.access
-          );
-          localStorage.setItem(
-            1 /* RefreshToken */.toString(),
-            auth_response.tokens.refresh
-          );
-        }
-        return response;
-      },
+      (response) => response,
       async (error) => {
         const originalRequest = error.config;
-        if (error.response?.status === 401 && !originalRequest._retry) {
+        if (error.response?.status === 401 && !originalRequest._retry && !originalRequest.url?.includes(REFRESH_URI)) {
           originalRequest._retry = true;
           try {
-            const refreshToken = localStorage.getItem(
-              1 /* RefreshToken */.toString()
-            );
+            const refreshToken = options?.getRefreshToken();
             const response = await axiosInstance.post(
-              "/auth/refreshToken",
+              REFRESH_URI,
               {},
-              { headers: { authorization: `Bearer ${refreshToken}` } }
+              { headers: { "x-refresh-token": `Bearer ${refreshToken}` } }
             );
             const auth_response = response.data;
             if (auth_response.tokens) {
-              localStorage.setItem(
-                0 /* AccessToken */.toString(),
-                auth_response.tokens.access
-              );
-              localStorage.setItem(
-                1 /* RefreshToken */.toString(),
-                auth_response.tokens.refresh
-              );
+              options?.onTokenRefresh?.(auth_response.tokens);
             }
             originalRequest.headers.Authorization = `Bearer ${auth_response.tokens?.access}`;
             return axiosInstance(originalRequest);
           } catch (e) {
-            localStorage.clear();
-            window.location.href = "/";
+            options?.onSessionExpired?.();
             return Promise.reject(e);
           }
         }
@@ -240,59 +763,40 @@ var JwtInterceptor = class {
   }
 };
 
-// src/http/session_interceptor.ts
-var SessionInterceptor = class {
-  apply(axios2) {
-    axios2.interceptors.request.use(
-      (config) => {
-        const session_id = localStorage.getItem(
-          2 /* SessionToken */.toString()
-        );
-        if (session_id) {
-          config.headers.Cookie = `id=${session_id}`;
-        }
-        return config;
-      },
-      (error) => {
-        console.error("Request error:", error);
-        return Promise.reject(error);
-      }
-    );
-    axios2.interceptors.response.use((response) => {
-      if (response.config.url !== "/auth/logout") {
-        localStorage.removeItem(2 /* SessionToken */.toString());
-        return response;
-      }
-      const setCookie = response.headers["set-cookie"];
-      if (setCookie) {
-        const cookie = setCookie.find((c) => c.startsWith("id="));
-        if (cookie) {
-          const sessionID = cookie.split(";")[0].split("=")[1];
-          localStorage.setItem(2 /* SessionToken */.toString(), sessionID);
-        }
-      }
-      return response;
-    });
-  }
-};
-
 // src/index.ts
-function Anzar(config) {
-  const axiosApiInstance = axios.create({
-    // httpAgent: agent,
-    baseURL: config.api_url,
+function Anzar(anzarConfig, options) {
+  const basePath = anzarConfig.api_url;
+  const configuration = new Configuration({ basePath });
+  const axiosInstance = axios.create({
+    baseURL: basePath,
+    withCredentials: true,
     headers: {
       "Content-Type": "application/json",
       Accept: "application/json"
     }
   });
-  if (config.auth) {
-    config.auth.strategy === "Session" /* Session */ ? new SessionInterceptor().apply(axiosApiInstance) : new JwtInterceptor().apply(axiosApiInstance);
-  } else {
-    new JwtInterceptor().apply(axiosApiInstance);
+  if (anzarConfig.auth?.strategy === "Jwt" /* Jwt */) {
+    new JwtInterceptor().apply(axiosInstance, options);
   }
-  const http_client = new HttpClientImpl(axiosApiInstance);
-  return new AnzarAuth(http_client, config);
+  const generatedAuthApi = new AuthApi(configuration, basePath, axiosInstance);
+  return {
+    Auth: {
+      login: (body) => generatedAuthApi.login(body),
+      register: (body) => generatedAuthApi.register(body),
+      logout: async () => {
+        await generatedAuthApi.logout();
+        options?.onLogout?.();
+      },
+      resetPassword: (body) => {
+        generatedAuthApi.requestPasswordReset(body);
+      },
+      ...anzarConfig.auth?.strategy === "Session" /* Session */ && {
+        session: () => generatedAuthApi.getSession()
+      }
+    },
+    User: new UsersApi(configuration, basePath, axiosInstance),
+    Email: new EmailApi(configuration, basePath, axiosInstance)
+  };
 }
 export {
   Anzar