@anzar-auth/core 1.5.10

package/dist/index.js

@@ -0,0 +1,934 @@
+// 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, axios = globalAxios) {
+    this.basePath = basePath;
+    this.axios = axios;
+    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 (axios = globalAxios5, basePath = BASE_PATH2) => {
+    const axiosRequestArgs = { ...axiosArgs.options, url: (axios.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
+    return axios.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.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+     * @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 with email and password.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+     * @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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Authenticates a user with email and password.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+     * @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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, 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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, 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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    },
+    /**
+     * Creates a new user account with email and password.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+     * @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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, 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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, 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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, 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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios2, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    }
+  };
+};
+var AuthApiFactory = function(configuration, basePath, axios) {
+  const localVarFp = AuthApiFp(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(options) {
+      return localVarFp.getSession(options).then((request) => request(axios, basePath));
+    },
+    /**
+     * Authenticates a user with email and password.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+     * @summary User login
+     * @param {LoginRequest} loginRequest User login credentials
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    login(loginRequest, options) {
+      return localVarFp.login(loginRequest, options).then((request) => request(axios, 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 localVarFp.logout(refreshTokenRequest, options).then((request) => request(axios, 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 localVarFp.refreshToken(refreshTokenRequest, options).then((request) => request(axios, basePath));
+    },
+    /**
+     * Creates a new user account with email and password.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+     * @summary Register a new user
+     * @param {RegisterRequest} registerRequest User register credentials
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    register(registerRequest, options) {
+      return localVarFp.register(registerRequest, options).then((request) => request(axios, 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 localVarFp.renderResetForm(token, options).then((request) => request(axios, 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 localVarFp.requestPasswordReset(emailRequest, options).then((request) => request(axios, 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 localVarFp.submitNewPassword(resetPasswordRequest, options).then((request) => request(axios, 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.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+   * @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 with email and password.  **Session strategy**: Returns a session cookie (`id`) managed by the server. **JWT strategy**: Returns `access` and `refresh` in the response body.
+   * @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;
+      }
+      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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios3, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    }
+  };
+};
+var EmailApiFactory = function(configuration, basePath, axios) {
+  const localVarFp = EmailApiFp(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(token, options) {
+      return localVarFp.verifyEmail(token, options).then((request) => request(axios, 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
+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;
+      }
+      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 (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios4, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+    }
+  };
+};
+var UsersApiFactory = function(configuration, basePath, axios) {
+  const localVarFp = UsersApiFp(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(options) {
+      return localVarFp.findUser(options).then((request) => request(axios, 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/generated/models/algorithm-config.ts
+var AlgorithmConfig = {
+  Hs256: "HS256",
+  Hs384: "HS384",
+  Hs512: "HS512",
+  Es256: "ES256",
+  Es384: "ES384",
+  Rs256: "RS256",
+  Rs384: "RS384",
+  Rs512: "RS512",
+  Ps256: "PS256",
+  Ps384: "PS384",
+  Ps512: "PS512",
+  EdDsa: "EdDSA"
+};
+
+// src/generated/models/auth-strategy.ts
+var AuthStrategy = {
+  Session: "Session",
+  Jwt: "Jwt"
+};
+
+// src/generated/models/cache-driver.ts
+var CacheDriver = {
+  MemCached: "MemCached",
+  Redis: "Redis"
+};
+
+// src/generated/models/database-driver.ts
+var DatabaseDriver = {
+  SqLite: "SQLite",
+  PostgreSql: "PostgreSQL",
+  MongoDb: "MongoDB"
+};
+
+// src/generated/models/error-code.ts
+var ErrorCode = {
+  InvalidToken: "InvalidToken",
+  TokenNotFound: "TokenNotFound",
+  TokenExpired: "TokenExpired",
+  TokenAlreadyUsed: "TokenAlreadyUsed",
+  TokenCreationFailed: "TokenCreationFailed",
+  TokenRevocationFailed: "TokenRevocationFailed",
+  AccountNotVerified: "AccountNotVerified",
+  InvalidCredentials: "InvalidCredentials",
+  MissingCredentials: "MissingCredentials",
+  AccountSuspended: "AccountSuspended",
+  UserNotFound: "UserNotFound",
+  RateLimitExceeded: "RateLimitExceeded",
+  EmailSendFailed: "EmailSendFailed",
+  TlsConfig: "TlsConfig",
+  HashingFailure: "HashingFailure",
+  MalformedData: "MalformedData",
+  DatabaseError: "DatabaseError",
+  InvalidRequest: "InvalidRequest",
+  UnsupportedMediaType: "UnsupportedMediaType",
+  BadRequest: "BadRequest",
+  InternalServerError: "InternalServerError"
+};
+
+// src/generated/models/role.ts
+var Role = {
+  User: "User",
+  Admin: "Admin"
+};
+
+// src/generated/models/same-site-config.ts
+var SameSiteConfig = {
+  Strict: "Strict",
+  Lax: "Lax",
+  None: "None"
+};
+export {
+  AlgorithmConfig,
+  AuthApi,
+  AuthApiAxiosParamCreator,
+  AuthApiFactory,
+  AuthApiFp,
+  AuthStrategy,
+  CacheDriver,
+  Configuration,
+  DatabaseDriver,
+  EmailApi,
+  EmailApiAxiosParamCreator,
+  EmailApiFactory,
+  EmailApiFp,
+  ErrorCode,
+  Role,
+  SameSiteConfig,
+  UsersApi,
+  UsersApiAxiosParamCreator,
+  UsersApiFactory,
+  UsersApiFp
+};