@authup/client-web-kit 1.0.0-beta.10 → 1.0.0-beta.13

package/dist/index.cjs

@@ -2,152 +2,1167 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var smob = require('smob');
-var vue = require('vue');
 var coreKit = require('@authup/core-kit');
+var vue = require('vue');
+var coreHttpKit = require('@authup/core-http-kit');
 var kit = require('@authup/kit');
+var smob = require('smob');
 var listControls = require('@vuecs/list-controls');
-var coreHttpKit = require('@authup/core-http-kit');
+var coreRealtimeKit = require('@authup/core-realtime-kit');
 var rapiq = require('rapiq');
 var formControls = require('@vuecs/form-controls');
 var vuelidate = require('@ilingo/vuelidate');
 var validators = require('@vuelidate/validators');
 var useVuelidate = require('@vuelidate/core');
 var pagination = require('@vuecs/pagination');
+var Cookie = require('universal-cookie');
+
+function inject$1(key, instance) {
+    if (instance && instance._context && instance._context.provides && instance._context.provides[key]) {
+        return instance._context.provides[key];
+    }
+    if (vue.hasInjectionContext()) {
+        return vue.inject(key, undefined);
+    }
+    return undefined;
+}
 
-var StoreName;
-(function(StoreName) {
-    StoreName["DEFAULT"] = "default";
-})(StoreName || (StoreName = {}));
-class Store {
+function provide(key, value, app) {
+    if (typeof app === 'undefined') {
+        const val = inject$1(key);
+        if (typeof val !== 'undefined') {
+            return;
+        }
+        vue.provide(key, value);
+        return;
+    }
+    if (app && app._context && app._context.provides && app._context.provides[key]) {
+        return;
+    }
+    app.provide(key, value);
+}
+
+const HTTPClientSymbol = Symbol.for('AuthupHTTPClient');
+function provideHTTPClient(client, app) {
+    provide(HTTPClientSymbol, client, app);
+}
+function hasHTTPClient(app) {
+    return !!inject$1(HTTPClientSymbol, app);
+}
+function injectHTTPClient(app) {
+    const instance = inject$1(HTTPClientSymbol, app);
+    if (!instance) {
+        throw new Error('The api client has not been injected.');
+    }
+    return instance;
+}
+
+var isVue2 = false;
+function set(target, key, val) {
+    if (Array.isArray(target)) {
+        target.length = Math.max(target.length, key);
+        target.splice(key, 1, val);
+        return val;
+    }
+    target[key] = val;
+    return val;
+}
+function del(target, key) {
+    if (Array.isArray(target)) {
+        target.splice(key, 1);
+        return;
+    }
+    delete target[key];
+}
+
+/**
+ * setActivePinia must be called to handle SSR at the top of functions like
+ * `fetch`, `setup`, `serverPrefetch` and others
+ */ let activePinia;
+/**
+ * Sets or unsets the active pinia. Used in SSR and internally when calling
+ * actions and getters
+ *
+ * @param pinia - Pinia instance
+ */ // @ts-expect-error: cannot constrain the type of the return
+const setActivePinia = (pinia)=>activePinia = pinia;
+const piniaSymbol = process.env.NODE_ENV !== 'production' ? Symbol('pinia') : /* istanbul ignore next */ Symbol();
+function isPlainObject(// eslint-disable-next-line @typescript-eslint/no-explicit-any
+o) {
+    return o && typeof o === 'object' && Object.prototype.toString.call(o) === '[object Object]' && typeof o.toJSON !== 'function';
+}
+// type DeepReadonly<T> = { readonly [P in keyof T]: DeepReadonly<T[P]> }
+// TODO: can we change these to numbers?
+/**
+ * Possible types for SubscriptionCallback
+ */ var MutationType;
+(function(MutationType) {
+    /**
+     * Direct mutation of the state:
+     *
+     * - `store.name = 'new name'`
+     * - `store.$state.name = 'new name'`
+     * - `store.list.push('new item')`
+     */ MutationType["direct"] = "direct";
     /**
-     * Set options for all groups.
+     * Mutated the state with `$patch` and an object
      *
-     * @param items
-     */ setAll(items) {
-        const keys = Object.keys(items);
+     * - `store.$patch({ name: 'newName' })`
+     */ MutationType["patchObject"] = "patch object";
+    /**
+     * Mutated the state with `$patch` and a function
+     *
+     * - `store.$patch(state => state.name = 'newName')`
+     */ MutationType["patchFunction"] = "patch function";
+// maybe reset? for $state = {} and $reset
+})(MutationType || (MutationType = {}));
+const IS_CLIENT = typeof window !== 'undefined';
+/**
+ * Should we add the devtools plugins.
+ * - only if dev mode or forced through the prod devtools flag
+ * - not in test
+ * - only if window exists (could change in the future)
+ */ const USE_DEVTOOLS = (process.env.NODE_ENV !== 'production' || typeof __VUE_PROD_DEVTOOLS__ !== 'undefined' && __VUE_PROD_DEVTOOLS__) && !(process.env.NODE_ENV === 'test') && IS_CLIENT;
+/**
+ * Mutates in place `newState` with `oldState` to _hot update_ it. It will
+ * remove any key not existing in `newState` and recursively merge plain
+ * objects.
+ *
+ * @param newState - new state object to be patched
+ * @param oldState - old state that should be used to patch newState
+ * @returns - newState
+ */ function patchObject(newState, oldState) {
+    // no need to go through symbols because they cannot be serialized anyway
+    for(const key in oldState){
+        const subPatch = oldState[key];
+        // skip the whole sub tree
+        if (!(key in newState)) {
+            continue;
+        }
+        const targetValue = newState[key];
+        if (isPlainObject(targetValue) && isPlainObject(subPatch) && !vue.isRef(subPatch) && !vue.isReactive(subPatch)) {
+            newState[key] = patchObject(targetValue, subPatch);
+        } else {
+            // objects are either a bit more complex (e.g. refs) or primitives, so we
+            // just set the whole thing
+            {
+                newState[key] = subPatch;
+            }
+        }
+    }
+    return newState;
+}
+const noop$1 = ()=>{};
+function addSubscription(subscriptions, callback, detached, onCleanup = noop$1) {
+    subscriptions.push(callback);
+    const removeSubscription = ()=>{
+        const idx = subscriptions.indexOf(callback);
+        if (idx > -1) {
+            subscriptions.splice(idx, 1);
+            onCleanup();
+        }
+    };
+    if (!detached && vue.getCurrentScope()) {
+        vue.onScopeDispose(removeSubscription);
+    }
+    return removeSubscription;
+}
+function triggerSubscriptions(subscriptions, ...args) {
+    subscriptions.slice().forEach((callback)=>{
+        callback(...args);
+    });
+}
+const fallbackRunWithContext = (fn)=>fn();
+function mergeReactiveObjects(target, patchToApply) {
+    // Handle Map instances
+    if (target instanceof Map && patchToApply instanceof Map) {
+        patchToApply.forEach((value, key)=>target.set(key, value));
+    }
+    // Handle Set instances
+    if (target instanceof Set && patchToApply instanceof Set) {
+        patchToApply.forEach(target.add, target);
+    }
+    // no need to go through symbols because they cannot be serialized anyway
+    for(const key in patchToApply){
+        if (!patchToApply.hasOwnProperty(key)) continue;
+        const subPatch = patchToApply[key];
+        const targetValue = target[key];
+        if (isPlainObject(targetValue) && isPlainObject(subPatch) && target.hasOwnProperty(key) && !vue.isRef(subPatch) && !vue.isReactive(subPatch)) {
+            // NOTE: here I wanted to warn about inconsistent types but it's not possible because in setup stores one might
+            // start the value of a property as a certain type e.g. a Map, and then for some reason, during SSR, change that
+            // to `undefined`. When trying to hydrate, we want to override the Map with `undefined`.
+            target[key] = mergeReactiveObjects(targetValue, subPatch);
+        } else {
+            // @ts-expect-error: subPatch is a valid value
+            target[key] = subPatch;
+        }
+    }
+    return target;
+}
+const skipHydrateSymbol = process.env.NODE_ENV !== 'production' ? Symbol('pinia:skipHydration') : /* istanbul ignore next */ Symbol();
+/**
+ * Returns whether a value should be hydrated
+ *
+ * @param obj - target variable
+ * @returns true if `obj` should be hydrated
+ */ function shouldHydrate(obj) {
+    return !isPlainObject(obj) || !obj.hasOwnProperty(skipHydrateSymbol);
+}
+const { assign } = Object;
+function isComputed(o) {
+    return !!(vue.isRef(o) && o.effect);
+}
+function createOptionsStore(id, options, pinia, hot) {
+    const { state, actions, getters } = options;
+    const initialState = pinia.state.value[id];
+    let store;
+    function setup() {
+        if (!initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {
+            /* istanbul ignore if */ {
+                pinia.state.value[id] = state ? state() : {};
+            }
+        }
+        // avoid creating a state in pinia.state.value
+        const localState = process.env.NODE_ENV !== 'production' && hot ? vue.toRefs(vue.ref(state ? state() : {}).value) : vue.toRefs(pinia.state.value[id]);
+        return assign(localState, actions, Object.keys(getters || {}).reduce((computedGetters, name)=>{
+            if (process.env.NODE_ENV !== 'production' && name in localState) {
+                console.warn(`[🍍]: A getter cannot have the same name as another state property. Rename one of them. Found with "${name}" in store "${id}".`);
+            }
+            computedGetters[name] = vue.markRaw(vue.computed(()=>{
+                setActivePinia(pinia);
+                // it was created just before
+                const store = pinia._s.get(id);
+                // @ts-expect-error
+                // return getters![name].call(context, context)
+                // TODO: avoid reading the getter while assigning with a global variable
+                return getters[name].call(store, store);
+            }));
+            return computedGetters;
+        }, {}));
+    }
+    store = createSetupStore(id, setup, options, pinia, hot, true);
+    return store;
+}
+function createSetupStore($id, setup, options = {}, pinia, hot, isOptionsStore) {
+    let scope;
+    const optionsForPlugin = assign({
+        actions: {}
+    }, options);
+    /* istanbul ignore if */ if (process.env.NODE_ENV !== 'production' && !pinia._e.active) {
+        throw new Error('Pinia destroyed');
+    }
+    // watcher options for $subscribe
+    const $subscribeOptions = {
+        deep: true
+    };
+    /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production' && !isVue2) {
+        $subscribeOptions.onTrigger = (event)=>{
+            /* istanbul ignore else */ if (isListening) {
+                debuggerEvents = event;
+            // avoid triggering this while the store is being built and the state is being set in pinia
+            } else if (isListening == false && !store._hotUpdating) {
+                // let patch send all the events together later
+                /* istanbul ignore else */ if (Array.isArray(debuggerEvents)) {
+                    debuggerEvents.push(event);
+                } else {
+                    console.error('🍍 debuggerEvents should be an array. This is most likely an internal Pinia bug.');
+                }
+            }
+        };
+    }
+    // internal state
+    let isListening; // set to true at the end
+    let isSyncListening; // set to true at the end
+    let subscriptions = [];
+    let actionSubscriptions = [];
+    let debuggerEvents;
+    const initialState = pinia.state.value[$id];
+    // avoid setting the state for option stores if it is set
+    // by the setup
+    if (!isOptionsStore && !initialState && (!(process.env.NODE_ENV !== 'production') || !hot)) {
+        /* istanbul ignore if */ {
+            pinia.state.value[$id] = {};
+        }
+    }
+    const hotState = vue.ref({});
+    // avoid triggering too many listeners
+    // https://github.com/vuejs/pinia/issues/1129
+    let activeListener;
+    function $patch(partialStateOrMutator) {
+        let subscriptionMutation;
+        isListening = isSyncListening = false;
+        // reset the debugger events since patches are sync
+        /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
+            debuggerEvents = [];
+        }
+        if (typeof partialStateOrMutator === 'function') {
+            partialStateOrMutator(pinia.state.value[$id]);
+            subscriptionMutation = {
+                type: MutationType.patchFunction,
+                storeId: $id,
+                events: debuggerEvents
+            };
+        } else {
+            mergeReactiveObjects(pinia.state.value[$id], partialStateOrMutator);
+            subscriptionMutation = {
+                type: MutationType.patchObject,
+                payload: partialStateOrMutator,
+                storeId: $id,
+                events: debuggerEvents
+            };
+        }
+        const myListenerId = activeListener = Symbol();
+        vue.nextTick().then(()=>{
+            if (activeListener === myListenerId) {
+                isListening = true;
+            }
+        });
+        isSyncListening = true;
+        // because we paused the watcher, we need to manually call the subscriptions
+        triggerSubscriptions(subscriptions, subscriptionMutation, pinia.state.value[$id]);
+    }
+    const $reset = isOptionsStore ? function $reset() {
+        const { state } = options;
+        const newState = state ? state() : {};
+        // we use a patch to group all changes into one single subscription
+        this.$patch(($state)=>{
+            assign($state, newState);
+        });
+    } : /* istanbul ignore next */ process.env.NODE_ENV !== 'production' ? ()=>{
+        throw new Error(`🍍: Store "${$id}" is built using the setup syntax and does not implement $reset().`);
+    } : noop$1;
+    function $dispose() {
+        scope.stop();
+        subscriptions = [];
+        actionSubscriptions = [];
+        pinia._s.delete($id);
+    }
+    /**
+     * Wraps an action to handle subscriptions.
+     *
+     * @param name - name of the action
+     * @param action - action to wrap
+     * @returns a wrapped action to handle subscriptions
+     */ function wrapAction(name, action) {
+        return function() {
+            setActivePinia(pinia);
+            const args = Array.from(arguments);
+            const afterCallbackList = [];
+            const onErrorCallbackList = [];
+            function after(callback) {
+                afterCallbackList.push(callback);
+            }
+            function onError(callback) {
+                onErrorCallbackList.push(callback);
+            }
+            // @ts-expect-error
+            triggerSubscriptions(actionSubscriptions, {
+                args,
+                name,
+                store,
+                after,
+                onError
+            });
+            let ret;
+            try {
+                ret = action.apply(this && this.$id === $id ? this : store, args);
+            // handle sync errors
+            } catch (error) {
+                triggerSubscriptions(onErrorCallbackList, error);
+                throw error;
+            }
+            if (ret instanceof Promise) {
+                return ret.then((value)=>{
+                    triggerSubscriptions(afterCallbackList, value);
+                    return value;
+                }).catch((error)=>{
+                    triggerSubscriptions(onErrorCallbackList, error);
+                    return Promise.reject(error);
+                });
+            }
+            // trigger after callbacks
+            triggerSubscriptions(afterCallbackList, ret);
+            return ret;
+        };
+    }
+    const _hmrPayload = /*#__PURE__*/ vue.markRaw({
+        actions: {},
+        getters: {},
+        state: [],
+        hotState
+    });
+    const partialStore = {
+        _p: pinia,
+        // _s: scope,
+        $id,
+        $onAction: addSubscription.bind(null, actionSubscriptions),
+        $patch,
+        $reset,
+        $subscribe (callback, options = {}) {
+            const removeSubscription = addSubscription(subscriptions, callback, options.detached, ()=>stopWatcher());
+            const stopWatcher = scope.run(()=>vue.watch(()=>pinia.state.value[$id], (state)=>{
+                    if (options.flush === 'sync' ? isSyncListening : isListening) {
+                        callback({
+                            storeId: $id,
+                            type: MutationType.direct,
+                            events: debuggerEvents
+                        }, state);
+                    }
+                }, assign({}, $subscribeOptions, options)));
+            return removeSubscription;
+        },
+        $dispose
+    };
+    const store = vue.reactive(process.env.NODE_ENV !== 'production' || USE_DEVTOOLS ? assign({
+        _hmrPayload,
+        _customProperties: vue.markRaw(new Set())
+    }, partialStore) : partialStore);
+    // store the partial store now so the setup of stores can instantiate each other before they are finished without
+    // creating infinite loops.
+    pinia._s.set($id, store);
+    const runWithContext = pinia._a && pinia._a.runWithContext || fallbackRunWithContext;
+    // TODO: idea create skipSerialize that marks properties as non serializable and they are skipped
+    const setupStore = runWithContext(()=>pinia._e.run(()=>(scope = vue.effectScope()).run(setup)));
+    // overwrite existing actions to support $onAction
+    for(const key in setupStore){
+        const prop = setupStore[key];
+        if (vue.isRef(prop) && !isComputed(prop) || vue.isReactive(prop)) {
+            // mark it as a piece of state to be serialized
+            if (process.env.NODE_ENV !== 'production' && hot) {
+                set(hotState.value, key, vue.toRef(setupStore, key));
+            // createOptionStore directly sets the state in pinia.state.value so we
+            // can just skip that
+            } else if (!isOptionsStore) {
+                // in setup stores we must hydrate the state and sync pinia state tree with the refs the user just created
+                if (initialState && shouldHydrate(prop)) {
+                    if (vue.isRef(prop)) {
+                        prop.value = initialState[key];
+                    } else {
+                        // probably a reactive object, lets recursively assign
+                        // @ts-expect-error: prop is unknown
+                        mergeReactiveObjects(prop, initialState[key]);
+                    }
+                }
+                // transfer the ref to the pinia state to keep everything in sync
+                /* istanbul ignore if */ {
+                    pinia.state.value[$id][key] = prop;
+                }
+            }
+            /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
+                _hmrPayload.state.push(key);
+            }
+        // action
+        } else if (typeof prop === 'function') {
+            // @ts-expect-error: we are overriding the function we avoid wrapping if
+            const actionValue = process.env.NODE_ENV !== 'production' && hot ? prop : wrapAction(key, prop);
+            // this a hot module replacement store because the hotUpdate method needs
+            // to do it with the right context
+            /* istanbul ignore if */ {
+                // @ts-expect-error
+                setupStore[key] = actionValue;
+            }
+            /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
+                _hmrPayload.actions[key] = prop;
+            }
+            // list actions so they can be used in plugins
+            // @ts-expect-error
+            optionsForPlugin.actions[key] = prop;
+        } else if (process.env.NODE_ENV !== 'production') {
+            // add getters for devtools
+            if (isComputed(prop)) {
+                _hmrPayload.getters[key] = isOptionsStore ? options.getters[key] : prop;
+                if (IS_CLIENT) {
+                    const getters = setupStore._getters || // @ts-expect-error: same
+                    (setupStore._getters = vue.markRaw([]));
+                    getters.push(key);
+                }
+            }
+        }
+    }
+    // add the state, getters, and action properties
+    /* istanbul ignore if */ {
+        assign(store, setupStore);
+        // allows retrieving reactive objects with `storeToRefs()`. Must be called after assigning to the reactive object.
+        // Make `storeToRefs()` work with `reactive()` #799
+        assign(vue.toRaw(store), setupStore);
+    }
+    // use this instead of a computed with setter to be able to create it anywhere
+    // without linking the computed lifespan to wherever the store is first
+    // created.
+    Object.defineProperty(store, '$state', {
+        get: ()=>process.env.NODE_ENV !== 'production' && hot ? hotState.value : pinia.state.value[$id],
+        set: (state)=>{
+            /* istanbul ignore if */ if (process.env.NODE_ENV !== 'production' && hot) {
+                throw new Error('cannot set hotState');
+            }
+            $patch(($state)=>{
+                assign($state, state);
+            });
+        }
+    });
+    // add the hotUpdate before plugins to allow them to override it
+    /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
+        store._hotUpdate = vue.markRaw((newStore)=>{
+            store._hotUpdating = true;
+            newStore._hmrPayload.state.forEach((stateKey)=>{
+                if (stateKey in store.$state) {
+                    const newStateTarget = newStore.$state[stateKey];
+                    const oldStateSource = store.$state[stateKey];
+                    if (typeof newStateTarget === 'object' && isPlainObject(newStateTarget) && isPlainObject(oldStateSource)) {
+                        patchObject(newStateTarget, oldStateSource);
+                    } else {
+                        // transfer the ref
+                        newStore.$state[stateKey] = oldStateSource;
+                    }
+                }
+                // patch direct access properties to allow store.stateProperty to work as
+                // store.$state.stateProperty
+                set(store, stateKey, vue.toRef(newStore.$state, stateKey));
+            });
+            // remove deleted state properties
+            Object.keys(store.$state).forEach((stateKey)=>{
+                if (!(stateKey in newStore.$state)) {
+                    del(store, stateKey);
+                }
+            });
+            // avoid devtools logging this as a mutation
+            isListening = false;
+            isSyncListening = false;
+            pinia.state.value[$id] = vue.toRef(newStore._hmrPayload, 'hotState');
+            isSyncListening = true;
+            vue.nextTick().then(()=>{
+                isListening = true;
+            });
+            for(const actionName in newStore._hmrPayload.actions){
+                const action = newStore[actionName];
+                set(store, actionName, wrapAction(actionName, action));
+            }
+            // TODO: does this work in both setup and option store?
+            for(const getterName in newStore._hmrPayload.getters){
+                const getter = newStore._hmrPayload.getters[getterName];
+                const getterValue = isOptionsStore ? vue.computed(()=>{
+                    setActivePinia(pinia);
+                    return getter.call(store, store);
+                }) : getter;
+                set(store, getterName, getterValue);
+            }
+            // remove deleted getters
+            Object.keys(store._hmrPayload.getters).forEach((key)=>{
+                if (!(key in newStore._hmrPayload.getters)) {
+                    del(store, key);
+                }
+            });
+            // remove old actions
+            Object.keys(store._hmrPayload.actions).forEach((key)=>{
+                if (!(key in newStore._hmrPayload.actions)) {
+                    del(store, key);
+                }
+            });
+            // update the values used in devtools and to allow deleting new properties later on
+            store._hmrPayload = newStore._hmrPayload;
+            store._getters = newStore._getters;
+            store._hotUpdating = false;
+        });
+    }
+    if (USE_DEVTOOLS) {
+        const nonEnumerable = {
+            writable: true,
+            configurable: true,
+            // avoid warning on devtools trying to display this property
+            enumerable: false
+        };
+        [
+            '_p',
+            '_hmrPayload',
+            '_getters',
+            '_customProperties'
+        ].forEach((p)=>{
+            Object.defineProperty(store, p, assign({
+                value: store[p]
+            }, nonEnumerable));
+        });
+    }
+    // apply all plugins
+    pinia._p.forEach((extender)=>{
+        /* istanbul ignore else */ if (USE_DEVTOOLS) {
+            const extensions = scope.run(()=>extender({
+                    store,
+                    app: pinia._a,
+                    pinia,
+                    options: optionsForPlugin
+                }));
+            Object.keys(extensions || {}).forEach((key)=>store._customProperties.add(key));
+            assign(store, extensions);
+        } else {
+            assign(store, scope.run(()=>extender({
+                    store,
+                    app: pinia._a,
+                    pinia,
+                    options: optionsForPlugin
+                })));
+        }
+    });
+    if (process.env.NODE_ENV !== 'production' && store.$state && typeof store.$state === 'object' && typeof store.$state.constructor === 'function' && !store.$state.constructor.toString().includes('[native code]')) {
+        console.warn(`[🍍]: The "state" must be a plain object. It cannot be\n` + `\tstate: () => new MyClass()\n` + `Found in store "${store.$id}".`);
+    }
+    // only apply hydrate to option stores with an initial state in pinia
+    if (initialState && isOptionsStore && options.hydrate) {
+        options.hydrate(store.$state, initialState);
+    }
+    isListening = true;
+    isSyncListening = true;
+    return store;
+}
+function defineStore(// TODO: add proper types from above
+idOrOptions, setup, setupOptions) {
+    let id;
+    let options;
+    const isSetupStore = typeof setup === 'function';
+    {
+        id = idOrOptions;
+        // the option store setup will contain the actual options in this case
+        options = isSetupStore ? setupOptions : setup;
+    }
+    function useStore(pinia, hot) {
+        const hasContext = vue.hasInjectionContext();
+        pinia = // in test mode, ignore the argument provided as we can always retrieve a
+        // pinia instance with getActivePinia()
+        (process.env.NODE_ENV === 'test' && activePinia && activePinia._testing ? null : pinia) || (hasContext ? vue.inject(piniaSymbol, null) : null);
+        if (pinia) setActivePinia(pinia);
+        if (process.env.NODE_ENV !== 'production' && !activePinia) {
+            throw new Error(`[🍍]: "getActivePinia()" was called but there was no active Pinia. Are you trying to use a store before calling "app.use(pinia)"?\n` + `See https://pinia.vuejs.org/core-concepts/outside-component-usage.html for help.\n` + `This will fail in production.`);
+        }
+        pinia = activePinia;
+        if (!pinia._s.has(id)) {
+            // creating the store registers it in `pinia._s`
+            if (isSetupStore) {
+                createSetupStore(id, setup, options, pinia);
+            } else {
+                createOptionsStore(id, options, pinia);
+            }
+            /* istanbul ignore else */ if (process.env.NODE_ENV !== 'production') {
+                // @ts-expect-error: not the right inferred type
+                useStore._pinia = pinia;
+            }
+        }
+        const store = pinia._s.get(id);
+        if (process.env.NODE_ENV !== 'production' && hot) {
+            const hotId = '__hot:' + id;
+            const newStore = isSetupStore ? createSetupStore(hotId, setup, options, pinia, true) : createOptionsStore(hotId, assign({}, options), pinia, true);
+            hot._hotUpdate(newStore);
+            // cleanup the state properties and the store from the cache
+            delete pinia.state.value[hotId];
+            pinia._s.delete(hotId);
+        }
+        if (process.env.NODE_ENV !== 'production' && IS_CLIENT) {
+            const currentInstance = vue.getCurrentInstance();
+            // save stores in instances to access them devtools
+            if (currentInstance && currentInstance.proxy && // avoid adding stores that are just built for hot module replacement
+            !hot) {
+                const vm = currentInstance.proxy;
+                const cache = '_pStores' in vm ? vm._pStores : vm._pStores = {};
+                cache[id] = store;
+            }
+        }
+        // StoreGeneric cannot be casted towards Store
+        return store;
+    }
+    useStore.$id = id;
+    return useStore;
+}
+/**
+ * Creates an object of references with all the state, getters, and plugin-added
+ * state properties of the store. Similar to `toRefs()` but specifically
+ * designed for Pinia stores so methods and non reactive properties are
+ * completely ignored.
+ *
+ * @param store - store to extract the refs from
+ */ function storeToRefs$1(store) {
+    // See https://github.com/vuejs/pinia/issues/852
+    // It's easier to just use toRefs() even if it includes more stuff
+    {
+        store = vue.toRaw(store);
+        const refs = {};
+        for(const key in store){
+            const value = store[key];
+            if (vue.isRef(value) || vue.isReactive(value)) {
+                // @ts-expect-error: the key is state or getter
+                refs[key] = // ---
+                vue.toRef(store, key);
+            }
+        }
+        return refs;
+    }
+}
+
+/*
+ * Copyright (c) 2024.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ const STORE_ID = 'authup';
+
+function createStore(context = {}) {
+    const client = new coreHttpKit.Client({
+        baseURL: context.baseURL
+    });
+    const initialized = vue.ref(false);
+    const setInitialized = (value)=>{
+        initialized.value = value;
+    };
+    // --------------------------------------------------------------------
+    const accessToken = vue.ref(undefined);
+    const setAccessToken = (input)=>{
+        accessToken.value = input;
+    };
+    // --------------------------------------------------------------------
+    const accessTokenExpireDate = vue.ref(undefined);
+    const setAccessTokenExpireDate = (input)=>{
+        if (typeof input === 'number' || typeof input === 'string') {
+            accessTokenExpireDate.value = new Date(input); // verify microseconds or seconds
+            return;
+        }
+        accessTokenExpireDate.value = input;
+    };
+    // --------------------------------------------------------------------
+    const refreshToken = vue.ref(undefined);
+    const setRefreshToken = (input)=>{
+        refreshToken.value = input;
+    };
+    // --------------------------------------------------------------------
+    const handleTokenGrantResponse = (response)=>{
+        const expireDate = new Date(Date.now() + response.expires_in * 1000);
+        setAccessTokenExpireDate(expireDate);
+        setAccessToken(response.access_token);
+        setRefreshToken(response.refresh_token);
+    };
+    // --------------------------------------------------------------------
+    let refreshTokenPromise;
+    const attemptRefreshToken = ()=>{
+        if (!refreshToken.value) {
+            return Promise.reject(new Error('No refresh token is present.'));
+        }
+        if (refreshTokenPromise) {
+            return refreshTokenPromise;
+        }
+        refreshTokenPromise = client.token.createWithRefreshToken({
+            refresh_token: refreshToken.value
+        }).then((r)=>{
+            handleTokenGrantResponse(r);
+            return r;
+        }).finally(()=>{
+            refreshTokenPromise = undefined;
+        });
+        return refreshTokenPromise;
+    };
+    // --------------------------------------------------------------------
+    const user = vue.ref(undefined);
+    const userId = vue.computed(()=>user.value ? user.value.id : undefined);
+    const userResolved = vue.ref(false);
+    const setUser = (entity)=>{
+        user.value = entity;
+        userResolved.value = !!entity;
+    };
+    // --------------------------------------------------------------------
+    const realm = vue.ref(undefined);
+    const realmId = vue.computed(()=>realm.value ? realm.value.id : undefined);
+    const realmName = vue.computed(()=>realm.value ? realm.value.name : undefined);
+    const realmIsRoot = vue.computed(()=>{
+        if (realm.value) {
+            return realm.value.name === coreKit.REALM_MASTER_NAME;
+        }
+        return false;
+    });
+    const setRealm = (entity)=>{
+        realm.value = entity;
+    };
+    const realmManagement = vue.ref(undefined);
+    const realmManagementId = vue.computed(()=>realmManagement.value ? realmManagement.value.id : realmId.value);
+    const realmManagementName = vue.computed(()=>realmManagement.value ? realmManagement.value.name : realmName.value);
+    const setRealmManagement = (entity)=>{
+        realmManagement.value = entity;
+    };
+    const abilities = new kit.Abilities();
+    const tokenInfo = vue.ref(undefined);
+    const tokenResolved = vue.ref(false);
+    const setTokenInfo = (entity)=>{
+        tokenResolved.value = !!entity;
+        tokenInfo.value = entity;
+        if (!entity) {
+            setRealm(undefined);
+            setRealmManagement(undefined);
+            abilities.set([]);
+            return;
+        }
+        if (entity.exp) {
+            const expireDate = new Date(entity.exp * 1000);
+            setAccessTokenExpireDate(expireDate);
+        }
+        if (entity.realm_id && entity.realm_name) {
+            realm.value = {
+                id: entity.realm_id,
+                name: entity.realm_name
+            };
+            if (typeof realmManagement.value === 'undefined') {
+                setRealmManagement(realm.value);
+            }
+        }
+        if (entity.permissions) {
+            abilities.set(entity.permissions);
+        }
+    };
+    // --------------------------------------------------------------------
+    const resolve = async (ctx = {})=>{
+        if (!accessToken.value || ctx.attempts && ctx.attempts > 3) return;
+        try {
+            if (!tokenResolved.value || ctx.refresh) {
+                const token = await client.token.introspect({
+                    token: accessToken.value
+                }, {
+                    authorizationHeader: {
+                        type: 'Bearer',
+                        token: accessToken.value
+                    }
+                });
+                setTokenInfo(token);
+                tokenResolved.value = true;
+            }
+            if (!userResolved.value || ctx.refresh) {
+                const entity = await client.userInfo.get(`Bearer ${accessToken.value}`);
+                setUser(entity);
+                userResolved.value = true;
+            }
+        } catch (e) {
+            if (coreHttpKit.isClientTokenExpiredError(e)) {
+                await attemptRefreshToken();
+                await resolve({
+                    refresh: true,
+                    attempts: ctx.attempts ? ctx.attempts++ : 1
+                });
+                return;
+            }
+            throw e;
+        }
+    };
+    const loggedIn = vue.computed(()=>!!accessToken.value);
+    const login = async (ctx)=>{
+        try {
+            const response = await client.token.createWithPasswordGrant({
+                username: ctx.name,
+                password: ctx.password,
+                ...realmId.value ? {
+                    realm_id: ctx.realmId
+                } : {}
+            });
+            handleTokenGrantResponse(response);
+            await resolve();
+        } catch (e) {
+            setUser(undefined);
+            throw e;
+        }
+    };
+    const logout = ()=>{
+        setAccessToken(undefined);
+        setAccessTokenExpireDate(undefined);
+        setRefreshToken(undefined);
+        setUser(undefined);
+        setTokenInfo(undefined);
+    };
+    return {
+        initialized,
+        setInitialized,
+        abilities,
+        login,
+        logout,
+        loggedIn,
+        resolve,
+        handleTokenGrantResponse,
+        accessToken,
+        setAccessToken,
+        accessTokenExpireDate,
+        setAccessTokenExpireDate,
+        refreshToken,
+        setRefreshToken,
+        tokenInfo,
+        setTokenInfo,
+        realm,
+        realmId,
+        realmIsRoot,
+        realmName,
+        setRealm,
+        realmManagement,
+        realmManagementId,
+        realmManagementName,
+        setRealmManagement,
+        user,
+        userId,
+        setUser
+    };
+}
+
+function tryOnScopeDispose(fn) {
+    if (vue.getCurrentScope()) {
+        vue.onScopeDispose(fn);
+        return true;
+    }
+    return false;
+}
+typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
+const noop = ()=>{};
+
+function useCookies(dependencies, { doNotParse = false, autoUpdateDependencies = false } = {}, cookies = new Cookie()) {
+    const watchingDependencies = autoUpdateDependencies ? [
+        ...[]
+    ] : dependencies;
+    let previousCookies = cookies.getAll({
+        doNotParse: true
+    });
+    const touches = vue.ref(0);
+    const onChange = ()=>{
+        const newCookies = cookies.getAll({
+            doNotParse: true
+        });
+        if (shouldUpdate(watchingDependencies || null, newCookies, previousCookies)) touches.value++;
+        previousCookies = newCookies;
+    };
+    cookies.addChangeListener(onChange);
+    tryOnScopeDispose(()=>{
+        cookies.removeChangeListener(onChange);
+    });
+    return {
+        /**
+     * Reactive get cookie by name. If **autoUpdateDependencies = true** then it will update watching dependencies
+     */ get: (...args)=>{
+            if (autoUpdateDependencies && watchingDependencies && !watchingDependencies.includes(args[0])) watchingDependencies.push(args[0]);
+            touches.value;
+            return cookies.get(args[0], {
+                doNotParse,
+                ...args[1]
+            });
+        },
+        /**
+     * Reactive get all cookies
+     */ getAll: (...args)=>{
+            touches.value;
+            return cookies.getAll({
+                doNotParse,
+                ...args[0]
+            });
+        },
+        set: (...args)=>cookies.set(...args),
+        remove: (...args)=>cookies.remove(...args),
+        addChangeListener: (...args)=>cookies.addChangeListener(...args),
+        removeChangeListener: (...args)=>cookies.removeChangeListener(...args)
+    };
+}
+function shouldUpdate(dependencies, newCookies, oldCookies) {
+    if (!dependencies) return true;
+    for (const dependency of dependencies){
+        if (newCookies[dependency] !== oldCookies[dependency]) return true;
+    }
+    return false;
+}
+
+const StoreSymbol = Symbol.for('AuthupStore');
+function useStore(pinia, app) {
+    const instance = injectStore(app);
+    if (!instance) {
+        throw new Error('The store has not been injected in the app context.');
+    }
+    return instance(pinia);
+}
+function injectStore(app) {
+    const instance = inject$1(StoreSymbol, app);
+    if (!instance) {
+        throw new Error('The store has not been injected in the app context.');
+    }
+    return instance;
+}
+function hasStore(app) {
+    return !!inject$1(StoreSymbol, app);
+}
+function provideStore(store, app) {
+    provide(StoreSymbol, store, app);
+}
+
+function installStore(app, options = {}) {
+    if (hasStore(app)) {
+        return;
+    }
+    const storeCreator = defineStore(STORE_ID, ()=>createStore({
+            baseURL: options.baseURL
+        }));
+    const store = storeCreator();
+    const cookies = useCookies();
+    let cookieGet;
+    if (options.cookieGet) {
+        cookieGet = options.cookieGet;
+    } else {
+        cookieGet = cookies.get;
+    }
+    let cookieSet;
+    if (options.cookieSet) {
+        cookieSet = options.cookieSet;
+    } else {
+        cookieSet = cookies.set;
+    }
+    let cookieUnset;
+    if (options.cookieUnset) {
+        cookieUnset = options.cookieUnset;
+    } else if (options.cookieSet) {
+        cookieUnset = (key)=>{
+            options.cookieSet(key, null);
+        };
+    } else {
+        cookieUnset = cookies.remove;
+    }
+    const initStore = ()=>{
+        if (store.initialized) {
+            return;
+        }
+        store.setInitialized(true);
+        const keys = Object.values(coreHttpKit.CookieName);
+        let value;
         for(let i = 0; i < keys.length; i++){
-            this.setOptions(keys[i], items[keys[i]]);
+            value = cookieGet(keys[i]);
+            if (!value) {
+                continue;
+            }
+            switch(keys[i]){
+                case coreHttpKit.CookieName.ACCESS_TOKEN:
+                    if (!store.accessToken) {
+                        store.setAccessToken(value);
+                    }
+                    break;
+                case coreHttpKit.CookieName.ACCESS_TOKEN_EXPIRE_DATE:
+                    if (!store.accessTokenExpireDate) {
+                        store.setAccessTokenExpireDate(value);
+                    }
+                    break;
+                case coreHttpKit.CookieName.REFRESH_TOKEN:
+                    if (!store.refreshToken) {
+                        store.setRefreshToken(value);
+                    }
+                    break;
+                case coreHttpKit.CookieName.USER:
+                    if (!store.user) {
+                        store.setUser(value);
+                    }
+                    break;
+                case coreHttpKit.CookieName.REALM:
+                    if (!store.realm) {
+                        store.setRealm(value);
+                    }
+                    break;
+                case coreHttpKit.CookieName.REALM_MANAGEMENT:
+                    if (!store.realmManagement) {
+                        store.setRealmManagement(value);
+                    }
+                    break;
+            }
         }
-    }
-    /**
-     * Set options for a specific group.
-     *
-     * @param group
-     * @param options
-     */ setOptions(group, options) {
-        if (typeof this.data[group] === 'undefined') {
-            this.data[group] = {};
+    };
+    store.$onAction((action)=>{
+        if (action.store.$id !== STORE_ID) {
+            return;
         }
-        this.data[group] = options;
-    }
-    hasOptions(group) {
-        return smob.hasOwnProperty(this.data, group);
-    }
-    getOptions(group) {
-        if (typeof this.data[group] !== 'undefined') {
-            return this.data[group];
+        if (action.name === 'logout') {
+            cookieUnset(coreHttpKit.CookieName.ACCESS_TOKEN);
+            cookieUnset(coreHttpKit.CookieName.ACCESS_TOKEN_EXPIRE_DATE);
+            cookieUnset(coreHttpKit.CookieName.REFRESH_TOKEN);
+            cookieUnset(coreHttpKit.CookieName.USER);
+            cookieUnset(coreHttpKit.CookieName.REALM);
+            cookieUnset(coreHttpKit.CookieName.REALM_MANAGEMENT);
         }
-        return {};
-    }
-    hasOption(group, option) {
-        return typeof this.data[group] !== 'undefined' && smob.hasOwnProperty(this.data[group], option);
-    }
-    getOption(group, option) {
-        if (typeof this.data[group] === 'undefined') {
-            return undefined;
+    });
+    initStore();
+    store.$subscribe((mutation, state)=>{
+        if (mutation.storeId !== STORE_ID) {
+            return;
         }
-        return this.data[group][option];
-    }
-    constructor(){
-        this.data = {};
-    }
-}
-class StoreManager {
-    keys() {
-        return Object.keys(this.instances);
-    }
-    use(key) {
-        if (typeof this.instances[key] !== 'undefined') {
-            return this.instances[key];
+        if (state.accessToken) {
+            cookieSet(coreHttpKit.CookieName.ACCESS_TOKEN, state.accessToken);
         }
-        this.instances[key] = new Store();
-        return this.instances[key];
-    }
-    constructor(){
-        this.instances = {};
-    }
-}
-function applyStoreManagerOptions(manager, options) {
-    if (options.presets) {
-        const presetKeys = Object.keys(options.presets);
-        for(let i = 0; i < presetKeys.length; i++){
-            const store = manager.use(presetKeys[i]);
-            store.setAll(options.presets[presetKeys[i]]);
+        if (state.accessTokenExpireDate) {
+            cookieSet(coreHttpKit.CookieName.ACCESS_TOKEN_EXPIRE_DATE, state.accessTokenExpireDate);
         }
-    }
-    if (options.defaults) {
-        const store = manager.use(StoreName.DEFAULT);
-        store.setAll(options.defaults);
-    }
-}
-function getSymbol(key) {
-    {
-        return Symbol.for(`VCStoreManager#${key}`);
-    }
-}
-function installStoreManager(instance, key) {
-    let manager;
-    const symbol = getSymbol(key);
-    if (instance._context && instance._context.provides && instance._context.provides[symbol]) {
-        return instance._context.provides[symbol];
-    }
-    if (vue.hasInjectionContext()) {
-        manager = vue.inject(symbol, undefined);
-        if (manager) {
-            return manager;
+        if (state.refreshToken) {
+            cookieSet(coreHttpKit.CookieName.REFRESH_TOKEN, state.refreshToken);
         }
-    }
-    manager = new StoreManager();
-    instance.provide(symbol, manager);
-    return manager;
-}
-
-function inject$1(key, instance) {
-    if (instance && instance._context && instance._context.provides && instance._context.provides[key]) {
-        return instance._context.provides[key];
-    }
-    if (vue.hasInjectionContext()) {
-        return vue.inject(key, undefined);
-    }
-    return undefined;
+        if (state.user) {
+            cookieSet(coreHttpKit.CookieName.USER, state.user);
+        }
+        if (state.realm) {
+            cookieSet(coreHttpKit.CookieName.REALM, state.realm);
+        }
+        if (state.realmManagement) {
+            cookieSet(coreHttpKit.CookieName.REALM_MANAGEMENT, state.realmManagement);
+        }
+    });
+    provideStore(storeCreator, app);
 }
 
-function provide(key, value, app) {
-    if (typeof app === 'undefined') {
-        const val = inject$1(key);
-        if (typeof val !== 'undefined') {
-            return;
+function storeToRefs(store) {
+    store = vue.toRaw(store);
+    const refs = {};
+    const keys = Object.keys(store);
+    for(let i = 0; i < keys.length; i++){
+        const value = store[keys[i]];
+        if (vue.isRef(value) || vue.isReactive(value)) {
+            refs[keys[i]] = vue.toRef(store, keys[i]);
         }
-        vue.provide(key, value);
-        return;
-    }
-    if (app && app._context && app._context.provides && app._context.provides[key]) {
-        return;
     }
-    app.provide(key, value);
+    return refs;
 }
 
-const APIClientSymbol = Symbol.for('AuthupAPIClient');
-function provideAPIClient(client, app) {
-    provide(APIClientSymbol, client, app);
-}
-function injectAPIClient() {
-    const instance = inject$1(APIClientSymbol);
-    if (!instance) {
-        throw new Error('The api client has not been injected.');
+function installHTTPClient(app, options = {}) {
+    if (hasHTTPClient(app)) {
+        return;
     }
-    return instance;
+    const client = new coreHttpKit.Client({
+        baseURL: options.baseURL
+    });
+    const storeCreator = injectStore(app);
+    const store = storeCreator();
+    const { refreshToken } = storeToRefs$1(store);
+    const tokenHook = new coreHttpKit.ClientResponseErrorTokenHook(client, {
+        baseURL: options.baseURL,
+        tokenCreator: ()=>{
+            if (!refreshToken.value) {
+                throw new Error('No refresh token available.');
+            }
+            return client.token.createWithRefreshToken({
+                refresh_token: refreshToken.value
+            });
+        },
+        tokenCreated: (response)=>{
+            store.handleTokenGrantResponse(response);
+        },
+        tokenFailed: ()=>{
+            store.logout();
+        }
+    });
+    store.$subscribe((mutation, state)=>{
+        if (mutation.storeId !== STORE_ID) return;
+        if (state.accessToken) {
+            client.setAuthorizationHeader({
+                type: 'Bearer',
+                token: state.accessToken
+            });
+            tokenHook.mount();
+        } else {
+            client.unsetAuthorizationHeader();
+            tokenHook.unmount();
+        }
+        if (state.refreshToken && state.accessTokenExpireDate) {
+            const expiresIn = Math.floor((state.accessTokenExpireDate.getTime() - Date.now()) / 1000);
+            tokenHook.setTimer({
+                refresh_token: ()=>refreshToken.value,
+                expires_in: expiresIn
+            });
+        }
+    });
+    provideHTTPClient(client, app);
 }
 
 function renderEntityAssignAction(ctx) {
@@ -289,271 +1304,61 @@ function buildListCreatedHandler(items, cb) {
         } else {
             index = -1;
         }
-        if (index === -1) {
-            if (options.unshift) {
-                items.value.unshift(item);
-            } else {
-                items.value.push(item);
-            }
-            if (cb) {
-                cb(item);
-            }
-        }
-    };
-}
-function buildListUpdatedHandler(items, cb) {
-    return (item)=>{
-        if (!smob.isObject(item)) {
-            return;
-        }
-        const index = items.value.findIndex((el)=>el.id === item.id);
-        if (index !== -1) {
-            const keys = Object.keys(item);
-            for(let i = 0; i < keys.length; i++){
-                items.value[index][keys[i]] = item[keys[i]];
-            }
-            if (cb) {
-                cb(item);
-            }
-        }
-    };
-}
-function buildListDeletedHandler(items, cb) {
-    return (item)=>{
-        if (!smob.isObject(item)) {
-            return undefined;
-        }
-        const index = items.value.findIndex((el)=>el.id === item.id);
-        if (index !== -1) {
-            if (cb) {
-                cb(items.value[index]);
-            }
-            return items.value.splice(index, 1).pop();
-        }
-        return undefined;
-    };
-}
-
-/*
- * Copyright (c) 2023.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function boolableToObject(input) {
-    if (typeof input === 'boolean') {
-        return {};
-    }
-    return input;
-}
-
-const createStore = (context)=>{
-    const client = new coreHttpKit.Client({
-        baseURL: context.baseURL
-    });
-    // --------------------------------------------------------------------
-    const accessToken = vue.ref(undefined);
-    const setAccessToken = (input)=>{
-        accessToken.value = input;
-    };
-    // --------------------------------------------------------------------
-    const accessTokenExpireDate = vue.ref(undefined);
-    const setAccessTokenExpireDate = (input)=>{
-        if (typeof input === 'number' || typeof input === 'string') {
-            accessTokenExpireDate.value = new Date(input); // verify microseconds or seconds
-            return;
-        }
-        accessTokenExpireDate.value = input;
-    };
-    // --------------------------------------------------------------------
-    const refreshToken = vue.ref(undefined);
-    const setRefreshToken = (input)=>{
-        refreshToken.value = input;
-    };
-    const handleTokenGrantResponse = (response)=>{
-        const expireDate = new Date(Date.now() + response.expires_in * 1000);
-        setAccessTokenExpireDate(expireDate);
-        setAccessToken(response.access_token);
-        setRefreshToken(response.refresh_token);
-    };
-    let refreshTokenPromise;
-    const attemptRefreshToken = ()=>{
-        if (!refreshToken.value) {
-            return Promise.reject(new Error('No refresh token is present.'));
-        }
-        if (refreshTokenPromise) {
-            return refreshTokenPromise;
-        }
-        refreshTokenPromise = client.token.createWithRefreshToken({
-            refresh_token: refreshToken.value
-        }).then((r)=>{
-            handleTokenGrantResponse(r);
-            refreshTokenPromise = undefined;
-            return r;
-        }).catch((e)=>{
-            refreshTokenPromise = undefined;
-            throw e;
-        });
-        return refreshTokenPromise;
-    };
-    // --------------------------------------------------------------------
-    const user = vue.ref(undefined);
-    const userId = vue.computed(()=>user.value ? user.value.id : undefined);
-    const userResolved = vue.ref(false);
-    const setUser = (entity)=>{
-        user.value = entity;
-        userResolved.value = !!entity;
-    };
-    // --------------------------------------------------------------------
-    const abilityManager = new kit.AbilityManager();
-    const tokenInfo = vue.ref(undefined);
-    const tokenResolved = vue.ref(false);
-    const has = (name)=>abilityManager.has(name);
-    const realm = vue.ref(undefined);
-    const realmId = vue.computed(()=>realm.value ? realm.value.id : undefined);
-    const realmName = vue.computed(()=>realm.value ? realm.value.name : undefined);
-    const setRealm = (entity)=>{
-        realm.value = entity;
-    };
-    const realmManagement = vue.ref(undefined);
-    const realmManagementId = vue.computed(()=>realmManagement.value ? realmManagement.value.id : realmId.value);
-    const realmManagementName = vue.computed(()=>realmManagement.value ? realmManagement.value.name : realmName.value);
-    const setRealmManagement = (entity)=>{
-        realmManagement.value = entity;
-    };
-    const setTokenInfo = (entity)=>{
-        tokenResolved.value = !!entity;
-        tokenInfo.value = entity;
-        if (!entity) {
-            setRealm(undefined);
-            setRealmManagement(undefined);
-            abilityManager.set([]);
-            return;
-        }
-        if (entity.exp) {
-            const expireDate = new Date(entity.exp * 1000);
-            setAccessTokenExpireDate(expireDate);
-        }
-        if (entity.realm_id && entity.realm_name) {
-            realm.value = {
-                id: entity.realm_id,
-                name: entity.realm_name
-            };
-            if (typeof realmManagement.value === 'undefined') {
-                setRealmManagement(realm.value);
-            }
-        }
-        if (entity.permissions) {
-            abilityManager.set(entity.permissions);
-        }
-    };
-    // --------------------------------------------------------------------
-    const resolve = async (ctx = {})=>{
-        if (!accessToken.value || ctx.attempts && ctx.attempts > 3) return;
-        try {
-            if (!tokenResolved.value || ctx.refresh) {
-                const token = await client.token.introspect({
-                    token: accessToken.value
-                }, {
-                    authorizationHeader: {
-                        type: 'Bearer',
-                        token: accessToken.value
-                    }
-                });
-                setTokenInfo(token);
-                tokenResolved.value = true;
-            }
-            if (!userResolved.value || ctx.refresh) {
-                const entity = await client.userInfo.get(`Bearer ${accessToken.value}`);
-                setUser(entity);
-                userResolved.value = true;
+        if (index === -1) {
+            if (options.unshift) {
+                items.value.unshift(item);
+            } else {
+                items.value.push(item);
             }
-        } catch (e) {
-            if (coreHttpKit.isClientTokenExpiredError(e)) {
-                await attemptRefreshToken();
-                await resolve({
-                    refresh: true,
-                    attempts: ctx.attempts ? ctx.attempts++ : 1
-                });
-                return;
+            if (cb) {
+                cb(item);
             }
-            throw e;
         }
     };
-    const loggedIn = vue.computed(()=>!!accessToken.value);
-    const login = async (ctx)=>{
-        try {
-            const response = await client.token.createWithPasswordGrant({
-                username: ctx.name,
-                password: ctx.password,
-                ...realmId.value ? {
-                    realm_id: ctx.realmId
-                } : {}
-            });
-            handleTokenGrantResponse(response);
-            await resolve();
-        } catch (e) {
-            setUser(undefined);
-            throw e;
+}
+function buildListUpdatedHandler(items, cb) {
+    return (item)=>{
+        if (!smob.isObject(item)) {
+            return;
+        }
+        const index = items.value.findIndex((el)=>el.id === item.id);
+        if (index !== -1) {
+            const keys = Object.keys(item);
+            for(let i = 0; i < keys.length; i++){
+                items.value[index][keys[i]] = item[keys[i]];
+            }
+            if (cb) {
+                cb(item);
+            }
         }
     };
-    const logout = ()=>{
-        setAccessToken(undefined);
-        setRefreshToken(undefined);
-        setUser(undefined);
-        setTokenInfo(undefined);
-    };
-    return {
-        login,
-        logout,
-        loggedIn,
-        resolve,
-        handleTokenGrantResponse,
-        accessToken,
-        setAccessToken,
-        accessTokenExpireDate,
-        setAccessTokenExpireDate,
-        refreshToken,
-        setRefreshToken,
-        tokenInfo,
-        setTokenInfo,
-        realm,
-        realmId,
-        realmName,
-        setRealm,
-        realmManagement,
-        realmManagementId,
-        realmManagementName,
-        setRealmManagement,
-        user,
-        userId,
-        setUser,
-        has
-    };
-};
-
-const StoreSymbol = Symbol.for('AuthupStore');
-function injectStore() {
-    const instance = inject$1(StoreSymbol);
-    if (!instance) {
-        throw new Error('The store has not been injected in the app context.');
-    }
-    return instance;
 }
-function provideStore(store, app) {
-    provide(StoreSymbol, store, app);
+function buildListDeletedHandler(items, cb) {
+    return (item)=>{
+        if (!smob.isObject(item)) {
+            return undefined;
+        }
+        const index = items.value.findIndex((el)=>el.id === item.id);
+        if (index !== -1) {
+            if (cb) {
+                cb(items.value[index]);
+            }
+            return items.value.splice(index, 1).pop();
+        }
+        return undefined;
+    };
 }
 
-function storeToRefs(store) {
-    store = vue.toRaw(store);
-    const refs = {};
-    const keys = Object.keys(store);
-    for(let i = 0; i < keys.length; i++){
-        const value = store[keys[i]];
-        if (vue.isRef(value) || vue.isReactive(value)) {
-            refs[keys[i]] = vue.toRef(store, keys[i]);
-        }
+/*
+ * Copyright (c) 2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ function boolableToObject(input) {
+    if (typeof input === 'boolean') {
+        return {};
     }
-    return refs;
+    return input;
 }
 
 const SocketClientSymbol = Symbol.for('AuthupSocketClientManager');
@@ -575,6 +1380,13 @@ function injectSocketClientManager() {
     return manager;
 }
 
+function installSocketClientManager(app, options) {
+    const socketClientManager = new coreRealtimeKit.ClientManager({
+        url: options.baseURL
+    });
+    provideSocketClientManager(socketClientManager, app);
+}
+
 function createEntitySocket(ctx) {
     if (!isSocketClientManagerInjected()) {
         return {
@@ -582,7 +1394,7 @@ function createEntitySocket(ctx) {
             unmount () {}
         };
     }
-    const store = injectStore();
+    const store = useStore();
     const storeRefs = storeToRefs(store);
     const realmId = vue.computed(()=>{
         if (storeRefs.realmName.value === coreKit.REALM_MASTER_NAME) {
@@ -731,7 +1543,7 @@ function createList(context) {
         }
         return undefined;
     });
-    const client = injectAPIClient();
+    const client = injectHTTPClient();
     let domainAPI;
     if (kit.hasOwnProperty(client, context.type)) {
         domainAPI = client[context.type];
@@ -998,7 +1810,7 @@ function defineEntityManagerProps() {
 }
 
 function createEntityManager(ctx) {
-    const client = injectAPIClient();
+    const client = injectHTTPClient();
     let domainAPI;
     if (kit.hasOwnProperty(client, ctx.type)) {
         domainAPI = client[ctx.type];
@@ -1433,9 +2245,6 @@ class MemoryStore {
     }
 }
 
-typeof WorkerGlobalScope !== "undefined" && globalThis instanceof WorkerGlobalScope;
-const noop = ()=>{};
-
 function computedAsync(evaluationCallback, initialState, optionsOrRef) {
     let options;
     if (vue.isRef(optionsOrRef)) {
@@ -1815,6 +2624,33 @@ function useUpdatedAt(input) {
     });
 }
 
+function useAbilityCheck(name) {
+    const { abilities } = useStore();
+    const data = vue.ref(false);
+    data.value = abilities.has(name);
+    let removeListener;
+    vue.onMounted(()=>{
+        removeListener = abilities.on('updated', ()=>{
+            data.value = abilities.has(name);
+        });
+    });
+    vue.onUnmounted(()=>{
+        if (typeof removeListener !== 'undefined') {
+            removeListener();
+        }
+    });
+    return data;
+}
+
+function useRealmResourceWritableCheck(realmId) {
+    const store = useStore();
+    const { realm } = storeToRefs$1(store);
+    return vue.computed(()=>{
+        const realmIdRaw = vue.unref(realmId);
+        return coreKit.isRealmResourceWritable(realm.value, realmIdRaw);
+    });
+}
+
 const ARealm = vue.defineComponent({
     props: defineEntityManagerProps(),
     emits: defineEntityManagerEvents(),
@@ -2521,6 +3357,25 @@ const AClientScopes = vue.defineComponent({
     }
 });
 
+function createRealmFormPicker(form) {
+    return formControls.buildFormGroup({
+        label: true,
+        labelContent: 'Realm',
+        content: vue.h(ARealms, {}, {
+            [listControls.SlotName.ITEM_ACTIONS]: (props)=>renderEntityAssignAction({
+                    item: form.realm_id === props.data.id,
+                    busy: props.busy,
+                    add () {
+                        form.realm_id = props.data.id;
+                    },
+                    drop () {
+                        form.realm_id = '';
+                    }
+                })
+        })
+    });
+}
+
 const AScopeForm = vue.defineComponent({
     props: {
         name: {
@@ -2528,12 +3383,7 @@ const AScopeForm = vue.defineComponent({
             default: undefined
         },
         entity: {
-            type: Object,
-            default: undefined
-        },
-        realmId: {
-            type: String,
-            default: undefined
+            type: Object
         }
     },
     emits: defineEntityManagerEvents(),
@@ -2557,11 +3407,19 @@ const AScopeForm = vue.defineComponent({
             },
             realm_id: {}
         }, form);
+        const store = useStore();
+        const storeRefs = storeToRefs(store);
         const manager = createEntityManager({
             type: `${coreKit.DomainType.SCOPE}`,
             setup: ctx,
             props
         });
+        const realmId = vue.computed(()=>{
+            if (!storeRefs.realmIsRoot) {
+                return storeRefs.realmId.value;
+            }
+            return manager.data.value ? manager.data.value.realm_id : null;
+        });
         const isEditing = useIsEditing(manager.data);
         const updatedAt = useUpdatedAt(props.entity);
         const isNameFixed = vue.computed(()=>{
@@ -2570,14 +3428,10 @@ const AScopeForm = vue.defineComponent({
             }
             return !!(manager.data.value && manager.data.value.built_in);
         });
-        const isRealmLocked = vue.computed(()=>!!props.realmId);
         function initForm() {
             if (props.name) {
                 form.name = props.name;
             }
-            if (props.realmId) {
-                form.realm_id = props.realmId;
-            }
             initFormAttributesFromSource(form, manager.data.value);
         }
         vue.watch(updatedAt, (val, oldVal)=>{
@@ -2606,8 +3460,8 @@ const AScopeForm = vue.defineComponent({
                 key: exports.TranslatorTranslationDefaultKey.REALM
             }
         ]);
-        const render = ()=>{
-            const name = [
+        return ()=>{
+            const children = [
                 formControls.buildFormGroup({
                     validationMessages: translationsValidation.name.value,
                     validationSeverity: getVuelidateSeverity($v.value.name),
@@ -2622,9 +3476,7 @@ const AScopeForm = vue.defineComponent({
                             disabled: isNameFixed.value
                         }
                     })
-                })
-            ];
-            const description = [
+                }),
                 formControls.buildFormGroup({
                     validationMessages: translationsValidation.description.value,
                     validationSeverity: getVuelidateSeverity($v.value.description),
@@ -2641,52 +3493,22 @@ const AScopeForm = vue.defineComponent({
                     })
                 })
             ];
-            const submitForm = buildFormSubmitWithTranslations({
-                busy,
+            if (!realmId.value && !isNameFixed.value && !isEditing.value) {
+                children.push(createRealmFormPicker(form));
+            }
+            children.push(buildFormSubmitWithTranslations({
                 submit,
+                busy,
                 isEditing: isEditing.value,
                 invalid: $v.value.$invalid
-            }, translationsSubmit);
-            let realm = [];
-            if (!isRealmLocked.value && !isNameFixed.value) {
-                realm = [
-                    vue.h('hr'),
-                    vue.h('label', {
-                        class: 'form-label'
-                    }, translationsDefault[exports.TranslatorTranslationDefaultKey.REALM].value),
-                    vue.h(ARealms, {
-                        headerTitle: false
-                    }, {
-                        [listControls.SlotName.ITEM_ACTIONS]: (props)=>renderEntityAssignAction({
-                                item: form.realm_id === props.data.id,
-                                busy: props.busy,
-                                add () {
-                                    form.realm_id = props.data.id;
-                                },
-                                drop () {
-                                    form.realm_id = '';
-                                }
-                            })
-                    })
-                ];
-            }
+            }, translationsSubmit));
             return vue.h('form', {
                 onSubmit ($event) {
                     $event.preventDefault();
                     return submit.apply(null);
                 }
-            }, [
-                vue.h('div', [
-                    name,
-                    vue.h('hr'),
-                    description,
-                    realm,
-                    vue.h('hr'),
-                    submitForm
-                ])
-            ]);
+            }, children);
         };
-        return ()=>render();
     }
 });
 
@@ -4006,7 +4828,7 @@ const AIdentityProviderOAuth2Form = vue.defineComponent({
     },
     emits: defineEntityManagerEvents(),
     setup (props, ctx) {
-        const apiClient = injectAPIClient();
+        const apiClient = injectHTTPClient();
         const manager = createEntityManager({
             type: `${coreKit.DomainType.IDENTITY_PROVIDER}`,
             setup: ctx,
@@ -4598,7 +5420,8 @@ const ARoleForm = vue.defineComponent({
         const busy = vue.ref(false);
         const form = vue.reactive({
             name: '',
-            description: ''
+            description: '',
+            realm_id: ''
         });
         const $v = useVuelidate({
             name: {
@@ -4609,13 +5432,22 @@ const ARoleForm = vue.defineComponent({
             description: {
                 minLength: validators.minLength(5),
                 maxLength: validators.maxLength(4096)
-            }
+            },
+            realm_id: {}
         }, form);
+        const store = useStore();
+        const storeRefs = storeToRefs(store);
         const manager = createEntityManager({
             type: `${coreKit.DomainType.ROLE}`,
             setup: ctx,
             props
         });
+        const realmId = vue.computed(()=>{
+            if (!storeRefs.realmIsRoot) {
+                return storeRefs.realmId.value;
+            }
+            return manager.data.value ? manager.data.value.realm_id : null;
+        });
         const isEditing = useIsEditing(manager.data);
         const updatedAt = useUpdatedAt(props.entity);
         function initForm() {
@@ -4645,7 +5477,8 @@ const ARoleForm = vue.defineComponent({
             }
         ]);
         const render = ()=>{
-            const name = formControls.buildFormGroup({
+            const children = [];
+            children.push(formControls.buildFormGroup({
                 validationMessages: translationsValidation.name.value,
                 validationSeverity: getVuelidateSeverity($v.value.name),
                 label: true,
@@ -4656,8 +5489,8 @@ const ARoleForm = vue.defineComponent({
                         $v.value.name.$model = input;
                     }
                 })
-            });
-            const description = formControls.buildFormGroup({
+            }));
+            children.push(formControls.buildFormGroup({
                 validationMessages: translationsValidation.description.value,
                 validationSeverity: getVuelidateSeverity($v.value.description),
                 label: true,
@@ -4671,23 +5504,22 @@ const ARoleForm = vue.defineComponent({
                         rows: 6
                     }
                 })
-            });
-            const submitForm = buildFormSubmitWithTranslations({
+            }));
+            if (!realmId.value && !isEditing.value) {
+                children.push(createRealmFormPicker(form));
+            }
+            children.push(buildFormSubmitWithTranslations({
                 submit,
-                busy: busy.value,
+                busy,
                 isEditing: isEditing.value,
                 invalid: $v.value.$invalid
-            }, translationsSubmit);
+            }, translationsSubmit));
             return vue.h('form', {
                 onSubmit ($event) {
                     $event.preventDefault();
                     return submit.apply(null);
                 }
-            }, [
-                name,
-                description,
-                submitForm
-            ]);
+            }, children);
         };
         return ()=>render();
     }
@@ -4784,8 +5616,7 @@ const APermission = vue.defineComponent({
 const APermissionForm = vue.defineComponent({
     props: {
         entity: {
-            type: Object,
-            default: undefined
+            type: Object
         }
     },
     emits: defineEntityManagerEvents(),
@@ -4793,7 +5624,8 @@ const APermissionForm = vue.defineComponent({
         const busy = vue.ref(false);
         const form = vue.reactive({
             name: '',
-            description: ''
+            description: '',
+            realm_id: ''
         });
         const $v = useVuelidate({
             name: {
@@ -4804,13 +5636,22 @@ const APermissionForm = vue.defineComponent({
             description: {
                 minLength: validators.minLength(5),
                 maxLength: validators.maxLength(4096)
-            }
+            },
+            realm_id: {}
         }, form);
+        const store = useStore();
+        const storeRefs = storeToRefs(store);
         const manager = createEntityManager({
             type: `${coreKit.DomainType.PERMISSION}`,
             setup: ctx,
             props
         });
+        const realmId = vue.computed(()=>{
+            if (!storeRefs.realmIsRoot) {
+                return storeRefs.realmId.value;
+            }
+            return manager.data.value ? manager.data.value.realm_id : null;
+        });
         const isEditing = useIsEditing(manager.data);
         const updatedAt = useUpdatedAt(props.entity);
         function initForm() {
@@ -4840,7 +5681,8 @@ const APermissionForm = vue.defineComponent({
             }
         ]);
         const render = ()=>{
-            const name = formControls.buildFormGroup({
+            const children = [];
+            children.push(formControls.buildFormGroup({
                 validationMessages: translationsValidation.name.value,
                 validationSeverity: getVuelidateSeverity($v.value.name),
                 label: true,
@@ -4854,8 +5696,8 @@ const APermissionForm = vue.defineComponent({
                         disabled: manager.data.value && manager.data.value.built_in
                     }
                 })
-            });
-            const description = formControls.buildFormGroup({
+            }));
+            children.push(formControls.buildFormGroup({
                 validationMessages: translationsValidation.description.value,
                 validationSeverity: getVuelidateSeverity($v.value.description),
                 label: true,
@@ -4869,23 +5711,22 @@ const APermissionForm = vue.defineComponent({
                         rows: 4
                     }
                 })
-            });
-            const submitButton = buildFormSubmitWithTranslations({
+            }));
+            if (!realmId.value && !isEditing.value) {
+                children.push(createRealmFormPicker(form));
+            }
+            children.push(buildFormSubmitWithTranslations({
                 submit,
                 busy,
                 isEditing: isEditing.value,
                 invalid: $v.value.$invalid
-            }, translationsSubmit);
+            }, translationsSubmit));
             return vue.h('form', {
                 onSubmit ($event) {
                     $event.preventDefault();
                     return submit.apply(null);
                 }
-            }, [
-                name,
-                description,
-                submitButton
-            ]);
+            }, children);
         };
         return ()=>render();
     }
@@ -5702,7 +6543,7 @@ const AUserPasswordForm = vue.defineComponent({
         'failed'
     ],
     setup (props, ctx) {
-        const apiClient = injectAPIClient();
+        const apiClient = injectHTTPClient();
         const busy = vue.ref(false);
         const form = vue.reactive({
             password: '',
@@ -6336,7 +7177,7 @@ const AEntityDelete = vue.defineComponent({
         'failed'
     ],
     setup (props, ctx) {
-        const apiClient = injectAPIClient();
+        const apiClient = injectHTTPClient();
         const instance = vue.getCurrentInstance();
         const busy = vue.ref(false);
         const submit = wrapFnWithBusyState(busy, async ()=>{
@@ -6469,38 +7310,43 @@ var components = /*#__PURE__*/Object.freeze({
     LanguageSwitcherDropdown: LanguageSwitcherDropdown
 });
 
-function install(app, options) {
-    options = options || {};
-    if (options.apiClient) {
-        provideAPIClient(options.apiClient, app);
-    }
-    if (options.socketClientManager) {
-        provideSocketClientManager(options.socketClientManager, app);
-    }
-    if (options.store) {
-        provideStore(options.store, app);
+function installComponents(input) {
+    if (!input) {
+        return;
     }
-    installTranslator(app, {
-        locale: options.translatorLocale
-    });
-    const storeManager = installStoreManager(app, 'authup');
-    if (options.storeManager) {
-        applyStoreManagerOptions(storeManager, options.storeManager);
+    let componentsSelected;
+    if (typeof input !== 'boolean') {
+        componentsSelected = input;
     }
-    if (options.components) {
-        let componentsSelected;
-        if (typeof options.components !== 'boolean') {
-            componentsSelected = options.components;
+    Object.entries(components).forEach(([componentName, component])=>{
+        if (!Array.isArray(componentsSelected) || componentsSelected.indexOf(componentName) !== -1) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            app.component(componentName, component);
         }
-        Object.entries(components).forEach(([componentName, component])=>{
-            if (!Array.isArray(componentsSelected) || componentsSelected.indexOf(componentName) !== -1) {
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                app.component(componentName, component);
-            }
+    });
+}
+function install(app1, options) {
+    if (options.realtime) {
+        installSocketClientManager(app1, {
+            baseURL: options.realtimeURL || options.baseURL
         });
     }
+    installStore(app1, {
+        baseURL: options.baseURL,
+        cookieSet: options.cookieSet,
+        cookieGet: options.cookieGet,
+        cookieUnset: options.cookieUnset
+    });
+    installHTTPClient(app1, {
+        baseURL: options.baseURL
+    });
+    installTranslator(app1, {
+        locale: options.translatorLocale
+    });
+    installComponents(options.components);
 }
+
 var index = {
     install
 };
@@ -6525,7 +7371,6 @@ exports.AIdentityProviderProtocol = AIdentityProviderProtocol;
 exports.AIdentityProviderRoleAssignment = AIdentityProviderRoleAssignment;
 exports.AIdentityProviderRoleAssignments = AIdentityProviderRoleAssignments;
 exports.AIdentityProviders = AIdentityProviders;
-exports.APIClientSymbol = APIClientSymbol;
 exports.APagination = APagination;
 exports.APermission = APermission;
 exports.APermissionForm = APermissionForm;
@@ -6565,7 +7410,9 @@ exports.AUserRoleAssignment = AUserRoleAssignment;
 exports.AUserRoleAssignments = AUserRoleAssignments;
 exports.AUsers = AUsers;
 exports.EntityManagerError = EntityManagerError;
+exports.HTTPClientSymbol = HTTPClientSymbol;
 exports.LanguageSwitcherDropdown = LanguageSwitcherDropdown;
+exports.STORE_ID = STORE_ID;
 exports.SocketClientSymbol = SocketClientSymbol;
 exports.StoreSymbol = StoreSymbol;
 exports.VuelidateCustomRule = VuelidateCustomRule;
@@ -6586,29 +7433,40 @@ exports.defineListProps = defineListProps;
 exports.extendObjectProperties = extendObjectProperties;
 exports.extractVuelidateResultsFromChild = extractVuelidateResultsFromChild;
 exports.getVuelidateSeverity = getVuelidateSeverity;
+exports.hasHTTPClient = hasHTTPClient;
 exports.hasNormalizedSlot = hasNormalizedSlot;
+exports.hasStore = hasStore;
 exports.initFormAttributesFromSource = initFormAttributesFromSource;
 exports.inject = inject$1;
-exports.injectAPIClient = injectAPIClient;
+exports.injectHTTPClient = injectHTTPClient;
 exports.injectSocketClientManager = injectSocketClientManager;
 exports.injectStore = injectStore;
 exports.injectTranslatorLocale = injectTranslatorLocale;
 exports.install = install;
+exports.installHTTPClient = installHTTPClient;
+exports.installSocketClientManager = installSocketClientManager;
+exports.installStore = installStore;
 exports.installTranslator = installTranslator;
 exports.isQuerySortedDescByDate = isQuerySortedDescByDate;
 exports.isSocketClientManagerInjected = isSocketClientManagerInjected;
 exports.mergeListOptions = mergeListOptions;
 exports.normalizeSlot = normalizeSlot;
+exports.onChange = onChange;
 exports.provide = provide;
-exports.provideAPIClient = provideAPIClient;
+exports.provideHTTPClient = provideHTTPClient;
 exports.provideSocketClientManager = provideSocketClientManager;
 exports.provideStore = provideStore;
 exports.renderEntityAssignAction = renderEntityAssignAction;
 exports.storeToRefs = storeToRefs;
+exports.useAbilityCheck = useAbilityCheck;
+exports.useIsEditing = useIsEditing;
+exports.useRealmResourceWritableCheck = useRealmResourceWritableCheck;
+exports.useStore = useStore;
 exports.useTranslation = useTranslation;
 exports.useTranslationsForBaseValidation = useTranslationsForBaseValidation;
 exports.useTranslationsForGroup = useTranslationsForGroup;
 exports.useTranslationsForNestedValidation = useTranslationsForNestedValidation;
+exports.useUpdatedAt = useUpdatedAt;
 exports.wrapFnWithBusyState = wrapFnWithBusyState;
 module.exports = Object.assign(exports.default, exports);
 //# sourceMappingURL=index.cjs.map