@authup/client-web-kit 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/index.cjs

@@ -94,6 +94,91 @@ class PolicyEngine extends kit.PolicyEngine {
     }
 }
 
+/*
+ * 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.
+ */ var StoreDispatcherEventName = /*#__PURE__*/ function(StoreDispatcherEventName) {
+    StoreDispatcherEventName["LOGGING_IN"] = "loggingIn";
+    StoreDispatcherEventName["LOGGED_IN"] = "loggedIn";
+    StoreDispatcherEventName["LOGGING_OUT"] = "loggingOut";
+    StoreDispatcherEventName["LOGGED_OUT"] = "loggedOut";
+    StoreDispatcherEventName["RESOLVING"] = "resolving";
+    StoreDispatcherEventName["RESOLVED"] = "resolved";
+    StoreDispatcherEventName["ACCESS_TOKEN_UPDATED"] = "accessTokenUpdated";
+    StoreDispatcherEventName["ACCESS_TOKEN_EXPIRE_DATE_UPDATED"] = "accessTokenExpireDateUpdated";
+    StoreDispatcherEventName["REFRESH_TOKEN_UPDATED"] = "refreshTokenUpdated";
+    StoreDispatcherEventName["USER_UPDATED"] = "userUpdated";
+    StoreDispatcherEventName["REALM_UPDATED"] = "realmUpdated";
+    StoreDispatcherEventName["REALM_MANAGEMENT_UPDATED"] = "realmManagementUpdated";
+    return StoreDispatcherEventName;
+}({});
+
+// src/event-emitter.ts
+var EventEmitter = class {
+    on(type, handler) {
+        if (!this.all.has(type)) {
+            this.all.set(type, []);
+        }
+        const handlers = this.all.get(type);
+        handlers.push(handler);
+        return ()=>handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+    }
+    off(type, handler) {
+        if (!type) {
+            return this.all.clear();
+        }
+        const handlers = this.all.get(type);
+        if (handlers) {
+            if (handler) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            } else {
+                this.all.delete(type);
+            }
+        }
+    }
+    /**
+   * Invoke all handlers for the given type.
+   * If present, `'*'` handlers are invoked after type-matched handlers.
+   *
+   * Note: Manually firing `'*'` handlers is not supported.
+   *
+   * @param type The event type to invoke
+   * @param payload Any value to each handler
+   */ emit(type, ...payload) {
+        let handlers = this.all.get(type);
+        handlers?.slice().map((handler)=>{
+            handler(...payload);
+        });
+        handlers = this.all.get("*");
+        if (handlers) {
+            handlers.slice().map((handler)=>{
+                handler(type, payload);
+            });
+        }
+    }
+    constructor(all){
+        this.all = all || /* @__PURE__ */ new Map();
+    }
+};
+
+function createStoreDispatcher() {
+    return new EventEmitter();
+}
+
+const sym$1 = Symbol.for('AuthupStoreEventBus');
+function injectStoreDispatcher(app) {
+    const instance = inject$1(sym$1, app);
+    if (!instance) {
+        throw new Error('The store dispatcher has not been injected in the app context.');
+    }
+    return instance;
+}
+function provideStoreDispatcher(eventBus, app) {
+    provide(sym$1, eventBus, app);
+}
+
 function createPromiseShareWrapperFn(fn) {
     let promise;
     return (...args)=>{
@@ -111,41 +196,45 @@ function createPromiseShareWrapperFn(fn) {
         return promise;
     };
 }
-function createStore(context = {}) {
+function createStore(context) {
     const client = new coreHttpKit.Client({
         baseURL: context.baseURL
     });
-    const initialized = vue.ref(false);
-    const setInitialized = (value)=>{
-        initialized.value = value;
+    const cookiesRead = vue.ref(false);
+    const setCookiesRead = (value)=>{
+        cookiesRead.value = value;
     };
     // --------------------------------------------------------------------
-    const accessToken = vue.ref(undefined);
+    const accessToken = vue.ref(null);
     const setAccessToken = (input)=>{
         accessToken.value = input;
+        context.dispatcher.emit(StoreDispatcherEventName.ACCESS_TOKEN_UPDATED, input);
     };
     // --------------------------------------------------------------------
-    const accessTokenExpireDate = vue.ref(undefined);
+    const accessTokenExpireDate = vue.ref(null);
     const setAccessTokenExpireDate = (input)=>{
         if (typeof input === 'number' || typeof input === 'string') {
             accessTokenExpireDate.value = new Date(input); // verify microseconds or seconds
-            return;
+        } else {
+            accessTokenExpireDate.value = input;
         }
-        accessTokenExpireDate.value = input;
+        context.dispatcher.emit(StoreDispatcherEventName.ACCESS_TOKEN_EXPIRE_DATE_UPDATED, accessTokenExpireDate.value);
     };
     // --------------------------------------------------------------------
-    const refreshToken = vue.ref(undefined);
+    const refreshToken = vue.ref(null);
     const setRefreshToken = (input)=>{
         refreshToken.value = input;
+        context.dispatcher.emit(StoreDispatcherEventName.REFRESH_TOKEN_UPDATED, input);
     };
     // --------------------------------------------------------------------
-    const user = vue.ref(undefined);
-    const userId = vue.computed(()=>user.value ? user.value.id : undefined);
-    const setUser = (entity)=>{
-        user.value = entity;
+    const user = vue.ref(null);
+    const userId = vue.computed(()=>user.value ? user.value.id : null);
+    const setUser = (input)=>{
+        user.value = input;
+        context.dispatcher.emit(StoreDispatcherEventName.USER_UPDATED, input);
     };
     // --------------------------------------------------------------------
-    const realm = vue.ref(undefined);
+    const realm = vue.ref(null);
     const realmId = vue.computed(()=>realm.value ? realm.value.id : undefined);
     const realmName = vue.computed(()=>realm.value ? realm.value.name : undefined);
     const realmIsRoot = vue.computed(()=>{
@@ -154,14 +243,16 @@ function createStore(context = {}) {
         }
         return false;
     });
-    const setRealm = (entity)=>{
-        realm.value = entity;
+    const setRealm = (input)=>{
+        realm.value = input;
+        context.dispatcher.emit(StoreDispatcherEventName.REALM_UPDATED, input);
     };
-    const realmManagement = vue.ref(undefined);
+    const realmManagement = vue.ref(null);
     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 setRealmManagement = (input)=>{
+        realmManagement.value = input;
+        context.dispatcher.emit(StoreDispatcherEventName.REALM_MANAGEMENT_UPDATED, input);
     };
     // --------------------------------------------------------------------
     const permissionRepository = new kit.PermissionMemoryProvider();
@@ -170,6 +261,38 @@ function createStore(context = {}) {
         policyEngine: new PolicyEngine()
     });
     // --------------------------------------------------------------------
+    const cleanup = async ()=>{
+        const tempAccessToken = accessToken.value;
+        const tempRefreshToken = refreshToken.value;
+        setAccessToken(null);
+        setAccessTokenExpireDate(null);
+        setRefreshToken(null);
+        setUser(null);
+        setRealm(null);
+        setRealmManagement(null);
+        permissionRepository.setMany([]);
+        tokenResolved.value = false;
+        userResolved.value = false;
+        try {
+            if (tempAccessToken) {
+                await client.token.revoke({
+                    token: tempAccessToken
+                });
+            }
+        } catch (e) {
+        // ...
+        }
+        try {
+            if (tempRefreshToken) {
+                await client.token.revoke({
+                    token: tempRefreshToken
+                });
+            }
+        } catch (e) {
+        // ...
+        }
+    };
+    // --------------------------------------------------------------------
     const userResolved = vue.ref(false);
     const resolveUser = async ()=>{
         if (!accessToken.value || userResolved.value) {
@@ -214,29 +337,38 @@ function createStore(context = {}) {
         });
     };
     // --------------------------------------------------------------------
-    const handleTokenGrantResponse = (response)=>{
+    const applyTokenGrantResponse = (response)=>{
         const expireDate = new Date(Date.now() + response.expires_in * 1000);
         setAccessTokenExpireDate(expireDate);
         setAccessToken(response.access_token);
-        setRefreshToken(response.refresh_token);
+        if (response.refresh_token) {
+            setRefreshToken(response.refresh_token);
+        } else {
+            setRefreshToken(null);
+        }
     };
     // --------------------------------------------------------------------
     const refreshSession = createPromiseShareWrapperFn(async ()=>{
         if (!refreshToken.value) {
             throw new kit.TokenError('The access token can not be renewed.');
         }
-        return client.token.createWithRefreshToken({
-            refresh_token: refreshToken.value
-        }).then((r)=>handleTokenGrantResponse(r)).catch((e)=>{
-            logout();
-            return Promise.reject(e);
-        }).finally(()=>{
+        try {
+            const response = await client.token.createWithRefreshToken({
+                refresh_token: refreshToken.value
+            });
+            applyTokenGrantResponse(response);
+        } catch (e) {
+            await cleanup();
+            throw e;
+        } finally{
             tokenResolved.value = false;
             userResolved.value = false;
-        });
+        }
     });
     // --------------------------------------------------------------------
+    // todo: rename to reload() ?
     const resolveInternal = async ()=>{
+        context.dispatcher.emit(StoreDispatcherEventName.RESOLVING);
         try {
             if (!accessToken.value && refreshToken.value) {
                 await refreshSession();
@@ -250,49 +382,44 @@ function createStore(context = {}) {
         } catch (e) {
             if (coreHttpKit.isClientTokenExpiredError(e) && refreshToken.value) {
                 await refreshSession();
-                return resolveInternal();
+                await resolveToken();
+                await resolveUser();
+            } else {
+                throw e;
             }
-            throw e;
         }
-        return Promise.resolve();
+        context.dispatcher.emit(StoreDispatcherEventName.RESOLVED);
     };
     const resolve = createPromiseShareWrapperFn(resolveInternal);
     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) {
-            logout();
-            throw e;
-        }
+        context.dispatcher.emit(StoreDispatcherEventName.LOGGING_IN);
+        const response = await client.token.createWithPasswordGrant({
+            username: ctx.name,
+            password: ctx.password,
+            ...realmId.value ? {
+                realm_id: ctx.realmId
+            } : {}
+        });
+        applyTokenGrantResponse(response);
+        await resolveToken();
+        await resolveUser();
+        context.dispatcher.emit(StoreDispatcherEventName.LOGGED_IN);
     };
-    const logout = ()=>{
-        setAccessToken(undefined);
-        setAccessTokenExpireDate(undefined);
-        setRefreshToken(undefined);
-        setUser(undefined);
-        setRealm(undefined);
-        setRealmManagement(undefined);
-        tokenResolved.value = false;
-        userResolved.value = false;
+    const logout = async ()=>{
+        context.dispatcher.emit(StoreDispatcherEventName.LOGGING_OUT);
+        await cleanup();
+        context.dispatcher.emit(StoreDispatcherEventName.LOGGED_OUT);
     };
     return {
-        initialized,
-        setInitialized,
+        cookiesRead,
+        setCookiesRead,
         permissionChecker,
         login,
         logout,
         loggedIn,
         resolve,
-        handleTokenGrantResponse,
+        applyTokenGrantResponse,
         accessToken,
         setAccessToken,
         accessTokenExpireDate,
@@ -379,8 +506,8 @@ function shouldUpdate(dependencies, newCookies, oldCookies) {
     return false;
 }
 
-const StoreSymbol = Symbol.for('AuthupStore');
-function useStore(pinia, app) {
+const sym = Symbol.for('AuthupStore');
+function injectStore(pinia, app) {
     const instance = injectStoreFactory(app);
     if (!instance) {
         throw new Error('The store has not been injected in the app context.');
@@ -388,25 +515,28 @@ function useStore(pinia, app) {
     return instance(pinia);
 }
 function injectStoreFactory(app) {
-    const instance = inject$1(StoreSymbol, app);
+    const instance = inject$1(sym, app);
     if (!instance) {
         throw new Error('The store factory has not been injected in the app context.');
     }
     return instance;
 }
 function hasStoreFactory(app) {
-    return !!inject$1(StoreSymbol, app);
+    return !!inject$1(sym, app);
 }
 function provideStoreFactory(store, app) {
-    provide(StoreSymbol, store, app);
+    provide(sym, store, app);
 }
 
 function installStore(app, options = {}) {
     if (hasStoreFactory(app)) {
         return;
     }
+    const storeDispatcher = createStoreDispatcher();
+    provideStoreDispatcher(storeDispatcher, app);
     const storeFactory = pinia.defineStore(STORE_ID, ()=>createStore({
-            baseURL: options.baseURL
+            baseURL: options.baseURL,
+            dispatcher: storeDispatcher
         }));
     const store = storeFactory(options.pinia);
     let cookieGet;
@@ -434,11 +564,11 @@ function installStore(app, options = {}) {
         const cookies = useCookies();
         cookieUnset = cookies.remove;
     }
-    const initStore = ()=>{
-        if (store.initialized) {
+    const readCookies = ()=>{
+        if (store.cookiesRead) {
             return;
         }
-        store.setInitialized(true);
+        store.setCookiesRead(true);
         const keys = Object.values(coreHttpKit.CookieName);
         let value;
         for(let i = 0; i < keys.length; i++){
@@ -480,51 +610,60 @@ function installStore(app, options = {}) {
             }
         }
     };
-    store.$onAction((action)=>{
-        if (action.store.$id !== STORE_ID) {
-            return;
+    const maxAgeFn = ()=>{
+        if (!store.accessTokenExpireDate) {
+            return undefined;
         }
-        if (action.name === 'logout') {
-            cookieUnset(coreHttpKit.CookieName.ACCESS_TOKEN, {});
+        return Math.floor(Math.max(1000, new Date(`${store.accessTokenExpireDate}`).getTime() - Date.now()) / 1000);
+    };
+    storeDispatcher.on(StoreDispatcherEventName.ACCESS_TOKEN_EXPIRE_DATE_UPDATED, (input)=>{
+        if (input) {
+            cookieSet(coreHttpKit.CookieName.ACCESS_TOKEN_EXPIRE_DATE, input, {
+                maxAge: maxAgeFn()
+            });
+        } else {
             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, {});
         }
     });
-    initStore();
-    store.$subscribe((mutation, state)=>{
-        if (mutation.storeId !== STORE_ID) {
-            return;
-        }
-        let maxAge;
-        if (state.accessTokenExpireDate) {
-            maxAge = Math.floor(Math.max(1000, new Date(`${state.accessTokenExpireDate}`).getTime() - Date.now()) / 1000);
-        }
-        if (state.accessToken) {
-            cookieSet(coreHttpKit.CookieName.ACCESS_TOKEN, state.accessToken, {
-                maxAge
-            });
-        }
-        if (state.accessTokenExpireDate) {
-            cookieSet(coreHttpKit.CookieName.ACCESS_TOKEN_EXPIRE_DATE, state.accessTokenExpireDate, {
+    storeDispatcher.on(StoreDispatcherEventName.ACCESS_TOKEN_UPDATED, (input)=>{
+        if (input) {
+            const maxAge = maxAgeFn();
+            cookieSet(coreHttpKit.CookieName.ACCESS_TOKEN, input, {
                 maxAge
             });
+        } else {
+            cookieUnset(coreHttpKit.CookieName.ACCESS_TOKEN, {});
         }
-        if (state.refreshToken) {
-            cookieSet(coreHttpKit.CookieName.REFRESH_TOKEN, state.refreshToken, {});
+    });
+    storeDispatcher.on(StoreDispatcherEventName.REFRESH_TOKEN_UPDATED, (input)=>{
+        if (input) {
+            cookieSet(coreHttpKit.CookieName.REFRESH_TOKEN, input, {});
+        } else {
+            cookieUnset(coreHttpKit.CookieName.REFRESH_TOKEN, {});
         }
-        if (state.user) {
-            cookieSet(coreHttpKit.CookieName.USER, state.user, {});
+    });
+    storeDispatcher.on(StoreDispatcherEventName.USER_UPDATED, (input)=>{
+        if (input) {
+            cookieSet(coreHttpKit.CookieName.USER, input, {});
+        } else {
+            cookieUnset(coreHttpKit.CookieName.USER, {});
         }
-        if (state.realm) {
-            cookieSet(coreHttpKit.CookieName.REALM, state.realm, {});
+    });
+    storeDispatcher.on(StoreDispatcherEventName.REALM_UPDATED, (input)=>{
+        if (input) {
+            cookieSet(coreHttpKit.CookieName.REALM, input, {});
+        } else {
+            cookieUnset(coreHttpKit.CookieName.REALM, {});
         }
-        if (state.realmManagement) {
-            cookieSet(coreHttpKit.CookieName.REALM_MANAGEMENT, state.realmManagement, {});
+    });
+    storeDispatcher.on(StoreDispatcherEventName.REALM_MANAGEMENT_UPDATED, (input)=>{
+        if (input) {
+            cookieSet(coreHttpKit.CookieName.REALM_MANAGEMENT, input, {});
+        } else {
+            cookieUnset(coreHttpKit.CookieName.REALM_MANAGEMENT, {});
         }
     });
+    readCookies();
     provideStoreFactory(storeFactory, app);
 }
 
@@ -562,30 +701,36 @@ function installHTTPClient(app, options = {}) {
             });
         },
         tokenCreated: (response)=>{
-            store.handleTokenGrantResponse(response);
+            store.applyTokenGrantResponse(response);
         },
         tokenFailed: ()=>{
-            store.logout();
+            Promise.resolve().then(()=>store.logout());
         },
         timer: !options.isServer
     });
-    store.$subscribe((mutation, state)=>{
-        if (mutation.storeId !== STORE_ID) return;
-        if (state.accessToken) {
+    const storeDispatcher = injectStoreDispatcher(app);
+    const handleAccessTokenEvent = ()=>{
+        if (store.accessToken) {
             client.setAuthorizationHeader({
                 type: 'Bearer',
-                token: state.accessToken
+                token: store.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(expiresIn, ()=>refreshToken.value);
+    };
+    const handleAccessTokenExpireDateEvent = ()=>{
+        if (store.accessTokenExpireDate) {
+            const expiresIn = Math.floor((store.accessTokenExpireDate.getTime() - Date.now()) / 1000);
+            tokenHook.setTimer(expiresIn, ()=>refreshToken.value || undefined);
         }
-    });
+    };
+    storeDispatcher.on(StoreDispatcherEventName.ACCESS_TOKEN_UPDATED, ()=>handleAccessTokenEvent());
+    storeDispatcher.on(StoreDispatcherEventName.ACCESS_TOKEN_EXPIRE_DATE_UPDATED, ()=>handleAccessTokenExpireDateEvent());
+    handleAccessTokenEvent();
+    handleAccessTokenExpireDateEvent();
     provideHTTPClient(client, app);
 }
 
@@ -633,7 +778,7 @@ function renderEntityAssignAction(ctx) {
  * Author Peter Placzek (tada5hi)
  * For the full copyright and license information,
  * view the LICENSE file that was distributed with this source code.
- */ function defineListEvents() {
+ */ function defineResourceCollectionVEmitOptions() {
     return {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         created: (_item)=>true,
@@ -643,7 +788,7 @@ function renderEntityAssignAction(ctx) {
         updated: (_item)=>true
     };
 }
-function defineListProps() {
+function defineResourceCollectionVProps() {
     return {
         query: {
             type: Object,
@@ -818,7 +963,7 @@ function installSocketManager(app, options) {
     provideSocketManager(manager, app);
 }
 
-function createEntitySocket(ctx) {
+function create$2(ctx) {
     if (!isSocketManagerUsable()) {
         return {
             mount () {},
@@ -826,7 +971,7 @@ function createEntitySocket(ctx) {
         };
     }
     const socketManager = injectSocketManager();
-    const store = useStore();
+    const store = injectStore();
     const storeRefs = storeToRefs(store);
     const realmId = vue.computed(()=>{
         if (storeRefs.realmName.value === coreKit.REALM_MASTER_NAME) {
@@ -930,8 +1075,7 @@ function createEntitySocket(ctx) {
     vue.onUnmounted(()=>unmount());
     vue.watch(targetId, (val, oldValue)=>{
         if (val !== oldValue) {
-            unmount();
-            mount();
+            Promise.resolve().then(()=>unmount()).then(()=>mount());
         }
     });
     return {
@@ -939,6 +1083,9 @@ function createEntitySocket(ctx) {
         unmount
     };
 }
+function createResourceSocketManager(ctx) {
+    return create$2(ctx);
+}
 
 function isQuerySortedDescByDate(input) {
     if (Array.isArray(input)) {
@@ -955,7 +1102,7 @@ const merger = smob.createMerger({
     inPlace: false,
     priority: 'left'
 });
-function createList(context) {
+function create$1(context) {
     const data = vue.ref([]);
     const busy = vue.ref(false);
     const total = vue.ref(0);
@@ -1040,7 +1187,7 @@ function createList(context) {
         }
     }
     const handleCreated = buildListCreatedHandler(data, (cbEntity)=>{
-        total.value--;
+        total.value++;
         if (context.onCreated) {
             context.onCreated(cbEntity, meta.value);
         }
@@ -1073,7 +1220,7 @@ function createList(context) {
             noMore: renderOptions.noMore,
             body: renderOptions.body,
             loading: renderOptions.loading,
-            total,
+            total: total.value,
             load,
             busy: busy.value,
             data: data.value,
@@ -1082,16 +1229,19 @@ function createList(context) {
                 if (context.setup.emit) {
                     context.setup.emit('created', value);
                 }
+                handleCreated(value);
             },
             onDeleted: (value)=>{
                 if (context.setup.emit) {
                     context.setup.emit('deleted', value);
                 }
+                handleDeleted(value);
             },
             onUpdated: (value)=>{
                 if (context.setup.emit) {
                     context.setup.emit('updated', value);
                 }
+                handleUpdated(value);
             },
             slotItems: context.setup.slots || {}
         });
@@ -1129,7 +1279,7 @@ function createList(context) {
             handleDeleted(entity);
         };
         socketContext.realmId = realmId;
-        createEntitySocket(socketContext);
+        createResourceSocketManager(socketContext);
     }
     return {
         data,
@@ -1143,13 +1293,16 @@ function createList(context) {
         load
     };
 }
+function createResourceCollectionManager(context) {
+    return create$1(context);
+}
 
 /*
  * 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.
- */ class EntityManagerError extends Error {
+ */ class ResourceRecordError extends Error {
     static unresolvable() {
         return new this('Entity could not be resolved.');
     }
@@ -1196,7 +1349,7 @@ function createList(context) {
     return [];
 }
 
-function buildEntityManagerSlotProps(input) {
+function buildResourceVSlotProps(input) {
     return {
         ...input,
         error: vue.unref(input.error),
@@ -1205,7 +1358,7 @@ function buildEntityManagerSlotProps(input) {
         lockId: vue.unref(input.lockId)
     };
 }
-function defineEntityManagerEvents() {
+function defineResourceVEmitOptions() {
     return {
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         failed: (_item)=>true,
@@ -1219,7 +1372,7 @@ function defineEntityManagerEvents() {
         resolved: (_item)=>true
     };
 }
-function defineEntityManagerProps() {
+function defineResourceVProps() {
     return {
         entity: {
             type: Object
@@ -1239,7 +1392,7 @@ function defineEntityManagerProps() {
     };
 }
 
-function createEntityManager(ctx) {
+function create(ctx) {
     const client = injectHTTPClient();
     let domainAPI;
     if (kit.hasOwnProperty(client, ctx.type)) {
@@ -1391,7 +1544,7 @@ function createEntityManager(ctx) {
         socketContext.realmId = realmId;
         socketContext.target = true;
         socketContext.targetId = entityId;
-        socket = createEntitySocket(socketContext);
+        socket = createResourceSocketManager(socketContext);
     }
     const error = vue.ref(undefined);
     const resolveByProps = ()=>{
@@ -1500,7 +1653,7 @@ function createEntityManager(ctx) {
         await resolve(resolveContext);
         if (typeof entity.value === 'undefined') {
             if (!error.value) {
-                throw EntityManagerError.unresolvable();
+                throw ResourceRecordError.unresolvable();
             }
             // eslint-disable-next-line no-throw-literal
             throw error.value;
@@ -1529,7 +1682,7 @@ function createEntityManager(ctx) {
             return typeof content === 'function' ? content() : content;
         }
         if (hasNormalizedSlot('default', ctx.setup.slots)) {
-            return normalizeSlot('default', buildEntityManagerSlotProps(manager), ctx.setup.slots);
+            return normalizeSlot('default', buildResourceVSlotProps(manager), ctx.setup.slots);
         }
         return typeof content === 'function' ? content() : content;
     };
@@ -1544,6 +1697,9 @@ function createEntityManager(ctx) {
     };
     return manager;
 }
+function createResourceManager(ctx) {
+    return create(ctx);
+}
 
 /*
  * Copyright (c) 2022.
@@ -2092,7 +2248,7 @@ function createPermissionCheckerReactiveFn(ctx = {}) {
     if (ctx.store) {
         store = ctx.store;
     } else {
-        store = useStore(ctx.pinia, ctx.app);
+        store = injectStore(ctx.pinia, ctx.app);
     }
     const storeRefs = storeToRefs(store);
     return (ctx)=>{
@@ -2147,11 +2303,11 @@ function createPermissionCheckerReactiveFn(ctx = {}) {
 }
 
 const AClient = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.CLIENT}`,
             setup,
             props
@@ -2199,7 +2355,7 @@ function usePermissionCheck(ctx) {
 }
 
 function useRealmResourceWritableCheck(realmId) {
-    const store = useStore();
+    const store = injectStore();
     const { realm } = pinia.storeToRefs(store);
     return vue.computed(()=>{
         const realmIdRaw = vue.unref(realmId);
@@ -2208,11 +2364,11 @@ function useRealmResourceWritableCheck(realmId) {
 }
 
 const ARealm = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.REALM}`,
             props,
             setup
@@ -2234,7 +2390,7 @@ const ARealmForm = vue.defineComponent({
             default: undefined
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -2257,7 +2413,7 @@ const ARealmForm = vue.defineComponent({
                 maxLength: validators.maxLength(4096)
             }
         }, form);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.REALM}`,
             setup: ctx,
             props
@@ -2392,11 +2548,11 @@ const ARealmForm = vue.defineComponent({
 });
 
 const ARealms = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.REALM}`,
             props,
             setup: ctx
@@ -2561,7 +2717,7 @@ const AClientForm = vue.defineComponent({
             default: undefined
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -2603,7 +2759,7 @@ const AClientForm = vue.defineComponent({
                 maxLength: validators.maxLength(256)
             }
         }, form);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.CLIENT}`,
             setup: ctx,
             props
@@ -2876,11 +3032,11 @@ const AClientForm = vue.defineComponent({
 });
 
 const AClients = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.CLIENT}`,
             props,
             setup: ctx
@@ -2905,11 +3061,11 @@ const AClients = vue.defineComponent({
 });
 
 const AClientScope = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.CLIENT_SCOPE}`,
             props,
             setup
@@ -2924,11 +3080,11 @@ const AClientScope = vue.defineComponent({
 });
 
 const AClientScopes = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.CLIENT_SCOPE}`,
             props,
             setup: ctx
@@ -2981,7 +3137,7 @@ const AScopeForm = vue.defineComponent({
             type: Object
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -3007,9 +3163,9 @@ const AScopeForm = vue.defineComponent({
             },
             realm_id: {}
         }, form);
-        const store = useStore();
+        const store = injectStore();
         const storeRefs = storeToRefs(store);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.SCOPE}`,
             setup: ctx,
             props
@@ -3128,11 +3284,11 @@ const AScopeForm = vue.defineComponent({
 });
 
 const AScopes = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: coreKit.DomainType.SCOPE,
             props,
             setup: ctx
@@ -3157,11 +3313,11 @@ const AScopes = vue.defineComponent({
 });
 
 const AScope = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.SCOPE}`,
             props,
             setup
@@ -3180,9 +3336,9 @@ const AClientScopeAssignment = vue.defineComponent({
         clientId: String,
         scopeId: String
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.CLIENT_SCOPE}`,
             setup,
             socket: {
@@ -3231,11 +3387,11 @@ const AClientScopeAssignments = vue.defineComponent({
 });
 
 const AIdentityProvider = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.IDENTITY_PROVIDER}`,
             props,
             setup
@@ -3854,9 +4010,9 @@ const AIdentityProviderLdapForm = vue.defineComponent({
             default: undefined
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.IDENTITY_PROVIDER}`,
             setup: ctx,
             props
@@ -4071,7 +4227,11 @@ const AIdentityProviderPreset = vue.defineComponent({
     }
 });
 
-const AIdentityProviderPicker = vue.defineComponent({
+var _sfc_main = vue.defineComponent({
+    components: {
+        AIdentityProviderPreset,
+        AIdentityProviderProtocol
+    },
     props: {
         protocol: {
             type: String
@@ -4084,113 +4244,139 @@ const AIdentityProviderPicker = vue.defineComponent({
         'pick'
     ],
     setup (props, setup) {
-        const protocols = [];
-        const presets = [];
-        Object.values(coreKit.IdentityProviderProtocol).map((id)=>{
-            protocols.push({
-                id
-            });
-            return id;
-        });
-        Object.values(coreKit.IdentityProviderPreset).map((id)=>{
-            presets.push({
-                id
-            });
-            return id;
-        });
-        const pick = (ctx)=>{
-            setup.emit('pick', ctx);
+        const protocols = Object.values(coreKit.IdentityProviderProtocol);
+        const presets = Object.values(coreKit.IdentityProviderPreset);
+        const pickProtocol = (protocol)=>{
+            setup.emit('pick', 'protocol', protocol);
         };
-        return ()=>{
-            const protocolNode = listControls.buildList({
-                data: protocols,
-                header: {
-                    content: vue.h('h6', 'Protocols')
-                },
-                body: {
-                    class: 'd-flex flex-row',
-                    item: {
-                        class: [
-                            'me-1 list-item'
-                        ],
-                        icon: false,
-                        content: (item)=>vue.h(AIdentityProviderProtocol, {
-                                id: item.id
-                            }, {
-                                default: (element)=>[
-                                        vue.h('i', {
-                                            class: [
-                                                element.icon,
-                                                'pe-1'
-                                            ]
-                                        }),
-                                        element.name,
-                                        vue.h('button', {
-                                            class: 'btn btn-xs btn-dark ms-1',
-                                            onClick ($event) {
-                                                $event.preventDefault();
-                                                pick({
-                                                    protocol: item.id
-                                                });
-                                            }
-                                        }, [
-                                            vue.h('i', {
-                                                class: 'fa fa-plus'
-                                            })
-                                        ])
-                                    ]
-                            })
-                    }
-                }
-            });
-            const protocolNodeConfigurationNode = listControls.buildList({
-                data: presets,
-                header: {
-                    content: vue.h('h6', 'Presets')
-                },
-                body: {
-                    class: 'd-flex flex-row',
-                    item: {
-                        class: 'me-1 list-item',
-                        icon: false,
-                        content: (preset)=>vue.h(AIdentityProviderPreset, {
-                                id: preset.id
-                            }, {
-                                default: (item)=>vue.h('div', [
-                                        vue.h('i', {
-                                            class: [
-                                                item.icon,
-                                                'pe-1'
-                                            ]
-                                        }),
-                                        item.name,
-                                        vue.h('button', {
-                                            class: 'btn btn-xs btn-dark ms-1',
-                                            onClick ($event) {
-                                                $event.preventDefault();
-                                                pick({
-                                                    preset: preset.id,
-                                                    protocol: coreKit.getIdentityProviderProtocolForPreset(preset.id)
-                                                });
-                                            }
-                                        }, [
-                                            vue.h('i', {
-                                                class: 'fa fa-plus'
-                                            })
-                                        ])
-                                    ])
-                            })
-                    }
-                }
-            });
-            return [
-                protocolNode,
-                protocolNodeConfigurationNode
-            ];
+        const pickPreset = (preset)=>{
+            setup.emit('pick', 'preset', preset);
+        };
+        return {
+            protocols,
+            presets,
+            pickProtocol,
+            pickPreset
         };
     }
 });
 
+var _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+
+const _hoisted_1 = {
+    class: "d-flex flex-column gap-2"
+};
+const _hoisted_2 = {
+    class: "d-flex flex-row gap-2 flex-wrap"
+};
+const _hoisted_3 = [
+    "onClick"
+];
+const _hoisted_4 = {
+    class: "d-flex flex-row gap-2 flex-wrap"
+};
+const _hoisted_5 = [
+    "onClick"
+];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+    const _component_AIdentityProviderProtocol = vue.resolveComponent("AIdentityProviderProtocol");
+    const _component_AIdentityProviderPreset = vue.resolveComponent("AIdentityProviderPreset");
+    return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+        vue.createElementVNode("div", null, [
+            _cache[0] || (_cache[0] = vue.createElementVNode("h6", null, "Protocols", -1)),
+            vue.createElementVNode("div", _hoisted_2, [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.protocols, (item, key)=>{
+                    return vue.openBlock(), vue.createBlock(_component_AIdentityProviderProtocol, {
+                        key,
+                        id: item
+                    }, {
+                        default: vue.withCtx((props)=>[
+                                vue.createElementVNode("div", {
+                                    class: vue.normalizeClass([
+                                        {
+                                            "active": item === _ctx.protocol && !_ctx.preset
+                                        },
+                                        "d-flex flex-column gap-1 text-center identity-provider-picker-item"
+                                    ]),
+                                    onClick: vue.withModifiers(($event)=>_ctx.pickProtocol(item), [
+                                        "prevent"
+                                    ])
+                                }, [
+                                    vue.createElementVNode("div", null, [
+                                        vue.createElementVNode("i", {
+                                            class: vue.normalizeClass([
+                                                "fa-2x",
+                                                props.icon
+                                            ])
+                                        }, null, 2)
+                                    ]),
+                                    vue.createElementVNode("div", null, vue.toDisplayString(props.name), 1)
+                                ], 10, _hoisted_3)
+                            ]),
+                        _: 2
+                    }, 1032, [
+                        "id"
+                    ]);
+                }), 128))
+            ])
+        ]),
+        vue.createElementVNode("div", null, [
+            _cache[1] || (_cache[1] = vue.createElementVNode("h6", null, "Presets", -1)),
+            vue.createElementVNode("div", _hoisted_4, [
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.presets, (item, key)=>{
+                    return vue.openBlock(), vue.createBlock(_component_AIdentityProviderPreset, {
+                        key,
+                        id: item
+                    }, {
+                        default: vue.withCtx((props)=>[
+                                vue.createElementVNode("div", {
+                                    class: vue.normalizeClass([
+                                        {
+                                            "active": item === _ctx.preset
+                                        },
+                                        "d-flex flex-column gap-1 text-center identity-provider-picker-item"
+                                    ]),
+                                    onClick: vue.withModifiers(($event)=>_ctx.pickPreset(item), [
+                                        "prevent"
+                                    ])
+                                }, [
+                                    vue.createElementVNode("div", null, [
+                                        vue.createElementVNode("i", {
+                                            class: vue.normalizeClass([
+                                                "fa-2x",
+                                                props.icon
+                                            ])
+                                        }, null, 2)
+                                    ]),
+                                    vue.createElementVNode("div", null, vue.toDisplayString(props.name), 1)
+                                ], 10, _hoisted_5)
+                            ]),
+                        _: 2
+                    }, 1032, [
+                        "id"
+                    ]);
+                }), 128))
+            ])
+        ])
+    ]);
+}
+var AIdentityProviderPicker = /* @__PURE__ */ _export_sfc(_sfc_main, [
+    [
+        "render",
+        _sfc_render
+    ],
+    [
+        "__scopeId",
+        "data-v-0df1e731"
+    ]
+]);
+
 const AIdentityProviderOAuth2ClientFields = vue.defineComponent({
     props: {
         entity: {
@@ -4471,10 +4657,10 @@ const AIdentityProviderOAuth2Form = vue.defineComponent({
             type: String
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const apiClient = injectHTTPClient();
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.IDENTITY_PROVIDER}`,
             setup: ctx,
             props
@@ -4728,17 +4914,16 @@ const AIdentityProviderForm = vue.defineComponent({
         set();
         onChange(updatedAt, ()=>set());
         const renderPicker = ()=>vue.h(AIdentityProviderPicker, {
-                onPick (value) {
-                    if (value.protocol) {
-                        protocol.value = value.protocol;
-                    } else {
-                        protocol.value = null;
-                    }
-                    if (value.preset) {
-                        preset.value = value.preset;
-                    } else {
-                        preset.value = null;
+                protocol: protocol.value,
+                preset: preset.value,
+                onPick (type, value) {
+                    if (type === 'preset') {
+                        preset.value = value;
+                        protocol.value = `${coreKit.getIdentityProviderProtocolForPreset(value)}`;
+                        return;
                     }
+                    protocol.value = value;
+                    preset.value = null;
                 }
             });
         const render = (node)=>{
@@ -4810,11 +4995,11 @@ const AIdentityProviderForm = vue.defineComponent({
 });
 
 const AIdentityProviders = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.IDENTITY_PROVIDER}`,
             props,
             setup: ctx
@@ -4882,7 +5067,7 @@ const AIdentityProviderRoleAssignment = vue.defineComponent({
             required: true
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
         const display = vue.ref(false);
         const toggleDisplay = ()=>{
@@ -4910,7 +5095,7 @@ const AIdentityProviderRoleAssignment = vue.defineComponent({
                 key: TranslatorTranslationDefaultKey.VALUE_IS_REGEX
             }
         ]);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.IDENTITY_PROVIDER_ROLE_MAPPING}`,
             setup,
             socket: {
@@ -5091,7 +5276,7 @@ const ARoleForm = vue.defineComponent({
             default: undefined
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -5116,9 +5301,9 @@ const ARoleForm = vue.defineComponent({
             },
             realm_id: {}
         }, form);
-        const store = useStore();
+        const store = injectStore();
         const storeRefs = storeToRefs(store);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROLE}`,
             setup: ctx,
             props
@@ -5222,11 +5407,11 @@ const ARoleForm = vue.defineComponent({
 });
 
 const ARoles = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.ROLE}`,
             props,
             setup: ctx
@@ -5251,11 +5436,11 @@ const ARoles = vue.defineComponent({
 });
 
 const ARole = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROLE}`,
             props,
             setup
@@ -5291,11 +5476,11 @@ const AIdentityProviderRoleAssignments = vue.defineComponent({
 });
 
 const APermission = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.PERMISSION}`,
             setup,
             props
@@ -5347,7 +5532,7 @@ const APermissionForm = vue.defineComponent({
             type: Object
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -5372,9 +5557,9 @@ const APermissionForm = vue.defineComponent({
             },
             realm_id: {}
         }, form);
-        const store = useStore();
+        const store = injectStore();
         const storeRefs = storeToRefs(store);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.PERMISSION}`,
             setup: ctx,
             props
@@ -5481,11 +5666,11 @@ const APermissionForm = vue.defineComponent({
 });
 
 const APermissions = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, setup) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.PERMISSION}`,
             props,
             setup
@@ -5514,9 +5699,9 @@ const ARobotPermissionAssignment = vue.defineComponent({
         robotId: String,
         permissionId: String
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROBOT_PERMISSION}`,
             setup,
             socket: {
@@ -5546,11 +5731,11 @@ const ARobotPermissionAssignment = vue.defineComponent({
 });
 
 const ARobot = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROBOT}`,
             props,
             setup
@@ -5579,7 +5764,7 @@ const ARobotForm = vue.defineComponent({
             default: undefined
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -5606,7 +5791,7 @@ const ARobotForm = vue.defineComponent({
                 maxLength: validators.maxLength(256)
             }
         }, form);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROBOT}`,
             setup: ctx,
             props
@@ -5808,11 +5993,11 @@ const ARobotForm = vue.defineComponent({
 });
 
 const ARobots = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.ROBOT}`,
             props,
             setup: ctx
@@ -5860,9 +6045,9 @@ const ARolePermissionAssignment = vue.defineComponent({
         roleId: String,
         permissionId: String
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROLE_PERMISSION}`,
             setup,
             socket: {
@@ -5934,9 +6119,9 @@ const AUserPermissionAssignment = vue.defineComponent({
         userId: String,
         permissionId: String
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.USER_PERMISSION}`,
             setup,
             socket: {
@@ -5985,11 +6170,11 @@ const AUserPermissionAssignments = vue.defineComponent({
 });
 
 const AUser = vue.defineComponent({
-    props: defineEntityManagerProps(),
-    emits: defineEntityManagerEvents(),
+    props: defineResourceVProps(),
+    emits: defineResourceVEmitOptions(),
     slots: Object,
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.USER}`,
             props,
             setup
@@ -6018,7 +6203,7 @@ const AUserForm = vue.defineComponent({
             default: true
         }
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, ctx) {
         const busy = vue.ref(false);
         const form = vue.reactive({
@@ -6050,7 +6235,7 @@ const AUserForm = vue.defineComponent({
                 required: validators.required
             }
         }, form);
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.USER}`,
             setup: ctx,
             props
@@ -6262,11 +6447,11 @@ const AUserForm = vue.defineComponent({
 });
 
 const AUsers = vue.defineComponent({
-    props: defineListProps(),
+    props: defineResourceCollectionVProps(),
     slots: Object,
-    emits: defineListEvents(),
+    emits: defineResourceCollectionVEmitOptions(),
     setup (props, ctx) {
-        const { render } = createList({
+        const { render } = createResourceCollectionManager({
             type: `${coreKit.DomainType.USER}`,
             props,
             setup: ctx
@@ -6447,9 +6632,9 @@ const ARobotRoleAssignment = vue.defineComponent({
         roleId: String,
         robotId: String
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.ROBOT_ROLE}`,
             setup,
             socket: {
@@ -6514,9 +6699,9 @@ const AUserRoleAssignment = vue.defineComponent({
         roleId: String,
         userId: String
     },
-    emits: defineEntityManagerEvents(),
+    emits: defineResourceVEmitOptions(),
     async setup (props, setup) {
-        const manager = createEntityManager({
+        const manager = createResourceManager({
             type: `${coreKit.DomainType.USER_ROLE}`,
             setup,
             socket: {
@@ -7177,33 +7362,34 @@ exports.AUserPermissionAssignments = AUserPermissionAssignments;
 exports.AUserRoleAssignment = AUserRoleAssignment;
 exports.AUserRoleAssignments = AUserRoleAssignments;
 exports.AUsers = AUsers;
-exports.EntityManagerError = EntityManagerError;
 exports.HTTPClientSymbol = HTTPClientSymbol;
 exports.LanguageSwitcherDropdown = LanguageSwitcherDropdown;
+exports.ResourceRecordError = ResourceRecordError;
 exports.STORE_ID = STORE_ID;
 exports.SocketClientSymbol = SocketClientSymbol;
-exports.StoreSymbol = StoreSymbol;
+exports.StoreDispatcherEventName = StoreDispatcherEventName;
 exports.TranslatorTranslationClientKey = TranslatorTranslationClientKey;
 exports.TranslatorTranslationDefaultKey = TranslatorTranslationDefaultKey;
 exports.TranslatorTranslationGroup = TranslatorTranslationGroup;
 exports.TranslatorTranslationVuecsKey = TranslatorTranslationVuecsKey;
 exports.VuelidateCustomRule = VuelidateCustomRule;
 exports.VuelidateCustomRuleKey = VuelidateCustomRuleKey;
-exports.buildEntityManagerSlotProps = buildEntityManagerSlotProps;
 exports.buildFormSubmitWithTranslations = buildFormSubmitWithTranslations;
 exports.buildListCreatedHandler = buildListCreatedHandler;
 exports.buildListDeletedHandler = buildListDeletedHandler;
 exports.buildListUpdatedHandler = buildListUpdatedHandler;
-exports.createEntityManager = createEntityManager;
+exports.buildResourceVSlotProps = buildResourceVSlotProps;
 exports.createFormSubmitTranslations = createFormSubmitTranslations;
-exports.createList = createList;
 exports.createPermissionCheckerReactiveFn = createPermissionCheckerReactiveFn;
+exports.createResourceCollectionManager = createResourceCollectionManager;
+exports.createResourceManager = createResourceManager;
 exports.createStore = createStore;
+exports.createStoreDispatcher = createStoreDispatcher;
 exports.default = index;
-exports.defineEntityManagerEvents = defineEntityManagerEvents;
-exports.defineEntityManagerProps = defineEntityManagerProps;
-exports.defineListEvents = defineListEvents;
-exports.defineListProps = defineListProps;
+exports.defineResourceCollectionVEmitOptions = defineResourceCollectionVEmitOptions;
+exports.defineResourceCollectionVProps = defineResourceCollectionVProps;
+exports.defineResourceVEmitOptions = defineResourceVEmitOptions;
+exports.defineResourceVProps = defineResourceVProps;
 exports.extendObjectProperties = extendObjectProperties;
 exports.extractVuelidateResultsFromChild = extractVuelidateResultsFromChild;
 exports.getVuelidateSeverity = getVuelidateSeverity;
@@ -7214,6 +7400,8 @@ exports.initFormAttributesFromSource = initFormAttributesFromSource;
 exports.inject = inject$1;
 exports.injectHTTPClient = injectHTTPClient;
 exports.injectSocketManager = injectSocketManager;
+exports.injectStore = injectStore;
+exports.injectStoreDispatcher = injectStoreDispatcher;
 exports.injectStoreFactory = injectStoreFactory;
 exports.injectTranslatorLocale = injectTranslatorLocale;
 exports.install = install;
@@ -7229,13 +7417,13 @@ exports.onChange = onChange;
 exports.provide = provide;
 exports.provideHTTPClient = provideHTTPClient;
 exports.provideSocketManager = provideSocketManager;
+exports.provideStoreDispatcher = provideStoreDispatcher;
 exports.provideStoreFactory = provideStoreFactory;
 exports.renderEntityAssignAction = renderEntityAssignAction;
 exports.storeToRefs = storeToRefs;
 exports.useIsEditing = useIsEditing;
 exports.usePermissionCheck = usePermissionCheck;
 exports.useRealmResourceWritableCheck = useRealmResourceWritableCheck;
-exports.useStore = useStore;
 exports.useTranslation = useTranslation;
 exports.useTranslationsForBaseValidation = useTranslationsForBaseValidation;
 exports.useTranslationsForGroup = useTranslationsForGroup;