@openfort/openfort-js 0.6.17 → 0.6.18

package/dist/index.cjs

@@ -0,0 +1,3557 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var hash = require('@ethersproject/hash');
+var globalAxios = require('axios');
+var jose = require('jose');
+var secp256k1 = require('@noble/curves/secp256k1');
+var signingKey = require('@ethersproject/signing-key');
+var bytes = require('@ethersproject/bytes');
+var transactions = require('@ethersproject/transactions');
+
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Openfort API
+ * Complete Openfort API references and guides can be found at: https://openfort.xyz/docs
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: founders@openfort.xyz
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+const BASE_PATH = 'https://api.openfort.xyz'.replace(/\/+$/, '');
+/**
+ *
+ * @export
+ * @class BaseAPI
+ */
+class BaseAPI {
+    basePath;
+    axios;
+    configuration;
+    constructor(configuration, basePath = BASE_PATH, axios = globalAxios) {
+        this.basePath = basePath;
+        this.axios = axios;
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = configuration.basePath || this.basePath;
+        }
+    }
+}
+/**
+ *
+ * @export
+ * @class RequiredError
+ * @extends {Error}
+ */
+class RequiredError extends Error {
+    field;
+    constructor(field, msg) {
+        super(msg);
+        this.field = field;
+        this.name = 'RequiredError';
+    }
+}
+
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Openfort API
+ * Complete Openfort API references and guides can be found at: https://openfort.xyz/docs
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: founders@openfort.xyz
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ */
+const DUMMY_BASE_URL = 'https://example.com';
+/**
+ *
+ * @throws {RequiredError}
+ * @export
+ */
+const assertParamExists = function (functionName, paramName, paramValue) {
+    if (paramValue === null || paramValue === undefined) {
+        throw new RequiredError(paramName, `Required parameter ${paramName} was null or undefined when calling ${functionName}.`);
+    }
+};
+/**
+ *
+ * @export
+ */
+const 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.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);
+        }
+    }
+}
+/**
+ *
+ * @export
+ */
+const setSearchParams = function (url, ...objects) {
+    const searchParams = new URLSearchParams(url.search);
+    setFlattenedQueryParams(searchParams, objects);
+    url.search = searchParams.toString();
+};
+/**
+ *
+ * @export
+ */
+const 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 !== undefined ? value : {})
+        : value || '';
+};
+/**
+ *
+ * @export
+ */
+const toPathString = function (url) {
+    return url.pathname + url.search + url.hash;
+};
+/**
+ *
+ * @export
+ */
+const createRequestFunction = function (axiosArgs, globalAxios, BASE_PATH, configuration) {
+    return (axios = globalAxios, basePath = BASE_PATH) => {
+        const axiosRequestArgs = {
+            ...axiosArgs.options,
+            url: (configuration?.basePath || basePath) + axiosArgs.url,
+        };
+        return axios.request(axiosRequestArgs);
+    };
+};
+
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Openfort API
+ * Complete Openfort API references and guides can be found at: https://openfort.xyz/docs
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: founders@openfort.xyz
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Enum of the supporting OAuth providers.
+ * @export
+ * @enum {string}
+ */
+const OAuthProvider = {
+    Accelbyte: 'accelbyte',
+    Firebase: 'firebase',
+    Google: 'google',
+    Lootlocker: 'lootlocker',
+    Playfab: 'playfab',
+    Custom: 'custom',
+    Oidc: 'oidc',
+    Supabase: 'supabase',
+};
+/**
+ * Enum of the supporting third party auth providers.
+ * @export
+ * @enum {string}
+ */
+const ThirdPartyOAuthProvider = {
+    Accelbyte: 'accelbyte',
+    Firebase: 'firebase',
+    Lootlocker: 'lootlocker',
+    Playfab: 'playfab',
+    Supabase: 'supabase',
+    Custom: 'custom',
+    Oidc: 'oidc',
+};
+/**
+ * Enum of the supporting OAuth providers.
+ * @export
+ * @enum {string}
+ */
+const TokenType = {
+    IdToken: 'idToken',
+    CustomToken: 'customToken',
+};
+/**
+ * AuthenticationApi - axios parameter creator
+ * @export
+ */
+const AuthenticationApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         *
+         * @summary Authenticate player with oauth token.
+         * @param {AuthenticateOAuthRequest} authenticateOAuthRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateOAuth: async (authenticateOAuthRequest, options = {}) => {
+            // verify required parameter 'authenticateOAuthRequest' is not null or undefined
+            assertParamExists('authenticateOAuth', 'authenticateOAuthRequest', authenticateOAuthRequest);
+            const localVarPath = `/iam/v1/oauth/authenticate`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(authenticateOAuthRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Authenticate player with SIWE
+         * @param {SIWEAuthenticateRequest} sIWEAuthenticateRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        authenticateSIWE: async (sIWEAuthenticateRequest, options = {}) => {
+            // verify required parameter 'sIWEAuthenticateRequest' is not null or undefined
+            assertParamExists('authenticateSIWE', 'sIWEAuthenticateRequest', sIWEAuthenticateRequest);
+            const localVarPath = `/iam/v1/siwe/authenticate`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(sIWEAuthenticateRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * The endpoint verifies the token generated by OAuth provider, creates or retrieves a player based on his email, and returns the jwt token for the player together with the player id.
+         * @summary Authorize player with token.
+         * @param {OAuthProvider} provider OAuth provider
+         * @param {OAuthRequest} oAuthRequest
+         * @param {*} [options] Override http request option.
+         * @deprecated
+         * @throws {RequiredError}
+         */
+        authorizeWithOAuthToken: async (provider, oAuthRequest, options = {}) => {
+            // verify required parameter 'provider' is not null or undefined
+            assertParamExists('authorizeWithOAuthToken', 'provider', provider);
+            // verify required parameter 'oAuthRequest' is not null or undefined
+            assertParamExists('authorizeWithOAuthToken', 'oAuthRequest', oAuthRequest);
+            const localVarPath = `/iam/v1/oauth/{provider}/authorize`.replace(`{${'provider'}}`, encodeURIComponent(String(provider)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(oAuthRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get the jwks.json file.  You can use the jwks.json file to verify the signature of a JWT token issued by Openfort Auth.
+         * @summary Get the jwks.json file.
+         * @param {string} publishableKey Specifies the project publishable key (starts with pk_).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getJwks: async (publishableKey, options = {}) => {
+            // verify required parameter 'publishableKey' is not null or undefined
+            assertParamExists('getJwks', 'publishableKey', publishableKey);
+            const localVarPath = `/iam/v1/{publishable_key}/jwks.json`.replace(`{${'publishable_key'}}`, encodeURIComponent(String(publishableKey)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Initialize OAuth.
+         * @param {OAuthInitRequest} oAuthInitRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initOAuth: async (oAuthInitRequest, options = {}) => {
+            // verify required parameter 'oAuthInitRequest' is not null or undefined
+            assertParamExists('initOAuth', 'oAuthInitRequest', oAuthInitRequest);
+            const localVarPath = `/iam/v1/oauth/init`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(oAuthInitRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Create a challenge to link external wallet to the player.
+         * @summary Initialize SIWE.
+         * @param {SIWERequest} sIWERequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        initSIWE: async (sIWERequest, options = {}) => {
+            // verify required parameter 'sIWERequest' is not null or undefined
+            assertParamExists('initSIWE', 'sIWERequest', sIWERequest);
+            const localVarPath = `/iam/v1/siwe/init`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(sIWERequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Link external wallet.
+         * @param {SIWEAuthenticateRequest} sIWEAuthenticateRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        linkSIWE: async (sIWEAuthenticateRequest, options = {}) => {
+            // verify required parameter 'sIWEAuthenticateRequest' is not null or undefined
+            assertParamExists('linkSIWE', 'sIWEAuthenticateRequest', sIWEAuthenticateRequest);
+            const localVarPath = `/iam/v1/siwe/link`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(sIWEAuthenticateRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Authenticate a player based on email and password.
+         * @summary Email and password login.
+         * @param {LoginRequest} loginRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        loginEmailPassword: async (loginRequest, options = {}) => {
+            // verify required parameter 'loginRequest' is not null or undefined
+            assertParamExists('loginEmailPassword', 'loginRequest', loginRequest);
+            const localVarPath = `/iam/v1/password/login`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = '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,
+            };
+        },
+        /**
+         * When using Openfort Auth, the endpoint logs out the player.
+         * @summary Log out a player.
+         * @param {LogoutRequest} logoutRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        logout: async (logoutRequest, options = {}) => {
+            // verify required parameter 'logoutRequest' is not null or undefined
+            assertParamExists('logout', 'logoutRequest', logoutRequest);
+            const localVarPath = `/iam/v1/sessions/logout`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(logoutRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        me: async (options = {}) => {
+            const localVarPath = `/iam/v1/me`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Get or create a new session for the player based on the refresh token.
+         * @summary Refresh or create auth session.
+         * @param {RefreshTokenRequest} refreshTokenRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        refresh: async (refreshTokenRequest, options = {}) => {
+            // verify required parameter 'refreshTokenRequest' is not null or undefined
+            assertParamExists('refresh', 'refreshTokenRequest', refreshTokenRequest);
+            const localVarPath = `/iam/v1/sessions`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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';
+            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,
+            };
+        },
+        /**
+         * Create and authenticate a player based on email and password.
+         * @summary Email and password signup.
+         * @param {SignupRequest} signupRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        signupEmailPassword: async (signupRequest, options = {}) => {
+            // verify required parameter 'signupRequest' is not null or undefined
+            assertParamExists('signupEmailPassword', 'signupRequest', signupRequest);
+            const localVarPath = `/iam/v1/password/signup`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(signupRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Verify oauth token of a third party auth provider.
+         * @param {ThirdPartyOAuthRequest} thirdPartyOAuthRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        thirdParty: async (thirdPartyOAuthRequest, options = {}) => {
+            // verify required parameter 'thirdPartyOAuthRequest' is not null or undefined
+            assertParamExists('thirdParty', 'thirdPartyOAuthRequest', thirdPartyOAuthRequest);
+            const localVarPath = `/iam/v1/oauth/third_party`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(thirdPartyOAuthRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Unlink OAuth account
+         * @param {UnlinkRequest} unlinkRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        unlinkOAuth: async (unlinkRequest, options = {}) => {
+            // verify required parameter 'unlinkRequest' is not null or undefined
+            assertParamExists('unlinkOAuth', 'unlinkRequest', unlinkRequest);
+            const localVarPath = `/iam/v1/oauth/unlink`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(unlinkRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Unlink external wallet.
+         * @param {SIWERequest} sIWERequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        unlinkSIWE: async (sIWERequest, options = {}) => {
+            // verify required parameter 'sIWERequest' is not null or undefined
+            assertParamExists('unlinkSIWE', 'sIWERequest', sIWERequest);
+            const localVarPath = `/iam/v1/siwe/unlink`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(sIWERequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * The endpoint verifies the token generated by OAuth provider and retrieves a corresponding player.
+         * @summary Retrieve player by token.
+         * @param {OAuthProvider} provider OAuth provider
+         * @param {OAuthRequest} oAuthRequest
+         * @param {*} [options] Override http request option.
+         * @deprecated
+         * @throws {RequiredError}
+         */
+        verifyOAuth: async (provider, oAuthRequest, options = {}) => {
+            // verify required parameter 'provider' is not null or undefined
+            assertParamExists('verifyOAuth', 'provider', provider);
+            // verify required parameter 'oAuthRequest' is not null or undefined
+            assertParamExists('verifyOAuth', 'oAuthRequest', oAuthRequest);
+            const localVarPath = `/iam/v1/oauth/{provider}/verify`.replace(`{${'provider'}}`, encodeURIComponent(String(provider)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(oAuthRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * The endpoint verifies the token generated by OAuth provider and retrieves a corresponding player.
+         * @summary Retrieve player by oauth token.
+         * @param {AuthenticateOAuthRequest} authenticateOAuthRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        verifyOAuthToken: async (authenticateOAuthRequest, options = {}) => {
+            // verify required parameter 'authenticateOAuthRequest' is not null or undefined
+            assertParamExists('verifyOAuthToken', 'authenticateOAuthRequest', authenticateOAuthRequest);
+            const localVarPath = `/iam/v1/oauth/verify`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(authenticateOAuthRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * AuthenticationApi - functional programming interface
+ * @export
+ */
+const AuthenticationApiFp = function (configuration) {
+    const localVarAxiosParamCreator = AuthenticationApiAxiosParamCreator(configuration);
+    return {
+        /**
+         *
+         * @summary Authenticate player with oauth token.
+         * @param {AuthenticateOAuthRequest} authenticateOAuthRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authenticateOAuth(authenticateOAuthRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authenticateOAuth(authenticateOAuthRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Authenticate player with SIWE
+         * @param {SIWEAuthenticateRequest} sIWEAuthenticateRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async authenticateSIWE(sIWEAuthenticateRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authenticateSIWE(sIWEAuthenticateRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * The endpoint verifies the token generated by OAuth provider, creates or retrieves a player based on his email, and returns the jwt token for the player together with the player id.
+         * @summary Authorize player with token.
+         * @param {OAuthProvider} provider OAuth provider
+         * @param {OAuthRequest} oAuthRequest
+         * @param {*} [options] Override http request option.
+         * @deprecated
+         * @throws {RequiredError}
+         */
+        async authorizeWithOAuthToken(provider, oAuthRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.authorizeWithOAuthToken(provider, oAuthRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Get the jwks.json file.  You can use the jwks.json file to verify the signature of a JWT token issued by Openfort Auth.
+         * @summary Get the jwks.json file.
+         * @param {string} publishableKey Specifies the project publishable key (starts with pk_).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getJwks(publishableKey, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getJwks(publishableKey, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Initialize OAuth.
+         * @param {OAuthInitRequest} oAuthInitRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async initOAuth(oAuthInitRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.initOAuth(oAuthInitRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Create a challenge to link external wallet to the player.
+         * @summary Initialize SIWE.
+         * @param {SIWERequest} sIWERequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async initSIWE(sIWERequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.initSIWE(sIWERequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Link external wallet.
+         * @param {SIWEAuthenticateRequest} sIWEAuthenticateRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async linkSIWE(sIWEAuthenticateRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.linkSIWE(sIWEAuthenticateRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Authenticate a player based on email and password.
+         * @summary Email and password login.
+         * @param {LoginRequest} loginRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async loginEmailPassword(loginRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.loginEmailPassword(loginRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * When using Openfort Auth, the endpoint logs out the player.
+         * @summary Log out a player.
+         * @param {LogoutRequest} logoutRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async logout(logoutRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.logout(logoutRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async me(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.me(options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Get or create a new session for the player based on the refresh token.
+         * @summary Refresh or create auth session.
+         * @param {RefreshTokenRequest} refreshTokenRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async refresh(refreshTokenRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.refresh(refreshTokenRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Create and authenticate a player based on email and password.
+         * @summary Email and password signup.
+         * @param {SignupRequest} signupRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async signupEmailPassword(signupRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.signupEmailPassword(signupRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Verify oauth token of a third party auth provider.
+         * @param {ThirdPartyOAuthRequest} thirdPartyOAuthRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async thirdParty(thirdPartyOAuthRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.thirdParty(thirdPartyOAuthRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Unlink OAuth account
+         * @param {UnlinkRequest} unlinkRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async unlinkOAuth(unlinkRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.unlinkOAuth(unlinkRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Unlink external wallet.
+         * @param {SIWERequest} sIWERequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async unlinkSIWE(sIWERequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.unlinkSIWE(sIWERequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * The endpoint verifies the token generated by OAuth provider and retrieves a corresponding player.
+         * @summary Retrieve player by token.
+         * @param {OAuthProvider} provider OAuth provider
+         * @param {OAuthRequest} oAuthRequest
+         * @param {*} [options] Override http request option.
+         * @deprecated
+         * @throws {RequiredError}
+         */
+        async verifyOAuth(provider, oAuthRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.verifyOAuth(provider, oAuthRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * The endpoint verifies the token generated by OAuth provider and retrieves a corresponding player.
+         * @summary Retrieve player by oauth token.
+         * @param {AuthenticateOAuthRequest} authenticateOAuthRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async verifyOAuthToken(authenticateOAuthRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.verifyOAuthToken(authenticateOAuthRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+    };
+};
+/**
+ * AuthenticationApi - object-oriented interface
+ * @export
+ * @class AuthenticationApi
+ * @extends {BaseAPI}
+ */
+class AuthenticationApi extends BaseAPI {
+    /**
+     *
+     * @summary Authenticate player with oauth token.
+     * @param {AuthenticateOAuthRequest} authenticateOAuthRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    authenticateOAuth(authenticateOAuthRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .authenticateOAuth(authenticateOAuthRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Authenticate player with SIWE
+     * @param {SIWEAuthenticateRequest} sIWEAuthenticateRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    authenticateSIWE(sIWEAuthenticateRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .authenticateSIWE(sIWEAuthenticateRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * The endpoint verifies the token generated by OAuth provider, creates or retrieves a player based on his email, and returns the jwt token for the player together with the player id.
+     * @summary Authorize player with token.
+     * @param {OAuthProvider} provider OAuth provider
+     * @param {OAuthRequest} oAuthRequest
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    authorizeWithOAuthToken(provider, oAuthRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .authorizeWithOAuthToken(provider, oAuthRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get the jwks.json file.  You can use the jwks.json file to verify the signature of a JWT token issued by Openfort Auth.
+     * @summary Get the jwks.json file.
+     * @param {string} publishableKey Specifies the project publishable key (starts with pk_).
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    getJwks(publishableKey, options) {
+        return AuthenticationApiFp(this.configuration)
+            .getJwks(publishableKey, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Initialize OAuth.
+     * @param {OAuthInitRequest} oAuthInitRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    initOAuth(oAuthInitRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .initOAuth(oAuthInitRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Create a challenge to link external wallet to the player.
+     * @summary Initialize SIWE.
+     * @param {SIWERequest} sIWERequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    initSIWE(sIWERequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .initSIWE(sIWERequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Link external wallet.
+     * @param {SIWEAuthenticateRequest} sIWEAuthenticateRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    linkSIWE(sIWEAuthenticateRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .linkSIWE(sIWEAuthenticateRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Authenticate a player based on email and password.
+     * @summary Email and password login.
+     * @param {LoginRequest} loginRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    loginEmailPassword(loginRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .loginEmailPassword(loginRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * When using Openfort Auth, the endpoint logs out the player.
+     * @summary Log out a player.
+     * @param {LogoutRequest} logoutRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    logout(logoutRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .logout(logoutRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    me(options) {
+        return AuthenticationApiFp(this.configuration)
+            .me(options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Get or create a new session for the player based on the refresh token.
+     * @summary Refresh or create auth session.
+     * @param {RefreshTokenRequest} refreshTokenRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    refresh(refreshTokenRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .refresh(refreshTokenRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Create and authenticate a player based on email and password.
+     * @summary Email and password signup.
+     * @param {SignupRequest} signupRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    signupEmailPassword(signupRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .signupEmailPassword(signupRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Verify oauth token of a third party auth provider.
+     * @param {ThirdPartyOAuthRequest} thirdPartyOAuthRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    thirdParty(thirdPartyOAuthRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .thirdParty(thirdPartyOAuthRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Unlink OAuth account
+     * @param {UnlinkRequest} unlinkRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    unlinkOAuth(unlinkRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .unlinkOAuth(unlinkRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Unlink external wallet.
+     * @param {SIWERequest} sIWERequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    unlinkSIWE(sIWERequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .unlinkSIWE(sIWERequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * The endpoint verifies the token generated by OAuth provider and retrieves a corresponding player.
+     * @summary Retrieve player by token.
+     * @param {OAuthProvider} provider OAuth provider
+     * @param {OAuthRequest} oAuthRequest
+     * @param {*} [options] Override http request option.
+     * @deprecated
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    verifyOAuth(provider, oAuthRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .verifyOAuth(provider, oAuthRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * The endpoint verifies the token generated by OAuth provider and retrieves a corresponding player.
+     * @summary Retrieve player by oauth token.
+     * @param {AuthenticateOAuthRequest} authenticateOAuthRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AuthenticationApi
+     */
+    verifyOAuthToken(authenticateOAuthRequest, options) {
+        return AuthenticationApiFp(this.configuration)
+            .verifyOAuthToken(authenticateOAuthRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * SessionsApi - axios parameter creator
+ * @export
+ */
+const SessionsApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Creates a Session.
+         * @summary Create a session key.
+         * @param {CreateSessionRequest} createSessionRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        createSession: async (createSessionRequest, options = {}) => {
+            // verify required parameter 'createSessionRequest' is not null or undefined
+            assertParamExists('createSession', 'createSessionRequest', createSessionRequest);
+            const localVarPath = `/v1/sessions`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(createSessionRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Returns a list of Sessions.
+         * @summary List session keys of a player.
+         * @param {string} player The player ID (starts with pla_)
+         * @param {number} [limit] Specifies the maximum number of records to return.
+         * @param {number} [skip] Specifies the offset for the first records to return.
+         * @param {SortOrder} [order] Specifies the order in which to sort the results.
+         * @param {Array<SessionResponseExpandable>} [expand] Specifies the fields to expand in the response.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getPlayerSessions: async (player, limit, skip, order, expand, options = {}) => {
+            // verify required parameter 'player' is not null or undefined
+            assertParamExists('getPlayerSessions', 'player', player);
+            const localVarPath = `/v1/sessions`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (limit !== undefined) {
+                localVarQueryParameter['limit'] = limit;
+            }
+            if (skip !== undefined) {
+                localVarQueryParameter['skip'] = skip;
+            }
+            if (order !== undefined) {
+                localVarQueryParameter['order'] = order;
+            }
+            if (player !== undefined) {
+                localVarQueryParameter['player'] = player;
+            }
+            if (expand) {
+                localVarQueryParameter['expand'] = expand;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Retrieves the details of a Session that has previously been created.
+         * @summary Returns a player session by session id
+         * @param {string} id Specifies the unique session ID (starts with ses_).
+         * @param {Array<SessionResponseExpandable>} [expand] Specifies the fields to expand.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getSession: async (id, expand, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('getSession', 'id', id);
+            const localVarPath = `/v1/sessions/{id}`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (expand) {
+                localVarQueryParameter['expand'] = expand;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Revoke the session session key.
+         * @param {RevokeSessionRequest} revokeSessionRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        revokeSession: async (revokeSessionRequest, options = {}) => {
+            // verify required parameter 'revokeSessionRequest' is not null or undefined
+            assertParamExists('revokeSession', 'revokeSessionRequest', revokeSessionRequest);
+            const localVarPath = `/v1/sessions/revoke`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(revokeSessionRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         *
+         * @summary Send signed userOperationHash to create session.
+         * @param {string} id Specifies the unique session ID (starts with ses_).
+         * @param {SignatureRequest} signatureRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        signatureSession: async (id, signatureRequest, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('signatureSession', 'id', id);
+            // verify required parameter 'signatureRequest' is not null or undefined
+            assertParamExists('signatureSession', 'signatureRequest', signatureRequest);
+            const localVarPath = `/v1/sessions/{id}/signature`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(signatureRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * SessionsApi - functional programming interface
+ * @export
+ */
+const SessionsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = SessionsApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * Creates a Session.
+         * @summary Create a session key.
+         * @param {CreateSessionRequest} createSessionRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async createSession(createSessionRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.createSession(createSessionRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Returns a list of Sessions.
+         * @summary List session keys of a player.
+         * @param {string} player The player ID (starts with pla_)
+         * @param {number} [limit] Specifies the maximum number of records to return.
+         * @param {number} [skip] Specifies the offset for the first records to return.
+         * @param {SortOrder} [order] Specifies the order in which to sort the results.
+         * @param {Array<SessionResponseExpandable>} [expand] Specifies the fields to expand in the response.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getPlayerSessions(player, limit, skip, order, expand, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getPlayerSessions(player, limit, skip, order, expand, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Retrieves the details of a Session that has previously been created.
+         * @summary Returns a player session by session id
+         * @param {string} id Specifies the unique session ID (starts with ses_).
+         * @param {Array<SessionResponseExpandable>} [expand] Specifies the fields to expand.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getSession(id, expand, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getSession(id, expand, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Revoke the session session key.
+         * @param {RevokeSessionRequest} revokeSessionRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async revokeSession(revokeSessionRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.revokeSession(revokeSessionRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         *
+         * @summary Send signed userOperationHash to create session.
+         * @param {string} id Specifies the unique session ID (starts with ses_).
+         * @param {SignatureRequest} signatureRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async signatureSession(id, signatureRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.signatureSession(id, signatureRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+    };
+};
+/**
+ * SessionsApi - object-oriented interface
+ * @export
+ * @class SessionsApi
+ * @extends {BaseAPI}
+ */
+class SessionsApi extends BaseAPI {
+    /**
+     * Creates a Session.
+     * @summary Create a session key.
+     * @param {CreateSessionRequest} createSessionRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof SessionsApi
+     */
+    createSession(createSessionRequest, options) {
+        return SessionsApiFp(this.configuration)
+            .createSession(createSessionRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Returns a list of Sessions.
+     * @summary List session keys of a player.
+     * @param {string} player The player ID (starts with pla_)
+     * @param {number} [limit] Specifies the maximum number of records to return.
+     * @param {number} [skip] Specifies the offset for the first records to return.
+     * @param {SortOrder} [order] Specifies the order in which to sort the results.
+     * @param {Array<SessionResponseExpandable>} [expand] Specifies the fields to expand in the response.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof SessionsApi
+     */
+    getPlayerSessions(player, limit, skip, order, expand, options) {
+        return SessionsApiFp(this.configuration)
+            .getPlayerSessions(player, limit, skip, order, expand, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Retrieves the details of a Session that has previously been created.
+     * @summary Returns a player session by session id
+     * @param {string} id Specifies the unique session ID (starts with ses_).
+     * @param {Array<SessionResponseExpandable>} [expand] Specifies the fields to expand.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof SessionsApi
+     */
+    getSession(id, expand, options) {
+        return SessionsApiFp(this.configuration)
+            .getSession(id, expand, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Revoke the session session key.
+     * @param {RevokeSessionRequest} revokeSessionRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof SessionsApi
+     */
+    revokeSession(revokeSessionRequest, options) {
+        return SessionsApiFp(this.configuration)
+            .revokeSession(revokeSessionRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     *
+     * @summary Send signed userOperationHash to create session.
+     * @param {string} id Specifies the unique session ID (starts with ses_).
+     * @param {SignatureRequest} signatureRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof SessionsApi
+     */
+    signatureSession(id, signatureRequest, options) {
+        return SessionsApiFp(this.configuration)
+            .signatureSession(id, signatureRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+/**
+ * TransactionIntentsApi - axios parameter creator
+ * @export
+ */
+const TransactionIntentsApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * Creates a TransactionIntent.  A pending TransactionIntent has the `response` attribute as undefined.  After the TransactionIntent is created and broadcasted to the blockchain, `response` will be populated with the transaction hash and a status (1 success, 0 fail).  When using a non-custodial account, a `nextAction` attribute is returned with the `userOperationHash` that must be signed by the owner of the account.
+         * @summary Create a transaction intent object.
+         * @param {CreateTransactionIntentRequest} createTransactionIntentRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        createTransactionIntent: async (createTransactionIntentRequest, options = {}) => {
+            // verify required parameter 'createTransactionIntentRequest' is not null or undefined
+            assertParamExists('createTransactionIntent', 'createTransactionIntentRequest', createTransactionIntentRequest);
+            const localVarPath = `/v1/transaction_intents`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(createTransactionIntentRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Estimate the gas cost of broadcasting a TransactionIntent.  This is a simulation, it does not send the transaction on-chain.  If a Policy ID is used that includes payment of gas in ERC-20 tokens, an extra field `estimatedTXGasFeeToken` is returned with the estimated amount of tokens that will be used.
+         * @summary Estimate gas cost of creating a transaction
+         * @param {CreateTransactionIntentRequest} createTransactionIntentRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        estimateTransactionIntentCost: async (createTransactionIntentRequest, options = {}) => {
+            // verify required parameter 'createTransactionIntentRequest' is not null or undefined
+            assertParamExists('estimateTransactionIntentCost', 'createTransactionIntentRequest', createTransactionIntentRequest);
+            const localVarPath = `/v1/transaction_intents/estimate_gas_cost`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(createTransactionIntentRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Retrieves the details of a TransactionIntent that has previously been created.
+         * @summary Get a transaction intent object.
+         * @param {string} id Specifies the unique transaction intent ID (starts with tin_).
+         * @param {Array<TransactionIntentResponseExpandable>} [expand] Specifies the expandable fields.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getTransactionIntent: async (id, expand, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('getTransactionIntent', 'id', id);
+            const localVarPath = `/v1/transaction_intents/{id}`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (expand) {
+                localVarQueryParameter['expand'] = expand;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Returns a list of TransactionIntents.
+         * @summary List transaction intents.
+         * @param {number} [limit] Specifies the maximum number of records to return.
+         * @param {number} [skip] Specifies the offset for the first records to return.
+         * @param {SortOrder} [order] Specifies the order in which to sort the results.
+         * @param {Array<TransactionIntentResponseExpandable>} [expand] Specifies the fields to expand in the response.
+         * @param {number} [chainId] The chain ID. Must be a [supported chain](/chains).
+         * @param {Array<string>} [account] Filter by account ID or developer account (starts with acc_ or dac_ respectively).
+         * @param {Array<string>} [player] Filter by player ID (starts with pla_).
+         * @param {number} [status] Filter by successful (1) or failed (0) transaction intents.
+         * @param {Array<string>} [policy] Filter by policy ID (starts with pol_).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getTransactionIntents: async (limit, skip, order, expand, chainId, account, player, status, policy, options = {}) => {
+            const localVarPath = `/v1/transaction_intents`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            if (limit !== undefined) {
+                localVarQueryParameter['limit'] = limit;
+            }
+            if (skip !== undefined) {
+                localVarQueryParameter['skip'] = skip;
+            }
+            if (order !== undefined) {
+                localVarQueryParameter['order'] = order;
+            }
+            if (expand) {
+                localVarQueryParameter['expand'] = expand;
+            }
+            if (chainId !== undefined) {
+                localVarQueryParameter['chainId'] = chainId;
+            }
+            if (account) {
+                localVarQueryParameter['account'] = account;
+            }
+            if (player) {
+                localVarQueryParameter['player'] = player;
+            }
+            if (status !== undefined) {
+                localVarQueryParameter['status'] = status;
+            }
+            if (policy) {
+                localVarQueryParameter['policy'] = policy;
+            }
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Broadcasts a signed TransactionIntent to the blockchain.  Use this endpoint to send the signed `userOperationHash`. Openfort will then put it on-chain.
+         * @summary Send a signed transaction userOperationHash.
+         * @param {string} id Specifies the unique transaction intent ID (starts with tin_).
+         * @param {SignatureRequest} signatureRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        signature: async (id, signatureRequest, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('signature', 'id', id);
+            // verify required parameter 'signatureRequest' is not null or undefined
+            assertParamExists('signature', 'signatureRequest', signatureRequest);
+            const localVarPath = `/v1/transaction_intents/{id}/signature`.replace(`{${'id'}}`, encodeURIComponent(String(id)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            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 = {};
+            // authentication sk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            // authentication pk required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {
+                ...localVarHeaderParameter,
+                ...headersFromBaseOptions,
+                ...options.headers,
+            };
+            localVarRequestOptions.data = serializeDataIfNeeded(signatureRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+/**
+ * TransactionIntentsApi - functional programming interface
+ * @export
+ */
+const TransactionIntentsApiFp = function (configuration) {
+    const localVarAxiosParamCreator = TransactionIntentsApiAxiosParamCreator(configuration);
+    return {
+        /**
+         * Creates a TransactionIntent.  A pending TransactionIntent has the `response` attribute as undefined.  After the TransactionIntent is created and broadcasted to the blockchain, `response` will be populated with the transaction hash and a status (1 success, 0 fail).  When using a non-custodial account, a `nextAction` attribute is returned with the `userOperationHash` that must be signed by the owner of the account.
+         * @summary Create a transaction intent object.
+         * @param {CreateTransactionIntentRequest} createTransactionIntentRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async createTransactionIntent(createTransactionIntentRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.createTransactionIntent(createTransactionIntentRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Estimate the gas cost of broadcasting a TransactionIntent.  This is a simulation, it does not send the transaction on-chain.  If a Policy ID is used that includes payment of gas in ERC-20 tokens, an extra field `estimatedTXGasFeeToken` is returned with the estimated amount of tokens that will be used.
+         * @summary Estimate gas cost of creating a transaction
+         * @param {CreateTransactionIntentRequest} createTransactionIntentRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async estimateTransactionIntentCost(createTransactionIntentRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.estimateTransactionIntentCost(createTransactionIntentRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Retrieves the details of a TransactionIntent that has previously been created.
+         * @summary Get a transaction intent object.
+         * @param {string} id Specifies the unique transaction intent ID (starts with tin_).
+         * @param {Array<TransactionIntentResponseExpandable>} [expand] Specifies the expandable fields.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getTransactionIntent(id, expand, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTransactionIntent(id, expand, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Returns a list of TransactionIntents.
+         * @summary List transaction intents.
+         * @param {number} [limit] Specifies the maximum number of records to return.
+         * @param {number} [skip] Specifies the offset for the first records to return.
+         * @param {SortOrder} [order] Specifies the order in which to sort the results.
+         * @param {Array<TransactionIntentResponseExpandable>} [expand] Specifies the fields to expand in the response.
+         * @param {number} [chainId] The chain ID. Must be a [supported chain](/chains).
+         * @param {Array<string>} [account] Filter by account ID or developer account (starts with acc_ or dac_ respectively).
+         * @param {Array<string>} [player] Filter by player ID (starts with pla_).
+         * @param {number} [status] Filter by successful (1) or failed (0) transaction intents.
+         * @param {Array<string>} [policy] Filter by policy ID (starts with pol_).
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getTransactionIntents(limit, skip, order, expand, chainId, account, player, status, policy, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getTransactionIntents(limit, skip, order, expand, chainId, account, player, status, policy, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+        /**
+         * Broadcasts a signed TransactionIntent to the blockchain.  Use this endpoint to send the signed `userOperationHash`. Openfort will then put it on-chain.
+         * @summary Send a signed transaction userOperationHash.
+         * @param {string} id Specifies the unique transaction intent ID (starts with tin_).
+         * @param {SignatureRequest} signatureRequest
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async signature(id, signatureRequest, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.signature(id, signatureRequest, options);
+            return createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration);
+        },
+    };
+};
+/**
+ * TransactionIntentsApi - object-oriented interface
+ * @export
+ * @class TransactionIntentsApi
+ * @extends {BaseAPI}
+ */
+class TransactionIntentsApi extends BaseAPI {
+    /**
+     * Creates a TransactionIntent.  A pending TransactionIntent has the `response` attribute as undefined.  After the TransactionIntent is created and broadcasted to the blockchain, `response` will be populated with the transaction hash and a status (1 success, 0 fail).  When using a non-custodial account, a `nextAction` attribute is returned with the `userOperationHash` that must be signed by the owner of the account.
+     * @summary Create a transaction intent object.
+     * @param {CreateTransactionIntentRequest} createTransactionIntentRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionIntentsApi
+     */
+    createTransactionIntent(createTransactionIntentRequest, options) {
+        return TransactionIntentsApiFp(this.configuration)
+            .createTransactionIntent(createTransactionIntentRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Estimate the gas cost of broadcasting a TransactionIntent.  This is a simulation, it does not send the transaction on-chain.  If a Policy ID is used that includes payment of gas in ERC-20 tokens, an extra field `estimatedTXGasFeeToken` is returned with the estimated amount of tokens that will be used.
+     * @summary Estimate gas cost of creating a transaction
+     * @param {CreateTransactionIntentRequest} createTransactionIntentRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionIntentsApi
+     */
+    estimateTransactionIntentCost(createTransactionIntentRequest, options) {
+        return TransactionIntentsApiFp(this.configuration)
+            .estimateTransactionIntentCost(createTransactionIntentRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Retrieves the details of a TransactionIntent that has previously been created.
+     * @summary Get a transaction intent object.
+     * @param {string} id Specifies the unique transaction intent ID (starts with tin_).
+     * @param {Array<TransactionIntentResponseExpandable>} [expand] Specifies the expandable fields.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionIntentsApi
+     */
+    getTransactionIntent(id, expand, options) {
+        return TransactionIntentsApiFp(this.configuration)
+            .getTransactionIntent(id, expand, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Returns a list of TransactionIntents.
+     * @summary List transaction intents.
+     * @param {number} [limit] Specifies the maximum number of records to return.
+     * @param {number} [skip] Specifies the offset for the first records to return.
+     * @param {SortOrder} [order] Specifies the order in which to sort the results.
+     * @param {Array<TransactionIntentResponseExpandable>} [expand] Specifies the fields to expand in the response.
+     * @param {number} [chainId] The chain ID. Must be a [supported chain](/chains).
+     * @param {Array<string>} [account] Filter by account ID or developer account (starts with acc_ or dac_ respectively).
+     * @param {Array<string>} [player] Filter by player ID (starts with pla_).
+     * @param {number} [status] Filter by successful (1) or failed (0) transaction intents.
+     * @param {Array<string>} [policy] Filter by policy ID (starts with pol_).
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionIntentsApi
+     */
+    getTransactionIntents(limit, skip, order, expand, chainId, account, player, status, policy, options) {
+        return TransactionIntentsApiFp(this.configuration)
+            .getTransactionIntents(limit, skip, order, expand, chainId, account, player, status, policy, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+    /**
+     * Broadcasts a signed TransactionIntent to the blockchain.  Use this endpoint to send the signed `userOperationHash`. Openfort will then put it on-chain.
+     * @summary Send a signed transaction userOperationHash.
+     * @param {string} id Specifies the unique transaction intent ID (starts with tin_).
+     * @param {SignatureRequest} signatureRequest
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TransactionIntentsApi
+     */
+    signature(id, signatureRequest, options) {
+        return TransactionIntentsApiFp(this.configuration)
+            .signature(id, signatureRequest, options)
+            .then((request) => request(this.axios, this.basePath));
+    }
+}
+
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Openfort API
+ * Complete Openfort API references and guides can be found at: https://openfort.xyz/docs
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: founders@openfort.xyz
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+class Configuration {
+    /**
+     * parameter for apiKey security
+     * @param name security name
+     * @memberof Configuration
+     */
+    apiKey;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    username;
+    /**
+     * parameter for basic security
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    password;
+    /**
+     * parameter for oauth2 security
+     * @param name security name
+     * @param scopes oauth2 scope
+     * @memberof Configuration
+     */
+    accessToken;
+    /**
+     * override base path
+     *
+     * @type {string}
+     * @memberof Configuration
+     */
+    basePath;
+    /**
+     * base options for axios calls
+     *
+     * @type {any}
+     * @memberof Configuration
+     */
+    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.basePath = param.basePath;
+        this.baseOptions = param.baseOptions;
+        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|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return (mime !== null &&
+            (jsonMime.test(mime) ||
+                mime.toLowerCase() === 'application/json-patch+json'));
+    }
+}
+
+var SignerType;
+(function (SignerType) {
+    SignerType["EMBEDDED"] = "embedded";
+    SignerType["SESSION"] = "session";
+})(SignerType || (SignerType = {}));
+
+const isBrowser = () => typeof document !== 'undefined';
+const localStorageWriteTests = {
+    tested: false,
+    writable: false,
+};
+/**
+ * Checks whether localStorage is supported on this browser.
+ */
+const supportsLocalStorage = () => {
+    if (!isBrowser()) {
+        return false;
+    }
+    try {
+        if (typeof globalThis.localStorage !== 'object') {
+            return false;
+        }
+    }
+    catch (e) {
+        // DOM exception when accessing `localStorage`
+        return false;
+    }
+    if (localStorageWriteTests.tested) {
+        return localStorageWriteTests.writable;
+    }
+    const randomKey = `lswt-${Math.random()}${Math.random()}`;
+    try {
+        globalThis.localStorage.setItem(randomKey, randomKey);
+        globalThis.localStorage.removeItem(randomKey);
+        localStorageWriteTests.tested = true;
+        localStorageWriteTests.writable = true;
+    }
+    catch (e) {
+        // localStorage can't be written to
+        // https://www.chromium.org/for-testers/bug-reporting-guidelines/uncaught-securityerror-failed-to-read-the-localstorage-property-from-window-access-is-denied-for-this-document
+        localStorageWriteTests.tested = true;
+        localStorageWriteTests.writable = false;
+    }
+    return localStorageWriteTests.writable;
+};
+
+class OpenfortAuth {
+    static async initOAuth(publishableKey, provider, options) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const result = await oauthApi.initOAuth({ provider, options });
+        if (isBrowser() && !options?.skipBrowserRedirect) {
+            window.location.assign(result.data.url);
+        }
+        return {
+            url: result.data.url,
+            key: result.data.key,
+        };
+    }
+    static async authenticateOAuth(publishableKey, provider, token, tokenType) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const response = await oauthApi.authenticateOAuth({
+            provider,
+            token,
+            tokenType,
+        });
+        return response.data;
+    }
+    static async authenticateThirdParty(publishableKey, provider, token, tokenType) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const response = await oauthApi.thirdParty({
+            provider,
+            token,
+            tokenType,
+        });
+        return response.data;
+    }
+    static async initSIWE(publishableKey, address) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const result = await oauthApi.initSIWE({ address });
+        return {
+            address: result.data.address,
+            nonce: result.data.nonce,
+            expiresAt: result.data.expiresAt,
+        };
+    }
+    static async authenticateSIWE(publishableKey, signature, message, walletClientType, connectorType) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const response = await oauthApi.authenticateSIWE({
+            signature,
+            message,
+            walletClientType,
+            connectorType,
+        });
+        return response.data;
+    }
+    static async loginEmailPassword(publishableKey, email, password) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const response = await oauthApi.loginEmailPassword({ email, password });
+        return response.data;
+    }
+    static async signupEmailPassword(publishableKey, email, password, name) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const response = await oauthApi.signupEmailPassword({
+            name,
+            email,
+            password,
+        });
+        return response.data;
+    }
+    static async getJWK(publishableKey) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        const jwtks = await oauthApi.getJwks(publishableKey);
+        if (jwtks.data.keys.length === 0) {
+            throw new Error('No keys found');
+        }
+        const jwtKey = jwtks.data.keys[0];
+        return {
+            kty: jwtKey.kty,
+            crv: jwtKey.crv,
+            x: jwtKey.x,
+            y: jwtKey.y,
+            alg: jwtKey.alg,
+        };
+    }
+    static async validateCredentials(accessToken, refreshToken, jwk, publishableKey) {
+        try {
+            const key = (await jose.importJWK({
+                kty: jwk.kty,
+                crv: jwk.crv,
+                x: jwk.x,
+                y: jwk.y,
+            }, jwk.alg));
+            const verification = await jose.jwtVerify(accessToken, key);
+            return {
+                player: verification.payload.sub,
+                accessToken,
+                refreshToken,
+            };
+        }
+        catch (error) {
+            if (error instanceof jose.errors.JWTExpired) {
+                const configuration = new Configuration({
+                    accessToken: publishableKey,
+                    baseOptions: { withCredentials: true },
+                });
+                const oauthApi = new AuthenticationApi(configuration);
+                const newToken = await oauthApi.refresh({ refreshToken });
+                return {
+                    player: newToken.data.player.id,
+                    accessToken: newToken.data.token,
+                    refreshToken: newToken.data.refreshToken,
+                };
+            }
+            throw error;
+        }
+    }
+    static async logout(publishableKey, accessToken, refreshToken) {
+        const oauthApi = new AuthenticationApi(new Configuration({ accessToken: publishableKey }));
+        await oauthApi.logout({ refreshToken }, {
+            headers: {
+                authorization: `Bearer ${publishableKey}`,
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                'player-token': accessToken,
+            },
+        });
+    }
+}
+
+class LocalStorage {
+    static validateLocalStorage() {
+        if (!supportsLocalStorage()) {
+            throw new Error('Local storage is not available');
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    get(key) {
+        LocalStorage.validateLocalStorage();
+        return localStorage.getItem(key);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    save(key, value) {
+        LocalStorage.validateLocalStorage();
+        localStorage.setItem(key, value);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    remove(key) {
+        LocalStorage.validateLocalStorage();
+        localStorage.removeItem(key);
+    }
+}
+
+class KeyPair extends signingKey.SigningKey {
+    /**
+     * Initialize keypair based on the private key, if it is provided or generate a brand new keypair.
+     * @param privateKey Optional parameter to initialize private key from
+     */
+    constructor(privateKey = secp256k1.secp256k1.utils.randomPrivateKey()) {
+        super(privateKey);
+    }
+    /**
+     * Sign the message with the private key
+     * @param message Message to sign
+     */
+    sign(message) {
+        return bytes.joinSignature(this.signDigest(hash.hashMessage(bytes.arrayify(message))));
+    }
+    /**
+     * Load private key from the storage and generate keypair based on it.
+     */
+    static load(privateKey) {
+        return privateKey ? new KeyPair(bytes.arrayify(privateKey)) : null;
+    }
+    /**
+     * Return the address for the keypair
+     */
+    getPublicKey() {
+        return transactions.computeAddress(this.privateKey);
+    }
+    getPrivateKey() {
+        return this.privateKey;
+    }
+}
+
+class SessionSigner {
+    sessionKey;
+    instanceManager;
+    constructor(instanceManager) {
+        this.instanceManager = instanceManager;
+        this.sessionKey = null;
+    }
+    async sign(message) {
+        if (this.sessionKey === null) {
+            throw new Error('Session key is not loaded.');
+        }
+        return this.sessionKey.sign(message);
+    }
+    async logout() {
+        this.instanceManager.removeSessionKey();
+        this.sessionKey = null;
+    }
+    loadKeys() {
+        if (this.sessionKey) {
+            return this.sessionKey.getPublicKey();
+        }
+        const sessionKey = this.instanceManager.getSessionKey();
+        if (sessionKey === null) {
+            return null;
+        }
+        this.sessionKey = KeyPair.load(sessionKey);
+        if (this.sessionKey === null) {
+            return null;
+        }
+        return this.sessionKey.getPublicKey();
+    }
+    generateKeys() {
+        this.sessionKey = new KeyPair();
+        this.instanceManager.setSessionKey(this.sessionKey.getPrivateKey());
+        return this.sessionKey.getPublicKey();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getSingerType() {
+        return SignerType.SESSION;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    useCredentials() {
+        return false;
+    }
+    // eslint-disable-next-line class-methods-use-this
+    updateAuthentication() {
+        return Promise.resolve();
+    }
+}
+
+var Event;
+(function (Event) {
+    Event["LOADED"] = "loaded";
+    Event["CONFIGURE"] = "configure";
+    Event["CONFIGURED"] = "configured";
+    Event["UPDATE_AUTHENTICATION"] = "update-authentication";
+    Event["AUTHENTICATION_UPDATED"] = "authentication-updated";
+    Event["SIGN"] = "sign";
+    Event["SIGNED"] = "signed";
+    Event["LOGOUT"] = "logout";
+    Event["LOGGED_OUT"] = "logged-out";
+    Event["GET_CURRENT_DEVICE"] = "get-current-device";
+    Event["CURRENT_DEVICE"] = "current-device";
+    Event["PING"] = "ping";
+    Event["PONG"] = "pong";
+})(Event || (Event = {}));
+const NOT_CONFIGURED_ERROR = 'not-configured-error';
+class GetCurrentDeviceRequest {
+    uuid;
+    action = Event.GET_CURRENT_DEVICE;
+    playerID;
+    constructor(uuid, playerId) {
+        this.uuid = uuid;
+        this.playerID = playerId;
+    }
+}
+class PingRequest {
+    uuid;
+    action = Event.PING;
+    constructor(uuid) {
+        this.uuid = uuid;
+    }
+}
+class LogoutRequest {
+    uuid;
+    action = Event.LOGOUT;
+    constructor(uuid) {
+        this.uuid = uuid;
+    }
+}
+class SignRequest {
+    uuid;
+    action = Event.SIGN;
+    message;
+    requireArrayify;
+    requireHash;
+    openfortConfiguration;
+    constructor(uuid, message, requireArrayify, requireHash, openfortConfiguration) {
+        this.uuid = uuid;
+        this.message = message;
+        this.requireArrayify = requireArrayify;
+        this.requireHash = requireHash;
+        this.openfortConfiguration = openfortConfiguration;
+    }
+}
+class ErrorResponse {
+    uuid;
+    success;
+    error;
+    action;
+    version;
+    constructor(uuid, action, error) {
+        this.action = action;
+        this.success = false;
+        this.error = error;
+        this.uuid = uuid;
+        this.version = null;
+    }
+}
+class ConfigureResponse {
+    uuid;
+    success;
+    deviceID;
+    action = Event.CONFIGURED;
+    version;
+    constructor(uuid, deviceID) {
+        this.success = true;
+        this.deviceID = deviceID;
+        this.uuid = uuid;
+        this.version = null;
+    }
+}
+class UpdateAuthenticationResponse {
+    uuid;
+    success;
+    action = Event.AUTHENTICATION_UPDATED;
+    version;
+    constructor(uuid) {
+        this.success = true;
+        this.uuid = uuid;
+        this.version = null;
+    }
+}
+class SignResponse {
+    uuid;
+    success;
+    signature;
+    action = Event.SIGNED;
+    version;
+    constructor(uuid, signature) {
+        this.success = true;
+        this.signature = signature;
+        this.uuid = uuid;
+        this.version = null;
+    }
+}
+class LogoutResponse {
+    uuid;
+    success;
+    action = Event.LOGGED_OUT;
+    constructor(uuid) {
+        this.success = true;
+        this.uuid = uuid;
+    }
+}
+class UpdateAuthenticationRequest {
+    uuid;
+    action = Event.UPDATE_AUTHENTICATION;
+    accessToken;
+    recovery;
+    constructor(uuid, accessToken, recovery) {
+        this.uuid = uuid;
+        this.accessToken = accessToken;
+        this.recovery = recovery;
+    }
+}
+exports.AuthType = void 0;
+(function (AuthType) {
+    AuthType["OPENFORT"] = "openfort";
+    AuthType["CUSTOM"] = "custom";
+})(exports.AuthType || (exports.AuthType = {}));
+
+class MissingRecoveryPasswordError extends Error {
+    constructor() {
+        super('Recovery password is required for this operation');
+    }
+}
+class NoResponseError extends Error {
+    constructor() {
+        super('No response from iframe');
+    }
+}
+class UnknownResponseError extends Error {
+    message;
+    constructor(message) {
+        super(`Unknown response from iframe: ${message}`);
+        this.message = message || '';
+    }
+}
+class InvalidResponseError extends Error {
+    constructor() {
+        super('Invalid response from iframe');
+    }
+}
+class NotConfiguredError extends Error {
+    constructor() {
+        super('Not configured');
+    }
+}
+class IframeClient {
+    iframe;
+    responses = new Map();
+    configuration;
+    constructor(configuration) {
+        if (!document) {
+            throw new Error('must be run in a browser');
+        }
+        this.configuration = configuration;
+        this.configuration.iframeURL = configuration.iframeURL || 'https://iframe.openfort.xyz';
+        window.addEventListener('message', (event) => {
+            if (event.origin === this.configuration.iframeURL) {
+                const { data } = event;
+                if (data.action) {
+                    if (data.action === Event.PONG) {
+                        this.responses.set('FIRST', data);
+                    }
+                    this.responses.set(data.uuid, data);
+                }
+            }
+        });
+        const previousIframe = document.getElementById('openfort-iframe');
+        if (previousIframe) {
+            document.body.removeChild(previousIframe);
+        }
+        this.iframe = document.createElement('iframe');
+        this.iframe.style.display = 'none';
+        this.iframe.id = 'openfort-iframe';
+        document.body.appendChild(this.iframe);
+        this.iframe.src = configuration.iframeURL;
+    }
+    isLoaded() {
+        return this.responses.get('FIRST') !== undefined;
+    }
+    async waitForIframeLoad() {
+        const checkAndPing = async () => {
+            if (!this.isLoaded()) {
+                this.iframe.contentWindow?.postMessage(new PingRequest(this.generateShortUUID()), '*');
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 100);
+                });
+                await checkAndPing();
+            }
+        };
+        await checkAndPing();
+    }
+    responseConstructors = {
+        [Event.CONFIGURED]: ConfigureResponse,
+        [Event.AUTHENTICATION_UPDATED]: UpdateAuthenticationResponse,
+        [Event.SIGNED]: SignResponse,
+        [Event.LOGGED_OUT]: LogoutResponse,
+    };
+    waitForResponse(uuid) {
+        return new Promise((resolve, reject) => {
+            let retries = 0;
+            const interval = setInterval(() => {
+                if (retries > 100) {
+                    clearInterval(interval);
+                    reject(NoResponseError);
+                }
+                retries++;
+                const response = this.responses.get(uuid);
+                if (response) {
+                    clearInterval(interval);
+                    this.responses.delete(uuid);
+                    // @ts-ignore
+                    const responseConstructor = this.responseConstructors[response.action];
+                    if (responseConstructor) {
+                        resolve(response);
+                    }
+                    else if (response instanceof ErrorResponse) {
+                        if (response.error === NOT_CONFIGURED_ERROR) {
+                            reject(new NotConfiguredError());
+                        }
+                        reject(new UnknownResponseError(response.error));
+                    }
+                    else {
+                        reject(new InvalidResponseError());
+                    }
+                }
+            }, 100);
+        });
+    }
+    async configure(password) {
+        await this.waitForIframeLoad();
+        const config = {
+            uuid: this.generateShortUUID(),
+            action: Event.CONFIGURE,
+            chainId: this.configuration.chainId,
+            recovery: this.configuration.recovery,
+            publishableKey: this.configuration.publishableKey,
+            shieldAPIKey: this.configuration.shieldAPIKey,
+            accessToken: this.configuration.accessToken,
+            thirdPartyProvider: this.configuration.thirdPartyProvider,
+            thirdPartyTokenType: this.configuration.thirdPartyTokenType,
+            encryptionKey: password,
+            encryptionPart: this.configuration.encryptionPart,
+            openfortURL: this.configuration.openfortURL,
+            shieldURL: this.configuration.shieldURL,
+        };
+        this.iframe.contentWindow?.postMessage(config, '*');
+        const response = await this.waitForResponse(config.uuid);
+        sessionStorage.setItem('iframe-version', response.version ?? 'undefined');
+        if (response.success) {
+            return response.deviceID;
+        }
+        throw new MissingRecoveryPasswordError();
+    }
+    async sign(message, requireArrayify, requireHash) {
+        await this.waitForIframeLoad();
+        const uuid = this.generateShortUUID();
+        const openfortConfiguration = {
+            openfortURL: this.configuration.openfortURL,
+            publishableKey: this.configuration.publishableKey,
+            thirdPartyProvider: this.configuration.thirdPartyProvider ?? undefined,
+            thirdPartyTokenType: this.configuration.thirdPartyTokenType ?? undefined,
+            token: this.configuration.accessToken ?? undefined,
+        };
+        const request = new SignRequest(uuid, message, requireArrayify, requireHash, openfortConfiguration);
+        this.iframe.contentWindow?.postMessage(request, '*');
+        let response;
+        try {
+            response = await this.waitForResponse(uuid);
+        }
+        catch (e) {
+            if (e instanceof NotConfiguredError) {
+                await this.configure();
+                return this.sign(message, requireArrayify, requireHash);
+            }
+            throw e;
+        }
+        sessionStorage.setItem('iframe-version', response.version ?? 'undefined');
+        return response.signature;
+    }
+    async getCurrentDevice(playerId) {
+        await this.waitForIframeLoad();
+        const uuid = this.generateShortUUID();
+        const request = new GetCurrentDeviceRequest(uuid, playerId);
+        this.iframe.contentWindow?.postMessage(request, '*');
+        let response;
+        try {
+            response = await this.waitForResponse(uuid);
+            sessionStorage.setItem('iframe-version', response.version ?? 'undefined');
+        }
+        catch (e) {
+            throw new NoResponseError();
+        }
+        return response.deviceID;
+    }
+    async logout() {
+        await this.waitForIframeLoad();
+        const uuid = this.generateShortUUID();
+        const request = new LogoutRequest(uuid);
+        this.iframe.contentWindow?.postMessage(request, '*');
+        await this.waitForResponse(uuid);
+    }
+    async updateAuthentication(token) {
+        this.configuration.accessToken = token;
+        await this.waitForIframeLoad();
+        const uuid = this.generateShortUUID();
+        const request = new UpdateAuthenticationRequest(uuid, token);
+        this.iframe.contentWindow?.postMessage(request, '*');
+        try {
+            await this.waitForResponse(uuid);
+        }
+        catch (e) {
+            if (e instanceof NotConfiguredError) {
+                await this.configure();
+                await this.updateAuthentication(token);
+                return;
+            }
+            throw e;
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    generateShortUUID(length = 8) {
+        const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+        let result = '';
+        for (let i = 0; i < length; i++) {
+            result += characters.charAt(Math.floor(Math.random() * characters.length));
+        }
+        return result;
+    }
+}
+
+class EmbeddedSigner {
+    iframeClient;
+    instanceManager;
+    constructor(configuration, instanceManager) {
+        this.instanceManager = instanceManager;
+        this.iframeClient = new IframeClient(configuration);
+    }
+    async logout() {
+        await this.iframeClient.logout();
+        this.instanceManager.removeDeviceID();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    useCredentials() {
+        return true;
+    }
+    async updateAuthentication() {
+        const accessToken = this.instanceManager.getAccessToken();
+        if (!accessToken) {
+            return;
+        }
+        await this.iframeClient.updateAuthentication(accessToken.token);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    getSingerType() {
+        return SignerType.EMBEDDED;
+    }
+    async ensureEmbeddedAccount(recoveryPassword) {
+        let deviceID = this.instanceManager.getDeviceID();
+        const playerID = this.instanceManager.getPlayerID();
+        if (deviceID && !(await this.iframeClient.getCurrentDevice(playerID))) {
+            return deviceID;
+        }
+        deviceID = await this.iframeClient.configure(recoveryPassword);
+        this.instanceManager.setDeviceID(deviceID);
+        return deviceID;
+    }
+    async sign(message, requireArrayify, requireHash) {
+        const loaded = await this.isLoaded();
+        if (!loaded) {
+            throw new Error('Signer is not loaded');
+        }
+        return await this.iframeClient.sign(message, requireArrayify, requireHash);
+    }
+    getDeviceID() {
+        return this.instanceManager.getDeviceID();
+    }
+    async isLoaded() {
+        if (this.instanceManager.getDeviceID()) {
+            return true;
+        }
+        const playerID = this.instanceManager.getPlayerID();
+        const localStorageDevice = await this.iframeClient.getCurrentDevice(playerID);
+        if (localStorageDevice) {
+            this.instanceManager.setDeviceID(localStorageDevice);
+            return true;
+        }
+        return false;
+    }
+    iFrameLoaded() {
+        return this.iframeClient.isLoaded();
+    }
+}
+
+const authTokenStorageKey = 'openfort.auth_token';
+const thirdPartyProviderStorageKey = 'openfort.third_party_provider';
+const thirdPartyProviderTokenTypeStorageKey = 'openfort.third_party_provider_token_type';
+const refreshTokenStorageKey = 'openfort.refresh_token';
+const playerIDStorageKey = 'openfort.player_id';
+const sessionKeyStorageKey = 'openfort.session_key';
+const publishableKeyStorageKey = 'openfort.publishable_key';
+const signerTypeStorageKey = 'openfort.signer_type';
+const jwksStorageKey = 'openfort.jwk';
+const deviceIDStorageKey = 'openfort.device_id';
+
+class InstanceManager {
+    publishableKey = null;
+    authToken = null;
+    refreshToken = null;
+    signerType = null;
+    jwk = null;
+    sessionKey = null;
+    deviceID = null;
+    temporalStorage;
+    persistentStorage;
+    secureStorage;
+    playerId = null;
+    constructor(temporalStorage, persistentStorage, secureStorage) {
+        this.temporalStorage = temporalStorage;
+        this.persistentStorage = persistentStorage;
+        this.secureStorage = secureStorage;
+    }
+    setPublishableKey(publishableKey) {
+        this.publishableKey = publishableKey;
+        this.temporalStorage.save(publishableKeyStorageKey, publishableKey);
+    }
+    getPublishableKey() {
+        if (!this.publishableKey) {
+            this.publishableKey = this.temporalStorage.get(publishableKeyStorageKey);
+        }
+        return this.publishableKey;
+    }
+    removePublishableKey() {
+        this.publishableKey = null;
+        this.temporalStorage.remove(publishableKeyStorageKey);
+    }
+    getAccessToken() {
+        if (!this.authToken) {
+            const token = this.secureStorage.get(authTokenStorageKey);
+            if (token === null)
+                return null; // Early exit if no token is found
+            this.authToken = {
+                token,
+                thirdPartyProvider: this.secureStorage.get(thirdPartyProviderStorageKey),
+                thirdPartyTokenType: this.secureStorage.get(thirdPartyProviderTokenTypeStorageKey),
+            };
+        }
+        return this.authToken;
+    }
+    setAccessToken(accessToken) {
+        this.authToken = accessToken;
+        this.secureStorage.save(authTokenStorageKey, accessToken.token);
+        if (accessToken.thirdPartyProvider) {
+            this.secureStorage.save(thirdPartyProviderStorageKey, accessToken.thirdPartyProvider);
+        }
+        if (accessToken.thirdPartyTokenType) {
+            this.secureStorage.save(thirdPartyProviderTokenTypeStorageKey, accessToken.thirdPartyTokenType);
+        }
+    }
+    removeAccessToken() {
+        this.authToken = null;
+        this.secureStorage.remove(authTokenStorageKey);
+        this.secureStorage.remove(thirdPartyProviderStorageKey);
+        this.secureStorage.remove(thirdPartyProviderTokenTypeStorageKey);
+    }
+    getRefreshToken() {
+        if (!this.refreshToken) {
+            this.refreshToken = this.secureStorage.get(refreshTokenStorageKey);
+        }
+        return this.refreshToken;
+    }
+    setRefreshToken(refreshToken) {
+        this.refreshToken = refreshToken;
+        this.secureStorage.save(refreshTokenStorageKey, refreshToken);
+    }
+    removeRefreshToken() {
+        this.refreshToken = null;
+        this.secureStorage.remove(refreshTokenStorageKey);
+    }
+    setPlayerID(playerID) {
+        this.playerId = playerID;
+        this.persistentStorage.save(playerIDStorageKey, playerID);
+    }
+    getPlayerID() {
+        if (this.playerId === null) {
+            this.playerId = this.persistentStorage.get(playerIDStorageKey);
+        }
+        return this.playerId;
+    }
+    removePlayerID() {
+        this.playerId = null;
+        this.persistentStorage.remove(playerIDStorageKey);
+    }
+    setSignerType(signerType) {
+        this.signerType = signerType;
+        this.temporalStorage.save(signerTypeStorageKey, signerType);
+    }
+    getSignerType() {
+        if (!this.signerType) {
+            this.signerType = this.temporalStorage.get(signerTypeStorageKey);
+        }
+        if (!this.signerType) {
+            if (this.getSessionKey()) {
+                this.signerType = SignerType.SESSION;
+            }
+            else if (this.getDeviceID()) {
+                this.signerType = SignerType.EMBEDDED;
+            }
+        }
+        return this.signerType;
+    }
+    removeSignerType() {
+        this.signerType = null;
+        this.temporalStorage.remove(signerTypeStorageKey);
+    }
+    setJWK(jwk) {
+        this.jwk = jwk;
+        this.temporalStorage.save(jwksStorageKey, InstanceManager.jwkToString(jwk));
+    }
+    static jwkToString(jwk) {
+        return JSON.stringify({
+            kty: jwk.kty,
+            crv: jwk.crv,
+            x: jwk.x,
+            y: jwk.y,
+            alg: jwk.alg,
+        });
+    }
+    static stringToJWK(jwkString) {
+        const json = JSON.parse(jwkString);
+        return {
+            kty: json.kty,
+            crv: json.crv,
+            x: json.x,
+            y: json.y,
+            alg: json.alg,
+        };
+    }
+    async getJWK() {
+        if (!this.jwk) {
+            const jwkString = this.temporalStorage.get(jwksStorageKey);
+            if (jwkString) {
+                this.jwk = InstanceManager.stringToJWK(jwkString);
+            }
+        }
+        if (!this.jwk) {
+            const publishableKey = await this.getPublishableKey();
+            if (publishableKey) {
+                this.jwk = await OpenfortAuth.getJWK(publishableKey);
+            }
+        }
+        return this.jwk;
+    }
+    removeJWK() {
+        this.jwk = null;
+        this.temporalStorage.remove(jwksStorageKey);
+    }
+    getSessionKey() {
+        if (!this.sessionKey) {
+            this.sessionKey = this.persistentStorage.get(sessionKeyStorageKey);
+        }
+        return this.sessionKey;
+    }
+    setSessionKey(sessionKey) {
+        this.sessionKey = sessionKey;
+        this.persistentStorage.save(sessionKeyStorageKey, sessionKey);
+    }
+    removeSessionKey() {
+        this.sessionKey = null;
+        this.persistentStorage.remove(sessionKeyStorageKey);
+    }
+    setDeviceID(deviceID) {
+        this.deviceID = deviceID;
+        this.persistentStorage.save(deviceIDStorageKey, deviceID);
+    }
+    getDeviceID() {
+        if (!this.deviceID) {
+            this.deviceID = this.persistentStorage.get(deviceIDStorageKey);
+        }
+        return this.deviceID;
+    }
+    removeDeviceID() {
+        this.deviceID = null;
+        this.persistentStorage.remove(deviceIDStorageKey);
+    }
+}
+
+class SessionStorage {
+    static validateSessionStorage() {
+        if (!('sessionStorage' in global && !!global.sessionStorage)) {
+            throw new Error('Session storage is not available');
+        }
+    }
+    // eslint-disable-next-line class-methods-use-this
+    get(key) {
+        SessionStorage.validateSessionStorage();
+        return sessionStorage.getItem(key);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    save(key, value) {
+        SessionStorage.validateSessionStorage();
+        sessionStorage.setItem(key, value);
+    }
+    // eslint-disable-next-line class-methods-use-this
+    remove(key) {
+        SessionStorage.validateSessionStorage();
+        sessionStorage.removeItem(key);
+    }
+}
+
+exports.EmbeddedState = void 0;
+(function (EmbeddedState) {
+    EmbeddedState[EmbeddedState["NONE"] = 0] = "NONE";
+    EmbeddedState[EmbeddedState["UNAUTHENTICATED"] = 1] = "UNAUTHENTICATED";
+    EmbeddedState[EmbeddedState["EMBEDDED_SIGNER_NOT_CONFIGURED"] = 2] = "EMBEDDED_SIGNER_NOT_CONFIGURED";
+    EmbeddedState[EmbeddedState["CREATING_ACCOUNT"] = 3] = "CREATING_ACCOUNT";
+    EmbeddedState[EmbeddedState["READY"] = 4] = "READY";
+})(exports.EmbeddedState || (exports.EmbeddedState = {}));
+class NotLoggedIn extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NotLoggedIn';
+        Object.setPrototypeOf(this, NotLoggedIn.prototype);
+    }
+}
+class MissingRecoveryMethod extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MissingRecoveryMethod';
+        Object.setPrototypeOf(this, MissingRecoveryMethod.prototype);
+    }
+}
+class EmbeddedNotConfigured extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EmbeddedNotConfigured';
+        Object.setPrototypeOf(this, EmbeddedNotConfigured.prototype);
+    }
+}
+class NoSignerConfigured extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NoSignerConfigured';
+        Object.setPrototypeOf(this, NoSignerConfigured.prototype);
+    }
+}
+class NothingToSign extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NothingToSign';
+        Object.setPrototypeOf(this, NothingToSign.prototype);
+    }
+}
+class MissingPublishableKey extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MissingPublishableKey';
+        Object.setPrototypeOf(this, MissingPublishableKey.prototype);
+    }
+}
+class Openfort {
+    signer;
+    publishableKey;
+    shieldAPIKey;
+    iframeURL;
+    openfortURL;
+    shieldURL;
+    encryptionPart;
+    instanceManager;
+    constructor(publishableKey, shieldAPIKey = null, encryptionShare = null, iframeURL = 'https://iframe.openfort.xyz', openfortURL = 'https://api.openfort.xyz', shieldURL = 'https://shield.openfort.xyz') {
+        this.instanceManager = new InstanceManager(new SessionStorage(), new LocalStorage(), new LocalStorage());
+        this.iframeURL = iframeURL;
+        this.openfortURL = openfortURL;
+        this.shieldURL = shieldURL;
+        this.publishableKey = publishableKey;
+        this.shieldAPIKey = shieldAPIKey || publishableKey;
+        this.encryptionPart = encryptionShare;
+    }
+    async logout() {
+        await this.flushSigner();
+        if (this.credentialsProvided()) {
+            const accessToken = this.instanceManager.getAccessToken();
+            if (accessToken
+                && accessToken.thirdPartyProvider === undefined
+                && accessToken.thirdPartyTokenType === undefined) {
+                const refreshToken = this.instanceManager.getRefreshToken();
+                if (refreshToken === null) {
+                    console.error('Refresh token is missing; cannot complete logout.');
+                    return; // Optionally handle this case differently
+                }
+                try {
+                    await OpenfortAuth.logout(this.publishableKey, accessToken.token, refreshToken);
+                }
+                catch (e) {
+                    console.error('Error logging out', e);
+                }
+            }
+            this.instanceManager.removeAccessToken();
+            this.instanceManager.removeRefreshToken();
+            this.instanceManager.removePlayerID();
+            this.instanceManager.removeJWK();
+        }
+        this.instanceManager.removePublishableKey();
+    }
+    async flushSigner() {
+        if (this.signer) {
+            await this.signer.logout();
+            this.instanceManager.removeSignerType();
+            return;
+        }
+        const signerType = this.instanceManager.getSignerType();
+        switch (signerType) {
+            case SignerType.EMBEDDED: {
+                this.recoverPublishableKey();
+                const iframeConfiguration = this.createIFrameConfiguration();
+                const embeddedSigner = new EmbeddedSigner(iframeConfiguration, this.instanceManager);
+                await embeddedSigner.logout();
+                break;
+            }
+            case SignerType.SESSION:
+                this.configureSessionKey();
+                break;
+        }
+        this.instanceManager.removeSignerType();
+    }
+    createIFrameConfiguration() {
+        return {
+            accessToken: this.instanceManager.getAccessToken()?.token ?? null,
+            thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
+            thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
+            chainId: 0, // Default value, consider making this configurable or ensuring it's properly set
+            iframeURL: this.iframeURL,
+            openfortURL: this.openfortURL,
+            publishableKey: this.publishableKey,
+            recovery: null, // No recovery process implemented here, consider adding
+            shieldAPIKey: this.shieldAPIKey,
+            shieldURL: this.shieldURL,
+            encryptionPart: this.encryptionPart,
+        };
+    }
+    recoverPublishableKey() {
+        if (!this.publishableKey) {
+            const key = this.instanceManager.getPublishableKey();
+            if (!key) {
+                throw new MissingPublishableKey('Publishable key must be provided');
+            }
+            this.publishableKey = key;
+        }
+        this.instanceManager.setPublishableKey(this.publishableKey);
+    }
+    configureSessionKey() {
+        const signer = new SessionSigner(this.instanceManager);
+        this.signer = signer;
+        const publicKey = signer.loadKeys();
+        if (!publicKey) {
+            const newPublicKey = signer.generateKeys();
+            return { address: newPublicKey, isRegistered: false };
+        }
+        this.instanceManager.setSignerType(SignerType.SESSION);
+        return { address: publicKey, isRegistered: true };
+    }
+    async configureEmbeddedSigner(chainID, shieldAuthentication) {
+        const signer = this.newEmbeddedSigner(chainID, shieldAuthentication);
+        try {
+            await signer.ensureEmbeddedAccount();
+        }
+        catch (e) {
+            if (e instanceof MissingRecoveryPasswordError) {
+                throw new MissingRecoveryMethod('This device has not been configured, to recover or create your account provide recovery method.');
+            }
+        }
+        this.signer = signer;
+        this.instanceManager.setSignerType(SignerType.EMBEDDED);
+    }
+    newEmbeddedSigner(chainID, shieldAuthentication) {
+        if (!this.credentialsProvided()) {
+            throw new NotLoggedIn('Must be logged in to configure embedded signer');
+        }
+        this.recoverPublishableKey();
+        const iframeConfiguration = {
+            accessToken: this.instanceManager.getAccessToken()?.token ?? null,
+            thirdPartyProvider: this.instanceManager.getAccessToken()?.thirdPartyProvider ?? null,
+            thirdPartyTokenType: this.instanceManager.getAccessToken()?.thirdPartyTokenType ?? null,
+            chainId: chainID,
+            iframeURL: this.iframeURL,
+            openfortURL: this.openfortURL,
+            publishableKey: this.publishableKey,
+            recovery: shieldAuthentication ?? null,
+            shieldAPIKey: this.shieldAPIKey,
+            shieldURL: this.shieldURL,
+            encryptionPart: this.encryptionPart,
+        };
+        return new EmbeddedSigner(iframeConfiguration, this.instanceManager);
+    }
+    async configureEmbeddedSignerRecovery(chainID, shieldAuthentication, recoveryPassword) {
+        const signer = this.newEmbeddedSigner(chainID, shieldAuthentication);
+        await this.validateAndRefreshToken();
+        await signer.ensureEmbeddedAccount(recoveryPassword);
+        this.signer = signer;
+        this.instanceManager.setSignerType(SignerType.EMBEDDED);
+    }
+    async loginWithEmailPassword(email, password) {
+        this.recoverPublishableKey();
+        this.instanceManager.removeAccessToken();
+        this.instanceManager.removeRefreshToken();
+        this.instanceManager.removePlayerID();
+        const result = await OpenfortAuth.loginEmailPassword(this.publishableKey, email, password);
+        this.storeCredentials({
+            player: result.player.id,
+            accessToken: result.token,
+            refreshToken: result.refreshToken,
+        });
+        return result;
+    }
+    async signUpWithEmailPassword(email, password, name) {
+        this.recoverPublishableKey();
+        this.instanceManager.removeAccessToken();
+        this.instanceManager.removeRefreshToken();
+        this.instanceManager.removePlayerID();
+        const result = await OpenfortAuth.signupEmailPassword(this.publishableKey, email, password, name);
+        this.storeCredentials({
+            player: result.player.id,
+            accessToken: result.token,
+            refreshToken: result.refreshToken,
+        });
+        return result;
+    }
+    async initOAuth(provider, options) {
+        this.recoverPublishableKey();
+        return await OpenfortAuth.initOAuth(this.publishableKey, provider, options);
+    }
+    async authenticateWithOAuth(provider, token, tokenType) {
+        this.recoverPublishableKey();
+        this.instanceManager.removeAccessToken();
+        this.instanceManager.removeRefreshToken();
+        this.instanceManager.removePlayerID();
+        const result = await OpenfortAuth.authenticateOAuth(this.publishableKey, provider, token, tokenType);
+        this.storeCredentials({
+            player: result.player.id,
+            accessToken: result.token,
+            refreshToken: result.refreshToken,
+        });
+        return result;
+    }
+    async initSIWE(address) {
+        return await OpenfortAuth.initSIWE(this.publishableKey, address);
+    }
+    async authenticateWithThirdPartyProvider(provider, token, tokenType) {
+        const result = await OpenfortAuth.authenticateThirdParty(this.publishableKey, provider, token, tokenType);
+        this.instanceManager.setAccessToken({
+            token,
+            thirdPartyProvider: provider,
+            thirdPartyTokenType: tokenType,
+        });
+        this.instanceManager.setPlayerID(result.id);
+        if (this.signer && this.signer.useCredentials()) {
+            await this.signer.updateAuthentication();
+        }
+        return result;
+    }
+    async authenticateWithSIWE(signature, message, walletClientType, connectorType) {
+        this.recoverPublishableKey();
+        this.instanceManager.removeAccessToken();
+        this.instanceManager.removeRefreshToken();
+        this.instanceManager.removePlayerID();
+        const result = await OpenfortAuth.authenticateSIWE(this.publishableKey, signature, message, walletClientType, connectorType);
+        this.storeCredentials({
+            player: result.player.id,
+            accessToken: result.token,
+            refreshToken: result.refreshToken,
+        });
+        return result;
+    }
+    storeCredentials(auth) {
+        this.instanceManager.setAccessToken({
+            token: auth.accessToken,
+            thirdPartyProvider: null,
+            thirdPartyTokenType: null,
+        });
+        this.instanceManager.setRefreshToken(auth.refreshToken);
+        this.instanceManager.setPlayerID(auth.player);
+    }
+    async sendSignatureTransactionIntentRequest(transactionIntentId, userOperationHash = null, signature = null) {
+        let newSignature = signature;
+        if (!newSignature) {
+            if (!userOperationHash) {
+                throw new NothingToSign('No userOperationHash or signature provided');
+            }
+            await this.recoverSigner();
+            if (!this.signer) {
+                throw new NoSignerConfigured('In order to sign a transaction intent, a signer must be configured');
+            }
+            if (this.signer.useCredentials()) {
+                await this.validateAndRefreshToken();
+            }
+            newSignature = await this.signer.sign(userOperationHash);
+        }
+        this.recoverPublishableKey();
+        const transactionsApi = new TransactionIntentsApi(new Configuration({ accessToken: this.publishableKey }));
+        const result = await transactionsApi.signature(transactionIntentId, {
+            signature: newSignature,
+        });
+        return result.data;
+    }
+    async signMessage(message) {
+        await this.recoverSigner();
+        if (!this.signer) {
+            throw new NoSignerConfigured('No signer configured');
+        }
+        if (this.signer.useCredentials()) {
+            await this.validateAndRefreshToken();
+        }
+        return await this.signer.sign(message, false, true);
+    }
+    async signTypedData(domain, types, value) {
+        await this.recoverSigner();
+        if (!this.signer) {
+            throw new NoSignerConfigured('No signer configured');
+        }
+        if (this.signer.useCredentials()) {
+            await this.validateAndRefreshToken();
+        }
+        return await this.signer.sign(hash._TypedDataEncoder.hash(domain, types, value), false, false);
+    }
+    async sendRegisterSessionRequest(sessionId, signature, optimistic) {
+        await this.recoverSigner();
+        if (!this.signer) {
+            throw new NoSignerConfigured('No signer configured nor signature provided');
+        }
+        if (this.signer.getSingerType() !== SignerType.SESSION) {
+            throw new NoSignerConfigured('Session signer must be configured to sign a session');
+        }
+        this.recoverPublishableKey();
+        const sessionsApi = new SessionsApi(new Configuration({ accessToken: this.publishableKey }));
+        const result = await sessionsApi.signatureSession(sessionId, {
+            signature,
+            optimistic,
+        });
+        return result.data;
+    }
+    async recoverSigner() {
+        if (this.signer) {
+            return;
+        }
+        const signerType = this.instanceManager.getSignerType();
+        if (signerType === SignerType.EMBEDDED) {
+            await this.configureEmbeddedSigner(80002);
+            return;
+        }
+        if (signerType === SignerType.SESSION) {
+            this.configureSessionKey();
+            return;
+        }
+        await this.waitSigner();
+    }
+    async waitSigner() {
+        const retries = 100;
+        const delay = 100;
+        const checkSignerType = async (attempt) => {
+            if (attempt >= retries) {
+                return;
+            }
+            const signerType = this.instanceManager.getSignerType();
+            if (signerType) {
+                return;
+            }
+            await new Promise((resolve) => {
+                setTimeout(resolve, delay);
+            });
+            await checkSignerType(attempt + 1);
+        };
+        await checkSignerType(0);
+    }
+    getEmbeddedState() {
+        if (!this.credentialsProvided()) {
+            return exports.EmbeddedState.UNAUTHENTICATED;
+        }
+        if (this.instanceManager.getSignerType() !== SignerType.EMBEDDED) {
+            return exports.EmbeddedState.EMBEDDED_SIGNER_NOT_CONFIGURED;
+        }
+        if (!this.signer) {
+            this.signer = this.newEmbeddedSigner(80002);
+        }
+        if (!this.instanceManager.getDeviceID()) {
+            return exports.EmbeddedState.CREATING_ACCOUNT;
+        }
+        return exports.EmbeddedState.READY;
+    }
+    credentialsProvided() {
+        const token = this.instanceManager.getAccessToken();
+        const refreshToken = this.instanceManager.getRefreshToken();
+        return (token
+            && ((token.token && token.thirdPartyProvider && token.thirdPartyTokenType)
+                || (token.token && refreshToken)));
+    }
+    async isAuthenticated() {
+        if (!this.credentialsProvided()) {
+            return false;
+        }
+        if (!this.signer) {
+            const signerType = this.instanceManager.getSignerType();
+            if (signerType !== SignerType.EMBEDDED) {
+                return false;
+            }
+            const signer = this.newEmbeddedSigner(80002);
+            return await signer.isLoaded();
+        }
+        if (this.signer.getSingerType() !== SignerType.EMBEDDED) {
+            return false;
+        }
+        return await this.signer.isLoaded();
+    }
+    getAccessToken() {
+        return this.instanceManager.getAccessToken()?.token ?? null;
+    }
+    isLoaded() {
+        if (!this.instanceManager.getJWK()) {
+            return false;
+        }
+        if (this.signer && this.signer.getSingerType() === SignerType.EMBEDDED) {
+            return this.signer.iFrameLoaded();
+        }
+        return true;
+    }
+    async validateAndRefreshToken() {
+        if (!this.credentialsProvided()) {
+            return;
+        }
+        const accessToken = this.instanceManager.getAccessToken();
+        const refreshToken = this.instanceManager.getRefreshToken();
+        const jwk = await this.instanceManager.getJWK();
+        if (!accessToken || !refreshToken || !jwk) {
+            return;
+        }
+        this.recoverPublishableKey();
+        const auth = await OpenfortAuth.validateCredentials(accessToken.token, refreshToken, jwk, this.publishableKey);
+        if (auth.accessToken !== accessToken.token) {
+            this.storeCredentials(auth);
+        }
+        if (this.signer && this.signer.useCredentials()) {
+            await this.signer.updateAuthentication();
+        }
+    }
+}
+
+exports.EmbeddedNotConfigured = EmbeddedNotConfigured;
+exports.MissingPublishableKey = MissingPublishableKey;
+exports.MissingRecoveryMethod = MissingRecoveryMethod;
+exports.NoSignerConfigured = NoSignerConfigured;
+exports.NotLoggedIn = NotLoggedIn;
+exports.NothingToSign = NothingToSign;
+exports.OAuthProvider = OAuthProvider;
+exports.ThirdPartyOAuthProvider = ThirdPartyOAuthProvider;
+exports.TokenType = TokenType;
+exports.default = Openfort;