react-guma-auth/dist/esm/react-guma-auth.js

// src/ProviderGuma.tsx
import React2, { useCallback, useEffect, useState } from "react";

// src/AuthService.ts
import { UserManager, WebStorageStateStore } from "oidc-client-ts";
import React from "react";
var AuthService = class {
  constructor(gumaProps) {
    const settings = {
      authority: gumaProps.authority,
      client_id: gumaProps.clientId,
      client_secret: gumaProps.clientSecret,
      redirect_uri: gumaProps.redirectUri,
      silent_redirect_uri: `${gumaProps.redirectUri}silent-renew.html`,
      post_logout_redirect_uri: `${gumaProps.redirectUri}`,
      response_type: "code",
      scope: "openid profile email",
      userStore: new WebStorageStateStore({ store: window.localStorage })
    };
    this._userManager = new UserManager(settings);
    this._userManager.events.addAccessTokenExpired(() => console.log("token expired"));
  }
  async getUser() {
    return await this._userManager.getUser();
  }
  async login(params) {
    return new Promise((resolve) => {
      const { code, state } = params;
      if (!code && !state) {
        this._userManager.signinRedirect().catch((error) => console.error(error));
      } else {
        this._userManager.signinCallback().then((user) => {
          this._userManager.storeUser(user).then(() => this._userManager.clearStaleState()).finally(() => resolve());
        }).catch((error) => {
          console.error(`login error: ${error}`);
        });
      }
    });
  }
  async renewToken() {
    return await this._userManager.signinSilent();
  }
  async logout() {
    return await this._userManager.signoutRedirect();
  }
  async signinCallback() {
    return await this._userManager.signinRedirectCallback();
  }
};
var AuthContext = React.createContext(void 0);

// src/generated-sources/user/runtime.ts
var BASE_PATH = "http://localhost:8102".replace(/\/+$/, "");
var Configuration = class {
  constructor(configuration = {}) {
    this.configuration = configuration;
  }
  set config(configuration) {
    this.configuration = configuration;
  }
  get basePath() {
    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
  }
  get fetchApi() {
    return this.configuration.fetchApi;
  }
  get middleware() {
    return this.configuration.middleware || [];
  }
  get queryParamsStringify() {
    return this.configuration.queryParamsStringify || querystring;
  }
  get username() {
    return this.configuration.username;
  }
  get password() {
    return this.configuration.password;
  }
  get apiKey() {
    const apiKey = this.configuration.apiKey;
    if (apiKey) {
      return typeof apiKey === "function" ? apiKey : () => apiKey;
    }
    return void 0;
  }
  get accessToken() {
    const accessToken = this.configuration.accessToken;
    if (accessToken) {
      return typeof accessToken === "function" ? accessToken : async () => accessToken;
    }
    return void 0;
  }
  get headers() {
    return this.configuration.headers;
  }
  get credentials() {
    return this.configuration.credentials;
  }
};
var DefaultConfig = new Configuration();
var BaseAPI = class {
  constructor(configuration = DefaultConfig) {
    this.configuration = configuration;
    this.fetchApi = async (url, init) => {
      let fetchParams = { url, init };
      for (const middleware of this.middleware) {
        if (middleware.pre) {
          fetchParams = await middleware.pre({
            fetch: this.fetchApi,
            ...fetchParams
          }) || fetchParams;
        }
      }
      let response = void 0;
      try {
        response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
      } catch (e) {
        for (const middleware of this.middleware) {
          if (middleware.onError) {
            response = await middleware.onError({
              fetch: this.fetchApi,
              url: fetchParams.url,
              init: fetchParams.init,
              error: e,
              response: response ? response.clone() : void 0
            }) || response;
          }
        }
        if (response === void 0) {
          if (e instanceof Error) {
            throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
          } else {
            throw e;
          }
        }
      }
      for (const middleware of this.middleware) {
        if (middleware.post) {
          response = await middleware.post({
            fetch: this.fetchApi,
            url: fetchParams.url,
            init: fetchParams.init,
            response: response.clone()
          }) || response;
        }
      }
      return response;
    };
    this.middleware = configuration.middleware;
  }
  withMiddleware(...middlewares) {
    const next = this.clone();
    next.middleware = next.middleware.concat(...middlewares);
    return next;
  }
  withPreMiddleware(...preMiddlewares) {
    const middlewares = preMiddlewares.map((pre) => ({ pre }));
    return this.withMiddleware(...middlewares);
  }
  withPostMiddleware(...postMiddlewares) {
    const middlewares = postMiddlewares.map((post) => ({ post }));
    return this.withMiddleware(...middlewares);
  }
  async request(context, initOverrides) {
    const { url, init } = await this.createFetchParams(context, initOverrides);
    const response = await this.fetchApi(url, init);
    if (response && (response.status >= 200 && response.status < 300)) {
      return response;
    }
    throw new ResponseError(response, "Response returned an error code");
  }
  async createFetchParams(context, initOverrides) {
    let url = this.configuration.basePath + context.path;
    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
      url += "?" + this.configuration.queryParamsStringify(context.query);
    }
    const headers = Object.assign({}, this.configuration.headers, context.headers);
    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
    const initParams = {
      method: context.method,
      headers,
      body: context.body,
      credentials: this.configuration.credentials
    };
    const overridedInit = {
      ...initParams,
      ...await initOverrideFn({
        init: initParams,
        context
      })
    };
    const init = {
      ...overridedInit,
      body: isFormData(overridedInit.body) || overridedInit.body instanceof URLSearchParams || isBlob(overridedInit.body) ? overridedInit.body : JSON.stringify(overridedInit.body)
    };
    return { url, init };
  }
  clone() {
    const constructor = this.constructor;
    const next = new constructor(this.configuration);
    next.middleware = this.middleware.slice();
    return next;
  }
};
function isBlob(value) {
  return typeof Blob !== "undefined" && value instanceof Blob;
}
function isFormData(value) {
  return typeof FormData !== "undefined" && value instanceof FormData;
}
var ResponseError = class extends Error {
  constructor(response, msg) {
    super(msg);
    this.response = response;
    this.name = "ResponseError";
  }
};
var FetchError = class extends Error {
  constructor(cause, msg) {
    super(msg);
    this.cause = cause;
    this.name = "FetchError";
  }
};
var RequiredError = class extends Error {
  constructor(field, msg) {
    super(msg);
    this.field = field;
    this.name = "RequiredError";
  }
};
function exists(json, key) {
  const value = json[key];
  return value !== null && value !== void 0;
}
function querystring(params, prefix = "") {
  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
}
function querystringSingleKey(key, value, keyPrefix = "") {
  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
  if (value instanceof Array) {
    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
    return `${encodeURIComponent(fullKey)}=${multiValue}`;
  }
  if (value instanceof Set) {
    const valueAsArray = Array.from(value);
    return querystringSingleKey(key, valueAsArray, keyPrefix);
  }
  if (value instanceof Date) {
    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
  }
  if (value instanceof Object) {
    return querystring(value, fullKey);
  }
  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
}
var JSONApiResponse = class {
  constructor(raw, transformer = (jsonValue) => jsonValue) {
    this.raw = raw;
    this.transformer = transformer;
  }
  async value() {
    return this.transformer(await this.raw.json());
  }
};

// src/generated-sources/user/models/OrganizationIdDto.ts
function OrganizationIdDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "id": value.id
  };
}

// src/generated-sources/user/models/UserIdDto.ts
function UserIdDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "username": value.username
  };
}

// src/generated-sources/user/models/AddUserDto.ts
function AddUserDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "organizationId": OrganizationIdDtoToJSON(value.organizationId),
    "password": value.password,
    "preferredEmail": value.preferredEmail,
    "temporaryPassword": value.temporaryPassword,
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/AskPasswordUpdateDto.ts
function AskPasswordUpdateDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/BindUserToOauth2ServerDoneDto.ts
function BindUserToOauth2ServerDoneDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "authenticationSystemUserId": value.authenticationSystemUserId,
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/CancelDeleteUserDto.ts
function CancelDeleteUserDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/ConfirmDeleteUserDto.ts
function ConfirmDeleteUserDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/DeleteUserDto.ts
function DeleteUserDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/LanguageResource.ts
function LanguageResourceFromJSON(json) {
  return LanguageResourceFromJSONTyped(json, false);
}
function LanguageResourceFromJSONTyped(json, ignoreDiscriminator) {
  if (json === void 0 || json === null) {
    return json;
  }
  return {
    "code": !exists(json, "code") ? void 0 : json["code"]
  };
}
function LanguageResourceToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "code": value.code
  };
}

// src/generated-sources/user/models/ResetPasswordDto.ts
function ResetPasswordDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "newPassword": value.newPassword,
    "temporary": value.temporary,
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/SetRolesDto.ts
function SetRolesDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "selectedRoles": Array.from(value.selectedRoles),
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/SetUserLanguageDto.ts
function SetUserLanguageDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "languageResource": LanguageResourceToJSON(value.languageResource),
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/UpdateUserInformationsDto.ts
function UpdateUserInformationsDtoToJSON(value) {
  if (value === void 0) {
    return void 0;
  }
  if (value === null) {
    return null;
  }
  return {
    "additionalProperties": value.additionalProperties,
    "firstName": value.firstName,
    "lastName": value.lastName,
    "preferredEmail": value.preferredEmail,
    "userId": UserIdDtoToJSON(value.userId)
  };
}

// src/generated-sources/user/models/UserId.ts
function UserIdFromJSON(json) {
  return UserIdFromJSONTyped(json, false);
}
function UserIdFromJSONTyped(json, ignoreDiscriminator) {
  if (json === void 0 || json === null) {
    return json;
  }
  return {
    "tenant": !exists(json, "tenant") ? void 0 : json["tenant"],
    "username": !exists(json, "username") ? void 0 : json["username"]
  };
}

// src/generated-sources/user/models/UserOperationResponseResource.ts
function UserOperationResponseResourceFromJSON(json) {
  return UserOperationResponseResourceFromJSONTyped(json, false);
}
function UserOperationResponseResourceFromJSONTyped(json, ignoreDiscriminator) {
  if (json === void 0 || json === null) {
    return json;
  }
  return {
    "id": !exists(json, "id") ? void 0 : json["id"]
  };
}

// src/generated-sources/user/models/UserResource.ts
function UserResourceFromJSON(json) {
  return UserResourceFromJSONTyped(json, false);
}
function UserResourceFromJSONTyped(json, ignoreDiscriminator) {
  if (json === void 0 || json === null) {
    return json;
  }
  return {
    "additionalProperties": !exists(json, "additionalProperties") ? void 0 : json["additionalProperties"],
    "authenticationSystemUserId": !exists(json, "authenticationSystemUserId") ? void 0 : json["authenticationSystemUserId"],
    "deleted": !exists(json, "deleted") ? void 0 : json["deleted"],
    "firstName": !exists(json, "firstName") ? void 0 : json["firstName"],
    "id": !exists(json, "id") ? void 0 : json["id"],
    "languageResource": !exists(json, "languageResource") ? void 0 : LanguageResourceFromJSON(json["languageResource"]),
    "lastName": !exists(json, "lastName") ? void 0 : json["lastName"],
    "organizationId": !exists(json, "organizationId") ? void 0 : json["organizationId"],
    "preferredEmail": !exists(json, "preferredEmail") ? void 0 : json["preferredEmail"],
    "username": !exists(json, "username") ? void 0 : json["username"]
  };
}

// src/generated-sources/user/apis/UserApi.ts
var UserApi = class extends BaseAPI {
  async _deleteRaw(requestParameters, initOverrides) {
    if (requestParameters.deleteUserDto === null || requestParameters.deleteUserDto === void 0) {
      throw new RequiredError("deleteUserDto", "Required parameter requestParameters.deleteUserDto was null or undefined when calling _delete.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/delete`,
      method: "POST",
      headers: headerParameters,
      query: queryParameters,
      body: DeleteUserDtoToJSON(requestParameters.deleteUserDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async _delete(requestParameters, initOverrides) {
    const response = await this._deleteRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async addRaw(requestParameters, initOverrides) {
    if (requestParameters.addUserDto === null || requestParameters.addUserDto === void 0) {
      throw new RequiredError("addUserDto", "Required parameter requestParameters.addUserDto was null or undefined when calling add.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/`,
      method: "POST",
      headers: headerParameters,
      query: queryParameters,
      body: AddUserDtoToJSON(requestParameters.addUserDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async add(requestParameters, initOverrides) {
    const response = await this.addRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async bindDoneRaw(requestParameters, initOverrides) {
    if (requestParameters.bindUserToOauth2ServerDoneDto === null || requestParameters.bindUserToOauth2ServerDoneDto === void 0) {
      throw new RequiredError("bindUserToOauth2ServerDoneDto", "Required parameter requestParameters.bindUserToOauth2ServerDoneDto was null or undefined when calling bindDone.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/user/bind-to-auth-server-done`,
      method: "POST",
      headers: headerParameters,
      query: queryParameters,
      body: BindUserToOauth2ServerDoneDtoToJSON(requestParameters.bindUserToOauth2ServerDoneDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async bindDone(requestParameters, initOverrides) {
    const response = await this.bindDoneRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async cancelDeleteRaw(requestParameters, initOverrides) {
    if (requestParameters.cancelDeleteUserDto === null || requestParameters.cancelDeleteUserDto === void 0) {
      throw new RequiredError("cancelDeleteUserDto", "Required parameter requestParameters.cancelDeleteUserDto was null or undefined when calling cancelDelete.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/cancelDelete`,
      method: "POST",
      headers: headerParameters,
      query: queryParameters,
      body: CancelDeleteUserDtoToJSON(requestParameters.cancelDeleteUserDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async cancelDelete(requestParameters, initOverrides) {
    const response = await this.cancelDeleteRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async confirmDeleteRaw(requestParameters, initOverrides) {
    if (requestParameters.confirmDeleteUserDto === null || requestParameters.confirmDeleteUserDto === void 0) {
      throw new RequiredError("confirmDeleteUserDto", "Required parameter requestParameters.confirmDeleteUserDto was null or undefined when calling confirmDelete.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/confirmDelete`,
      method: "POST",
      headers: headerParameters,
      query: queryParameters,
      body: ConfirmDeleteUserDtoToJSON(requestParameters.confirmDeleteUserDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async confirmDelete(requestParameters, initOverrides) {
    const response = await this.confirmDeleteRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async findAll2Raw(requestParameters, initOverrides) {
    const queryParameters = {};
    if (requestParameters.organizationId !== void 0) {
      queryParameters["organizationId"] = requestParameters.organizationId;
    }
    if (requestParameters.showDeleted !== void 0) {
      queryParameters["showDeleted"] = requestParameters.showDeleted;
    }
    const headerParameters = {};
    const response = await this.request({
      path: `/v1/`,
      method: "GET",
      headers: headerParameters,
      query: queryParameters
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => jsonValue.map(UserResourceFromJSON));
  }
  async findAll2(requestParameters = {}, initOverrides) {
    const response = await this.findAll2Raw(requestParameters, initOverrides);
    return await response.value();
  }
  async findOneRaw(requestParameters, initOverrides) {
    if (requestParameters.id === null || requestParameters.id === void 0) {
      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling findOne.");
    }
    const queryParameters = {};
    const headerParameters = {};
    const response = await this.request({
      path: `/v1/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
      method: "GET",
      headers: headerParameters,
      query: queryParameters
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserResourceFromJSON(jsonValue));
  }
  async findOne(requestParameters, initOverrides) {
    const response = await this.findOneRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async resetPasswordRaw(requestParameters, initOverrides) {
    if (requestParameters.resetPasswordDto === null || requestParameters.resetPasswordDto === void 0) {
      throw new RequiredError("resetPasswordDto", "Required parameter requestParameters.resetPasswordDto was null or undefined when calling resetPassword.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/resetPassword`,
      method: "PUT",
      headers: headerParameters,
      query: queryParameters,
      body: ResetPasswordDtoToJSON(requestParameters.resetPasswordDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async resetPassword(requestParameters, initOverrides) {
    const response = await this.resetPasswordRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async saveAllUserRolesRaw(requestParameters, initOverrides) {
    if (requestParameters.id === null || requestParameters.id === void 0) {
      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling saveAllUserRoles.");
    }
    if (requestParameters.setRolesDto === null || requestParameters.setRolesDto === void 0) {
      throw new RequiredError("setRolesDto", "Required parameter requestParameters.setRolesDto was null or undefined when calling saveAllUserRoles.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/roles/user/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
      method: "POST",
      headers: headerParameters,
      query: queryParameters,
      body: SetRolesDtoToJSON(requestParameters.setRolesDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async saveAllUserRoles(requestParameters, initOverrides) {
    const response = await this.saveAllUserRolesRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async setAskPasswordUpdateRaw(requestParameters, initOverrides) {
    if (requestParameters.askPasswordUpdateDto === null || requestParameters.askPasswordUpdateDto === void 0) {
      throw new RequiredError("askPasswordUpdateDto", "Required parameter requestParameters.askPasswordUpdateDto was null or undefined when calling setAskPasswordUpdate.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/askPasswordUpdate`,
      method: "PUT",
      headers: headerParameters,
      query: queryParameters,
      body: AskPasswordUpdateDtoToJSON(requestParameters.askPasswordUpdateDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async setAskPasswordUpdate(requestParameters, initOverrides) {
    const response = await this.setAskPasswordUpdateRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async setUserLanguageRaw(requestParameters, initOverrides) {
    if (requestParameters.setUserLanguageDto === null || requestParameters.setUserLanguageDto === void 0) {
      throw new RequiredError("setUserLanguageDto", "Required parameter requestParameters.setUserLanguageDto was null or undefined when calling setUserLanguage.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/setLanguage`,
      method: "PUT",
      headers: headerParameters,
      query: queryParameters,
      body: SetUserLanguageDtoToJSON(requestParameters.setUserLanguageDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async setUserLanguage(requestParameters, initOverrides) {
    const response = await this.setUserLanguageRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async updateRaw(requestParameters, initOverrides) {
    if (requestParameters.updateUserInformationsDto === null || requestParameters.updateUserInformationsDto === void 0) {
      throw new RequiredError("updateUserInformationsDto", "Required parameter requestParameters.updateUserInformationsDto was null or undefined when calling update.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    headerParameters["Content-Type"] = "application/json";
    const response = await this.request({
      path: `/v1/admin/`,
      method: "PUT",
      headers: headerParameters,
      query: queryParameters,
      body: UpdateUserInformationsDtoToJSON(requestParameters.updateUserInformationsDto)
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserOperationResponseResourceFromJSON(jsonValue));
  }
  async update(requestParameters, initOverrides) {
    const response = await this.updateRaw(requestParameters, initOverrides);
    return await response.value();
  }
  async validateRaw(requestParameters, initOverrides) {
    if (requestParameters.id === null || requestParameters.id === void 0) {
      throw new RequiredError("id", "Required parameter requestParameters.id was null or undefined when calling validate.");
    }
    const queryParameters = {};
    if (requestParameters.async !== void 0) {
      queryParameters["async"] = requestParameters.async;
    }
    const headerParameters = {};
    const response = await this.request({
      path: `/v1/admin/{id}/validate`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
      method: "POST",
      headers: headerParameters,
      query: queryParameters
    }, initOverrides);
    return new JSONApiResponse(response, (jsonValue) => UserIdFromJSON(jsonValue));
  }
  async validate(requestParameters, initOverrides) {
    const response = await this.validateRaw(requestParameters, initOverrides);
    return await response.value();
  }
};

// src/ProviderGuma.tsx
var ProviderGuma = ({ children }) => {
  const [authService, setAuthService] = useState(null);
  const [userService, setUserService] = useState();
  const [isAuthenticated, setIsAuthenticated] = useState(false);
  const init = useCallback((gumaProps) => {
    if (!authService) {
      setAuthService(new AuthService(gumaProps));
      return userService != null ? userService : null;
    }
  }, [authService]);
  useEffect(() => {
    if (!authService)
      return;
    authService.getUser().then(async (user) => {
      if (user) {
        const configuration = new Configuration({
          accessToken: user.access_token,
          basePath: "https://guma-base.client.sw01.faber-app.cloud/user",
          headers: { "Authorization": `Bearer ${user.access_token}` }
        });
        setUserService(new UserApi(configuration));
        setIsAuthenticated(true);
      } else {
        const { searchParams } = new URL(window.location.href);
        const code = searchParams.get("code");
        const state = searchParams.get("state");
        if (code && state) {
          authService.login({ code, state }).then(() => window.location.replace(window.location.origin));
        } else {
          authService.login({});
        }
      }
    });
  }, [authService]);
  return /* @__PURE__ */ React2.createElement(AuthContext.Provider, {
    value: {
      init,
      userService,
      isAuthenticated
    }
  }, children);
};

// src/useGuma.ts
import React3 from "react";
var useGuma = () => {
  const context = React3.useContext(AuthContext);
  if (!context) {
    throw new Error("GumaProvider context is undefined, please verify you are calling useAuth() as child of a <GumaProvider> component.");
  }
  return context;
};
export {
  ProviderGuma,
  useGuma
};
//# sourceMappingURL=react-guma-auth.js.map