@go-avro/avro-js 0.0.37 → 0.0.38

package/dist/client/QueryClient.js

@@ -1,11 +1,11 @@
-import io from 'socket.io-client';
-import { useMutation, useQueryClient } from '@tanstack/react-query';
+import io from "socket.io-client";
+import { useMutation, useQueryClient, } from "@tanstack/react-query";
 import { v4 as uuidv4 } from "uuid";
-import { Job, LoginResponse } from '../types/api';
-import { AuthState } from '../types/auth';
-import { StandardError } from '../types/error';
+import { Job, LoginResponse, } from "../types/api";
+import { AuthState } from "../types/auth";
+import { StandardError } from "../types/error";
 function isBulkEvent(c) {
-    return 'invalidateKeys' in c;
+    return "invalidateKeys" in c;
 }
 /**
  * Maps socket event names to cache-update strategies.
@@ -18,75 +18,185 @@ function isBulkEvent(c) {
  */
 const SOCKET_EVENT_CONFIG = {
     // ── Company ──
-    create_company: { entityKey: 'companies', action: 'create', fetchPath: (id) => `/company/${id}` },
-    update_company: { entityKey: 'companies', action: 'update', fetchPath: (id) => `/company/${id}` },
-    delete_company: { entityKey: 'companies', action: 'delete', fetchPath: null },
+    create_company: {
+        entityKey: "companies",
+        action: "create",
+        fetchPath: (id) => `/company/${id}`,
+    },
+    update_company: {
+        entityKey: "companies",
+        action: "update",
+        fetchPath: (id) => `/company/${id}`,
+    },
+    delete_company: { entityKey: "companies", action: "delete", fetchPath: null },
     // ── Users (no single-entity socket events) ──
-    user_updated: { invalidateKeys: [['users'], ['user']] },
-    update_users: { invalidateKeys: [['users'], ['user']] },
+    user_updated: { invalidateKeys: [["users"], ["user"]] },
+    update_users: { invalidateKeys: [["users"], ["user"]] },
     // ── Jobs ──
-    create_job: { entityKey: 'jobs', action: 'create', fetchPath: (id) => `/job/${id}`, construct: (d) => new Job(d) },
-    update_job: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, construct: (d) => new Job(d) },
-    delete_job: { entityKey: 'jobs', action: 'delete', fetchPath: null },
-    update_jobs: { invalidateKeys: [['jobs'], ['infinite', 'jobs']] },
-    delete_jobs: { invalidateKeys: [['jobs'], ['infinite', 'jobs']] },
+    create_job: {
+        entityKey: "jobs",
+        action: "create",
+        fetchPath: (id) => `/job/${id}`,
+        construct: (d) => new Job(d),
+    },
+    update_job: {
+        entityKey: "jobs",
+        action: "update",
+        fetchPath: (id) => `/job/${id}`,
+        construct: (d) => new Job(d),
+    },
+    delete_job: { entityKey: "jobs", action: "delete", fetchPath: null },
+    update_jobs: { invalidateKeys: [["jobs"], ["infinite", "jobs"]] },
+    delete_jobs: { invalidateKeys: [["jobs"], ["infinite", "jobs"]] },
     // ── Routes ──
-    create_route: { entityKey: 'routes', action: 'create', fetchPath: (id) => `/route/${id}` },
-    update_route: { entityKey: 'routes', action: 'update', fetchPath: (id) => `/route/${id}` },
-    delete_route: { entityKey: 'routes', action: 'delete', fetchPath: null },
+    create_route: {
+        entityKey: "routes",
+        action: "create",
+        fetchPath: (id) => `/route/${id}`,
+    },
+    update_route: {
+        entityKey: "routes",
+        action: "update",
+        fetchPath: (id) => `/route/${id}`,
+    },
+    delete_route: { entityKey: "routes", action: "delete", fetchPath: null },
     // ── Events (also refetch parent job — overdueness, last_event, etc.) ──
-    create_event: { entityKey: 'events', action: 'create', fetchPath: (id) => `/event/${id}`, relatedRefetch: [{ entityKey: 'jobs', idField: 'job_id', fetchPath: (id) => `/job/${id}`, construct: (d) => new Job(d) }] },
-    update_event: { entityKey: 'events', action: 'update', fetchPath: (id) => `/event/${id}`, relatedRefetch: [{ entityKey: 'jobs', idField: 'job_id', fetchPath: (id) => `/job/${id}`, construct: (d) => new Job(d) }] },
-    delete_event: { entityKey: 'events', action: 'delete', fetchPath: null, relatedRefetch: [{ entityKey: 'jobs', idField: 'job_id', fetchPath: (id) => `/job/${id}`, construct: (d) => new Job(d) }] },
-    update_events: { invalidateKeys: [['events']] },
+    create_event: {
+        entityKey: "events",
+        action: "create",
+        fetchPath: (id) => `/event/${id}`,
+        relatedRefetch: [
+            {
+                entityKey: "jobs",
+                idField: "job_id",
+                fetchPath: (id) => `/job/${id}`,
+                construct: (d) => new Job(d),
+            },
+        ],
+    },
+    update_event: {
+        entityKey: "events",
+        action: "update",
+        fetchPath: (id) => `/event/${id}`,
+        relatedRefetch: [
+            {
+                entityKey: "jobs",
+                idField: "job_id",
+                fetchPath: (id) => `/job/${id}`,
+                construct: (d) => new Job(d),
+            },
+        ],
+    },
+    delete_event: {
+        entityKey: "events",
+        action: "delete",
+        fetchPath: null,
+        relatedRefetch: [
+            {
+                entityKey: "jobs",
+                idField: "job_id",
+                fetchPath: (id) => `/job/${id}`,
+                construct: (d) => new Job(d),
+            },
+        ],
+    },
+    update_events: { invalidateKeys: [["events"]] },
     // ── Teams ──
-    create_team: { entityKey: 'teams', action: 'create', fetchPath: null },
-    update_team: { entityKey: 'teams', action: 'update', fetchPath: null },
-    delete_team: { entityKey: 'teams', action: 'delete', fetchPath: null },
-    update_teams: { invalidateKeys: [['teams']] },
+    create_team: { entityKey: "teams", action: "create", fetchPath: null },
+    update_team: { entityKey: "teams", action: "update", fetchPath: null },
+    delete_team: { entityKey: "teams", action: "delete", fetchPath: null },
+    update_teams: { invalidateKeys: [["teams"]] },
     // ── Bills ──
-    create_bill: { entityKey: 'bills', action: 'create', fetchPath: (id) => `/bill/${id}` },
-    delete_bill: { entityKey: 'bills', action: 'delete', fetchPath: null },
-    update_bills: { invalidateKeys: [['bills']] },
+    create_bill: {
+        entityKey: "bills",
+        action: "create",
+        fetchPath: (id) => `/bill/${id}`,
+    },
+    delete_bill: { entityKey: "bills", action: "delete", fetchPath: null },
+    update_bills: { invalidateKeys: [["bills"]] },
     // ── Sessions ──
-    create_session: { entityKey: 'sessions', action: 'create', fetchPath: null },
-    update_session: { entityKey: 'sessions', action: 'update', fetchPath: null },
+    create_session: { entityKey: "sessions", action: "create", fetchPath: null },
+    update_session: { entityKey: "sessions", action: "update", fetchPath: null },
     // ── Catalog Items ──
-    create_catalog_item: { entityKey: 'catalog_items', action: 'create', fetchPath: (id) => `/catalog_item/${id}` },
-    update_catalog_item: { entityKey: 'catalog_items', action: 'update', fetchPath: (id) => `/catalog_item/${id}` },
-    delete_catalog_item: { entityKey: 'catalog_items', action: 'delete', fetchPath: null },
+    create_catalog_item: {
+        entityKey: "catalog_items",
+        action: "create",
+        fetchPath: (id) => `/catalog_item/${id}`,
+    },
+    update_catalog_item: {
+        entityKey: "catalog_items",
+        action: "update",
+        fetchPath: (id) => `/catalog_item/${id}`,
+    },
+    delete_catalog_item: {
+        entityKey: "catalog_items",
+        action: "delete",
+        fetchPath: null,
+    },
     // ── Groups ──
-    create_group: { entityKey: 'groups', action: 'create', fetchPath: null },
-    update_group: { entityKey: 'groups', action: 'update', fetchPath: null },
-    delete_group: { entityKey: 'groups', action: 'delete', fetchPath: null },
+    create_group: { entityKey: "groups", action: "create", fetchPath: null },
+    update_group: { entityKey: "groups", action: "update", fetchPath: null },
+    delete_group: { entityKey: "groups", action: "delete", fetchPath: null },
     // ── Labels ──
-    create_label: { entityKey: 'labels', action: 'create', fetchPath: null },
-    update_label: { entityKey: 'labels', action: 'update', fetchPath: null },
-    delete_label: { entityKey: 'labels', action: 'delete', fetchPath: null },
+    create_label: { entityKey: "labels", action: "create", fetchPath: null },
+    update_label: { entityKey: "labels", action: "update", fetchPath: null },
+    delete_label: { entityKey: "labels", action: "delete", fetchPath: null },
     // ── Skills ──
-    create_skill: { entityKey: 'skills', action: 'create', fetchPath: null },
-    update_skill: { entityKey: 'skills', action: 'update', fetchPath: null },
-    delete_skill: { entityKey: 'skills', action: 'delete', fetchPath: null },
+    create_skill: { entityKey: "skills", action: "create", fetchPath: null },
+    update_skill: { entityKey: "skills", action: "update", fetchPath: null },
+    delete_skill: { entityKey: "skills", action: "delete", fetchPath: null },
     // ── Proposals ──
-    create_proposal: { entityKey: 'proposals', action: 'create', fetchPath: (id) => `/proposal/${id}` },
-    update_proposal: { entityKey: 'proposals', action: 'update', fetchPath: (id) => `/proposal/${id}` },
-    delete_proposal: { entityKey: 'proposals', action: 'delete', fetchPath: null },
+    create_proposal: {
+        entityKey: "proposals",
+        action: "create",
+        fetchPath: (id) => `/proposal/${id}`,
+    },
+    update_proposal: {
+        entityKey: "proposals",
+        action: "update",
+        fetchPath: (id) => `/proposal/${id}`,
+    },
+    delete_proposal: {
+        entityKey: "proposals",
+        action: "delete",
+        fetchPath: null,
+    },
     // ── Service Months ──
-    create_month: { entityKey: 'months', action: 'create', fetchPath: null },
-    update_months: { invalidateKeys: [['months']] },
-    delete_months: { invalidateKeys: [['months']] },
+    create_month: { entityKey: "months", action: "create", fetchPath: null },
+    update_months: { invalidateKeys: [["months"]] },
+    delete_months: { invalidateKeys: [["months"]] },
     // ── Tasks (nested under jobs — target the parent job) ──
-    create_task: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, idField: 'job_id', construct: (d) => new Job(d) },
-    update_task: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, idField: 'job_id', construct: (d) => new Job(d) },
-    delete_task: { entityKey: 'jobs', action: 'update', fetchPath: (id) => `/job/${id}`, idField: 'job_id', construct: (d) => new Job(d) },
+    create_task: {
+        entityKey: "jobs",
+        action: "update",
+        fetchPath: (id) => `/job/${id}`,
+        idField: "job_id",
+        construct: (d) => new Job(d),
+    },
+    update_task: {
+        entityKey: "jobs",
+        action: "update",
+        fetchPath: (id) => `/job/${id}`,
+        idField: "job_id",
+        construct: (d) => new Job(d),
+    },
+    delete_task: {
+        entityKey: "jobs",
+        action: "update",
+        fetchPath: (id) => `/job/${id}`,
+        idField: "job_id",
+        construct: (d) => new Job(d),
+    },
     // ── Scheduling ──
-    schedule_complete: { invalidateKeys: [['routes'], ['jobs'], ['infinite', 'jobs']] },
+    schedule_complete: {
+        invalidateKeys: [["routes"], ["jobs"], ["infinite", "jobs"]],
+    },
     // ── Location ──
-    location_update: { invalidateKeys: [['teams']] },
+    location_update: { invalidateKeys: [["teams"]] },
     // ── Prepayments ──
-    update_prepayments: { invalidateKeys: [['prepayments']] },
+    update_prepayments: { invalidateKeys: [["prepayments"]] },
     // ── Chats ──
-    new_message: { invalidateKeys: [['chats'], ['messages']] },
+    new_message: { invalidateKeys: [["chats"], ["messages"]] },
 };
 /**
  * Returns true when `query.queryKey` belongs to the given entity,
@@ -94,7 +204,7 @@ const SOCKET_EVENT_CONFIG = {
  */
 function matchesEntityKey(query, entityKey) {
     const k = query.queryKey;
-    return k[0] === entityKey || (k[0] === 'infinite' && k[1] === entityKey);
+    return k[0] === entityKey || (k[0] === "infinite" && k[1] === entityKey);
 }
 export class AvroQueryClient {
     constructor(config) {
@@ -110,39 +220,45 @@ export class AvroQueryClient {
             baseUrl: config.baseUrl,
             authManager: config.authManager,
             maxRetries: config.maxRetries ?? 3,
-            retryStrategy: config.retryStrategy ?? 'fixed',
+            retryStrategy: config.retryStrategy ?? "fixed",
             timeout: config.timeout ?? 0,
         };
-        this.socket = io(config.baseUrl, { autoConnect: false, transports: ["websocket"], });
-        config.authManager.isAuthenticated().then(isAuth => {
+        this.socket = io(config.baseUrl, {
+            autoConnect: false,
+            transports: ["websocket"],
+        });
+        config.authManager.isAuthenticated().then((isAuth) => {
             this.setAuthState(isAuth);
-            this.getCompanyId().then(id => {
+            this.getCompanyId().then((id) => {
                 this.companyId = id;
             });
             if (!this.socket.connected && isAuth === AuthState.AUTHENTICATED) {
-                this.config.authManager.accessToken().then(token => {
-                    console.log('Initializing socket connection with token:', token);
+                this.config.authManager
+                    .accessToken()
+                    .then((token) => {
+                    console.log("Initializing socket connection with token:", token);
                     this.socket.auth = { token: token };
                     this.socket.connect();
-                }).catch(err => {
-                    console.error('Not logged in:', err);
+                })
+                    .catch((err) => {
+                    console.error("Not logged in:", err);
                 });
             }
         });
-        this.socket.on('connect', () => {
+        this.socket.on("connect", () => {
             this.setAuthState(AuthState.AUTHENTICATED);
             console.log(`Socket connected with ID: ${this.socket?.id}`);
         });
-        this.socket.on('disconnect', (reason) => {
+        this.socket.on("disconnect", (reason) => {
             console.log(`Socket disconnected: ${reason}`);
         });
-        this.socket.on('connect_error', (err) => {
+        this.socket.on("connect_error", (err) => {
             console.error(`Socket connection error: ${err.message}`);
         });
         this.config.authManager.onTokenRefreshed((newAccessToken) => {
             if (this.socket && newAccessToken) {
                 this.setAuthState(AuthState.AUTHENTICATED);
-                console.log('Access token refreshed, updating socket auth...');
+                console.log("Access token refreshed, updating socket auth...");
                 this.socket.auth = { token: newAccessToken };
                 this.socket.disconnect().connect();
             }
@@ -157,7 +273,7 @@ export class AvroQueryClient {
     }
     emit(eventName, data) {
         if (!this.socket?.connected) {
-            console.error('Socket is not connected. Cannot emit event.');
+            console.error("Socket is not connected. Cannot emit event.");
             return;
         }
         this.socket.emit(eventName, data);
@@ -191,7 +307,9 @@ export class AvroQueryClient {
         const client = this; // stable reference for async closures
         /** Full-invalidate every key that matches the entity (including 'infinite' prefix). */
         const invalidateEntity = (entityKey) => {
-            queryClient.invalidateQueries({ predicate: (q) => matchesEntityKey(q, entityKey) });
+            queryClient.invalidateQueries({
+                predicate: (q) => matchesEntityKey(q, entityKey),
+            });
         };
         for (const [event, config] of Object.entries(SOCKET_EVENT_CONFIG)) {
             if (isBulkEvent(config)) {
@@ -206,160 +324,39 @@ export class AvroQueryClient {
             }
             else {
                 // ── Targeted: surgical cache update ──────────────────
-                const { entityKey, action, fetchPath, idField, alsoInvalidate, relatedRefetch } = config;
+                const { entityKey, action, fetchPath, idField, alsoInvalidate, relatedRefetch, } = config;
                 const handler = async (data) => {
-                    const id = data?.[idField ?? 'id'];
+                    const id = data?.[idField ?? "id"];
                     // No id → old backend or malformed payload → full invalidation
-                    if (!id || typeof id !== 'string') {
+                    if (!id || typeof id !== "string") {
                         invalidateEntity(entityKey);
                         alsoInvalidate?.forEach((k) => queryClient.invalidateQueries({ queryKey: k }));
                         return;
                     }
-                    const entityPredicate = (q) => matchesEntityKey(q, entityKey);
                     let fetchedItem;
-                    switch (action) {
-                        // ─── CREATE ─────────────────────────────────
-                        case 'create': {
-                            if (fetchPath) {
-                                try {
-                                    const item = await queryClient.fetchQuery({
-                                        queryKey: [entityKey, id],
-                                        queryFn: () => client.get({ path: fetchPath(id) }),
-                                        staleTime: 0,
-                                    });
-                                    fetchedItem = config.construct ? config.construct(item) : item;
-                                    queryClient.setQueryData([entityKey, id], fetchedItem);
-                                    queryClient.setQueriesData({ predicate: entityPredicate, type: 'active' }, (old) => {
-                                        if (!old)
-                                            return old;
-                                        if (old.pages && Array.isArray(old.pages)) {
-                                            // Skip if already present (avoids duplicates
-                                            // when the creating user also gets the event)
-                                            if (old.pages.some((p) => p.some((x) => x?.id === id)))
-                                                return old;
-                                            return {
-                                                ...old,
-                                                pages: [
-                                                    [fetchedItem, ...(old.pages[0] || [])],
-                                                    ...old.pages.slice(1),
-                                                ],
-                                            };
-                                        }
-                                        if (Array.isArray(old)) {
-                                            if (old.some((x) => x?.id === id))
-                                                return old;
-                                            return [...old, fetchedItem];
-                                        }
-                                        return old;
-                                    });
-                                }
-                                catch {
-                                    invalidateEntity(entityKey);
-                                }
-                            }
-                            else {
-                                // No individual GET endpoint → invalidate lists
-                                invalidateEntity(entityKey);
-                            }
-                            break;
-                        }
-                        // ─── UPDATE ─────────────────────────────────
-                        case 'update': {
-                            if (fetchPath) {
-                                try {
-                                    // Fetch fresh copy (also updates the [entity, id] cache)
-                                    const item = await queryClient.fetchQuery({
-                                        queryKey: [entityKey, id],
-                                        queryFn: () => client.get({ path: fetchPath(id) }),
-                                        staleTime: 0,
-                                    });
-                                    fetchedItem = config.construct ? config.construct(item) : item;
-                                    queryClient.setQueryData([entityKey, id], fetchedItem);
-                                    // Patch it into every active list / infinite-query cache
-                                    queryClient.setQueriesData({ predicate: entityPredicate, type: 'active' }, (old) => {
-                                        if (!old)
-                                            return old;
-                                        if (old.pages && Array.isArray(old.pages)) {
-                                            return {
-                                                ...old,
-                                                pages: old.pages.map((page) => page.map((x) => (x?.id === id ? fetchedItem : x))),
-                                            };
-                                        }
-                                        if (Array.isArray(old)) {
-                                            return old.map((x) => (x?.id === id ? fetchedItem : x));
-                                        }
-                                        return old;
-                                    });
-                                }
-                                catch {
-                                    invalidateEntity(entityKey);
-                                }
-                            }
-                            else {
-                                // No individual GET → invalidate everything for this entity
-                                invalidateEntity(entityKey);
-                            }
-                            break;
-                        }
-                        // ─── DELETE ─────────────────────────────────
-                        case 'delete': {
-                            // Remove the individual-item cache entry
-                            queryClient.removeQueries({ queryKey: [entityKey, id], exact: true });
-                            // Remove from every active list / infinite-query cache
-                            queryClient.setQueriesData({ predicate: entityPredicate, type: 'active' }, (old) => {
-                                if (!old)
-                                    return old;
-                                if (old.pages && Array.isArray(old.pages)) {
-                                    return {
-                                        ...old,
-                                        pages: old.pages.map((page) => page.filter((x) => x?.id !== id)),
-                                    };
-                                }
-                                if (Array.isArray(old)) {
-                                    return old.filter((x) => x?.id !== id);
-                                }
-                                return old;
-                            });
-                            break;
-                        }
-                    }
+                    // ─── CREATE / UPDATE / DELETE via shared _syncEntity ───
+                    fetchedItem = await client._syncEntity(queryClient, {
+                        action,
+                        entityKey,
+                        id,
+                        fetchPath: fetchPath ? fetchPath(id) : undefined,
+                        construct: config.construct,
+                    });
                     // Invalidate any additional keys (e.g. companies → /company/list)
                     alsoInvalidate?.forEach((k) => queryClient.invalidateQueries({ queryKey: k }));
                     // Refetch & patch related entities (e.g. event → parent job)
                     if (relatedRefetch) {
                         for (const related of relatedRefetch) {
                             const relatedId = data?.[related.idField] ?? fetchedItem?.[related.idField];
-                            if (!relatedId || typeof relatedId !== 'string')
+                            if (!relatedId || typeof relatedId !== "string")
                                 continue;
-                            try {
-                                let relatedItem = await queryClient.fetchQuery({
-                                    queryKey: [related.entityKey, relatedId],
-                                    queryFn: () => client.get({ path: related.fetchPath(relatedId) }),
-                                    staleTime: 0,
-                                });
-                                if (related.construct)
-                                    relatedItem = related.construct(relatedItem);
-                                queryClient.setQueryData([related.entityKey, relatedId], relatedItem);
-                                const relatedPredicate = (q) => matchesEntityKey(q, related.entityKey);
-                                queryClient.setQueriesData({ predicate: relatedPredicate, type: 'active' }, (old) => {
-                                    if (!old)
-                                        return old;
-                                    if (old.pages && Array.isArray(old.pages)) {
-                                        return {
-                                            ...old,
-                                            pages: old.pages.map((page) => page.map((x) => (x?.id === relatedId ? relatedItem : x))),
-                                        };
-                                    }
-                                    if (Array.isArray(old)) {
-                                        return old.map((x) => (x?.id === relatedId ? relatedItem : x));
-                                    }
-                                    return old;
-                                });
-                            }
-                            catch {
-                                // Fetch failed → invalidate related entity lists
-                                invalidateEntity(related.entityKey);
-                            }
+                            await client._syncEntity(queryClient, {
+                                action: "update",
+                                entityKey: related.entityKey,
+                                id: relatedId,
+                                fetchPath: related.fetchPath(relatedId),
+                                construct: related.construct,
+                            });
                         }
                     }
                 };
@@ -370,11 +367,11 @@ export class AvroQueryClient {
         // Auto join/leave company room
         const joinCompanyRoom = () => {
             if (this.companyId) {
-                this.socket.emit('join_company', { company_id: this.companyId });
+                this.socket.emit("join_company", { company_id: this.companyId });
             }
         };
-        this.socket.on('connect', joinCompanyRoom);
-        handlers.push({ event: 'connect', handler: joinCompanyRoom });
+        this.socket.on("connect", joinCompanyRoom);
+        handlers.push({ event: "connect", handler: joinCompanyRoom });
         // If already connected, join immediately
         if (this.socket.connected && this.companyId) {
             joinCompanyRoom();
@@ -385,7 +382,7 @@ export class AvroQueryClient {
             }
             // Leave company room on teardown
             if (this.socket.connected && this.companyId) {
-                this.socket.emit('leave_company', { company_id: this.companyId });
+                this.socket.emit("leave_company", { company_id: this.companyId });
             }
             this._queryClient = null;
         };
@@ -397,17 +394,17 @@ export class AvroQueryClient {
         this._socketInvalidationCleanup?.();
         this._socketInvalidationCleanup = null;
     }
-    get({ path, cancelToken, headers, progressUpdateCallback }) {
-        return this._xhr('GET', path, null, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    get({ path, cancelToken, headers, progressUpdateCallback, }) {
+        return this._xhr("GET", path, null, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
     }
-    post({ path, data, cancelToken, headers, progressUpdateCallback }) {
-        return this._xhr('POST', path, data, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    post({ path, data, cancelToken, headers, progressUpdateCallback, }) {
+        return this._xhr("POST", path, data, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
     }
-    put({ path, data, cancelToken, headers, progressUpdateCallback }) {
-        return this._xhr('PUT', path, data, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
+    put({ path, data, cancelToken, headers, progressUpdateCallback, }) {
+        return this._xhr("PUT", path, data, cancelToken, headers, true, this.config.maxRetries, progressUpdateCallback);
     }
-    delete({ path, cancelToken, headers, progressUpdateCallback }) {
-        return this._xhr('DELETE', path, null, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
+    delete({ path, cancelToken, headers, progressUpdateCallback, }) {
+        return this._xhr("DELETE", path, null, cancelToken, headers, false, this.config.maxRetries, progressUpdateCallback);
     }
     loginSuccess(tokens) {
         this.setAuthState(AuthState.AUTHENTICATED);
@@ -420,20 +417,23 @@ export class AvroQueryClient {
     useLogin() {
         const queryClient = this.getQueryClient();
         return useMutation({
-            mutationFn: async ({ username, password, code, cancelToken }) => {
+            mutationFn: async ({ username, password, code, cancelToken, }) => {
                 const resp = await this.post({
-                    path: '/login',
+                    path: "/login",
                     data: JSON.stringify({ username, password, code }),
                     cancelToken,
-                    headers: { 'Content-Type': 'application/json' }
+                    headers: { "Content-Type": "application/json" },
                 });
-                if (!resp || !('access_token' in resp)) {
+                if (!resp || !("access_token" in resp)) {
                     if (resp.msg === "TOTP required") {
                         return LoginResponse.NEEDS_TOTP;
                     }
-                    throw new StandardError(401, 'Invalid login response');
+                    throw new StandardError(401, "Invalid login response");
                 }
-                await this.loginSuccess({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                await this.loginSuccess({
+                    access_token: resp.access_token,
+                    refresh_token: resp.refresh_token,
+                });
                 return LoginResponse.SUCCESS;
             },
             onSettled: () => {
@@ -441,19 +441,19 @@ export class AvroQueryClient {
             },
             onError: (err) => {
                 this.config.authManager.clearCache();
-                throw new StandardError(401, err.message || 'Login failed');
-            }
+                throw new StandardError(401, err.message || "Login failed");
+            },
         });
     }
     useRequestCode() {
         const queryClient = this.getQueryClient();
         return useMutation({
-            mutationFn: async ({ username, email, cancelToken }) => {
+            mutationFn: async ({ username, email, cancelToken, }) => {
                 const resp = await this.post({
-                    path: '/code',
+                    path: "/code",
                     data: JSON.stringify({ username, email }),
                     cancelToken,
-                    headers: { 'Content-Type': 'application/json' }
+                    headers: { "Content-Type": "application/json" },
                 });
                 return resp;
             },
@@ -461,46 +461,49 @@ export class AvroQueryClient {
                 queryClient.invalidateQueries();
             },
             onError: (err) => {
-                throw new StandardError(err.status, err.message || 'Request code failed');
-            }
+                throw new StandardError(err.status, err.message || "Request code failed");
+            },
         });
     }
     useUpdatePassword() {
         const queryClient = this.getQueryClient();
         return useMutation({
-            mutationFn: async ({ username, email, code, newPassword, cancelToken }) => {
+            mutationFn: async ({ username, email, code, newPassword, cancelToken, }) => {
                 await this.post({
                     path: `/user/${username ?? email}/password`,
                     data: JSON.stringify({ code, password: newPassword }),
                     cancelToken,
-                    headers: { 'Content-Type': 'application/json' }
+                    headers: { "Content-Type": "application/json" },
                 });
             },
             onSettled: () => {
                 queryClient.invalidateQueries();
             },
             onError: (err) => {
-                throw new StandardError(err.status, err.message || 'Update password failed');
-            }
+                throw new StandardError(err.status, err.message || "Update password failed");
+            },
         });
     }
     useGoogleLogin() {
         const queryClient = this.getQueryClient();
         return useMutation({
-            mutationFn: async ({ token, cancelToken }) => {
-                const resp = await this._xhr('POST', `/google/authorize?token=${token}`, {}, cancelToken, { 'Content-Type': 'application/json' });
-                if (!resp || !('access_token' in resp)) {
+            mutationFn: async ({ token, cancelToken, }) => {
+                const resp = await this._xhr("POST", `/google/authorize?token=${token}`, {}, cancelToken, { "Content-Type": "application/json" });
+                if (!resp || !("access_token" in resp)) {
                     if (resp.msg === "TOTP required") {
                         return LoginResponse.NEEDS_TOTP;
                     }
-                    throw new StandardError(401, 'Invalid Google login response');
+                    throw new StandardError(401, "Invalid Google login response");
                 }
                 this.setAuthState(AuthState.AUTHENTICATED);
                 this.socket.auth = { token: resp.access_token };
                 if (!this.socket.connected) {
                     this.socket.connect();
                 }
-                await this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                await this.config.authManager.setTokens({
+                    access_token: resp.access_token,
+                    refresh_token: resp.refresh_token,
+                });
                 return LoginResponse.SUCCESS;
             },
             onSettled: () => {
@@ -508,27 +511,30 @@ export class AvroQueryClient {
             },
             onError: (err) => {
                 this.config.authManager.clearCache();
-                throw new StandardError(err.status, err.message || 'Google Login failed');
-            }
+                throw new StandardError(err.status, err.message || "Google Login failed");
+            },
         });
     }
     useAppleLogin() {
         const queryClient = this.getQueryClient();
         return useMutation({
-            mutationFn: async ({ token, cancelToken }) => {
-                const resp = await this._xhr('POST', `/apple/authorize?token=${encodeURIComponent(token)}`, {}, cancelToken, { 'Content-Type': 'application/json' });
-                if (!resp || !('access_token' in resp)) {
+            mutationFn: async ({ token, cancelToken, }) => {
+                const resp = await this._xhr("POST", `/apple/authorize?token=${encodeURIComponent(token)}`, {}, cancelToken, { "Content-Type": "application/json" });
+                if (!resp || !("access_token" in resp)) {
                     if (resp.msg === "TOTP required") {
                         return LoginResponse.NEEDS_TOTP;
                     }
-                    throw new StandardError(401, 'Invalid Apple login response');
+                    throw new StandardError(401, "Invalid Apple login response");
                 }
                 this.setAuthState(AuthState.AUTHENTICATED);
                 this.socket.auth = { token: resp.access_token };
                 if (!this.socket.connected) {
                     this.socket.connect();
                 }
-                await this.config.authManager.setTokens({ access_token: resp.access_token, refresh_token: resp.refresh_token });
+                await this.config.authManager.setTokens({
+                    access_token: resp.access_token,
+                    refresh_token: resp.refresh_token,
+                });
                 return LoginResponse.SUCCESS;
             },
             onSettled: () => {
@@ -536,8 +542,8 @@ export class AvroQueryClient {
             },
             onError: (err) => {
                 this.config.authManager.clearCache();
-                throw new StandardError(err.status, err.message || 'Apple Login failed');
-            }
+                throw new StandardError(err.status, err.message || "Apple Login failed");
+            },
         });
     }
     setTokens(tokens) {
@@ -576,10 +582,10 @@ export class AvroQueryClient {
         return () => this.offAuthStateChange(cb);
     }
     offAuthStateChange(cb) {
-        this.authStateListeners = this.authStateListeners.filter(c => c !== cb);
+        this.authStateListeners = this.authStateListeners.filter((c) => c !== cb);
     }
     setAuthState(state) {
-        this.authStateListeners.forEach(cb => cb(state));
+        this.authStateListeners.forEach((cb) => cb(state));
         this._authState = state;
     }
     getAuthState() {
@@ -591,13 +597,104 @@ export class AvroQueryClient {
     getQueryClient() {
         return useQueryClient();
     }
+    /**
+     * Fetch an entity from the API, optionally construct it, and surgically
+     * update all matching React-Query caches (individual + list + infinite).
+     *
+     * Shared by socket handlers and mutation `onSuccess` callbacks so the
+     * sender gets an immediate cache sync and everyone else gets the socket
+     * update — both use the identical code path.
+     *
+     * @returns The fetched (and optionally constructed) item, or `undefined`
+     *          for deletes / entities without a fetchPath.
+     */
+    async _syncEntity(queryClient, params) {
+        const { action, entityKey, id, fetchPath, construct } = params;
+        const predicate = (q) => matchesEntityKey(q, entityKey);
+        const invalidate = () => queryClient.invalidateQueries({ predicate });
+        // ─── DELETE ─────────────────────────────────────────
+        if (action === "delete") {
+            queryClient.removeQueries({ queryKey: [entityKey, id], exact: true });
+            queryClient.setQueriesData({ predicate, type: "active" }, (old) => {
+                if (!old)
+                    return old;
+                if (old.pages && Array.isArray(old.pages)) {
+                    return {
+                        ...old,
+                        pages: old.pages.map((p) => p.filter((x) => x?.id !== id)),
+                    };
+                }
+                if (Array.isArray(old)) {
+                    return old.filter((x) => x?.id !== id);
+                }
+                return old;
+            });
+            return undefined;
+        }
+        // ─── CREATE / UPDATE ────────────────────────────────
+        if (!fetchPath) {
+            invalidate();
+            return undefined;
+        }
+        try {
+            const raw = await queryClient.fetchQuery({
+                queryKey: [entityKey, id],
+                queryFn: () => this.get({ path: fetchPath }),
+                staleTime: 0,
+            });
+            const item = construct ? construct(raw) : raw;
+            queryClient.setQueryData([entityKey, id], item);
+            if (action === "create") {
+                queryClient.setQueriesData({ predicate, type: "active" }, (old) => {
+                    if (!old)
+                        return old;
+                    if (old.pages && Array.isArray(old.pages)) {
+                        if (old.pages.some((p) => p.some((x) => x?.id === id)))
+                            return old;
+                        return {
+                            ...old,
+                            pages: [[item, ...(old.pages[0] || [])], ...old.pages.slice(1)],
+                        };
+                    }
+                    if (Array.isArray(old)) {
+                        if (old.some((x) => x?.id === id))
+                            return old;
+                        return [...old, item];
+                    }
+                    return old;
+                });
+            }
+            else {
+                // UPDATE — replace in every active list / infinite-query cache
+                queryClient.setQueriesData({ predicate, type: "active" }, (old) => {
+                    if (!old)
+                        return old;
+                    if (old.pages && Array.isArray(old.pages)) {
+                        return {
+                            ...old,
+                            pages: old.pages.map((page) => page.map((x) => (x?.id === id ? item : x))),
+                        };
+                    }
+                    if (Array.isArray(old)) {
+                        return old.map((x) => (x?.id === id ? item : x));
+                    }
+                    return old;
+                });
+            }
+            return item;
+        }
+        catch {
+            invalidate();
+            return undefined;
+        }
+    }
     useLogout() {
         const queryClient = this.getQueryClient();
         return useMutation({
             mutationFn: async (cancelToken) => {
                 await this.post({
-                    path: '/logout',
-                    cancelToken
+                    path: "/logout",
+                    cancelToken,
                 });
                 await this.config.authManager.clearCache();
                 if (this.socket && this.socket.connected) {
@@ -611,276 +708,276 @@ export class AvroQueryClient {
             },
             onError: (err) => {
                 this.clearCache();
-                console.error('Logout failed:', err);
-                throw new StandardError(500, 'Logout failed');
-            }
+                console.error("Logout failed:", err);
+                throw new StandardError(500, "Logout failed");
+            },
         });
     }
     fetchJobs(body = {}, companyId, cancelToken, headers = {}) {
         const companyIdToUse = companyId ?? this.companyId;
-        if (!companyIdToUse || companyIdToUse.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!companyIdToUse || companyIdToUse.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${companyIdToUse}/jobs`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${companyIdToUse}/jobs`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid jobs response');
+                throw new StandardError(400, "Invalid jobs response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch jobs:', err);
+            .catch((err) => {
+            console.error("Failed to fetch jobs:", err);
             throw new StandardError(500, `Failed to fetch jobs: ${err.message ?? err}`);
         });
     }
     fetchChats(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/chats`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/chats`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid chats response');
+                throw new StandardError(400, "Invalid chats response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch chats:', err);
-            throw new StandardError(500, 'Failed to fetch chats');
+            .catch((err) => {
+            console.error("Failed to fetch chats:", err);
+            throw new StandardError(500, "Failed to fetch chats");
         });
     }
     fetchMessages(chatId, body = {}, cancelToken, headers = {}) {
-        if (!chatId || chatId.trim() === '') {
-            throw new StandardError(400, 'Chat ID is required');
+        if (!chatId || chatId.trim() === "") {
+            throw new StandardError(400, "Chat ID is required");
         }
-        return this._fetch('POST', `/chat/${chatId}/messages`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/chat/${chatId}/messages`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid messages response');
+                throw new StandardError(400, "Invalid messages response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch messages:', err);
-            throw new StandardError(500, 'Failed to fetch messages');
+            .catch((err) => {
+            console.error("Failed to fetch messages:", err);
+            throw new StandardError(500, "Failed to fetch messages");
         });
     }
     async fetchPrepayments(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/prepayments`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/prepayments`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid prepayments response');
+                throw new StandardError(400, "Invalid prepayments response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch prepayments:', err);
-            throw new StandardError(500, 'Failed to fetch prepayments');
+            .catch((err) => {
+            console.error("Failed to fetch prepayments:", err);
+            throw new StandardError(500, "Failed to fetch prepayments");
         });
     }
     async fetchWaivers(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/waivers`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/waivers`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid waivers response');
+                throw new StandardError(400, "Invalid waivers response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch waivers:', err);
-            throw new StandardError(500, 'Failed to fetch waivers');
+            .catch((err) => {
+            console.error("Failed to fetch waivers:", err);
+            throw new StandardError(500, "Failed to fetch waivers");
         });
     }
     async fetchEvents(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/events`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/events`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid events response');
+                throw new StandardError(400, "Invalid events response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch events:', err);
-            throw new StandardError(500, 'Failed to fetch events');
+            .catch((err) => {
+            console.error("Failed to fetch events:", err);
+            throw new StandardError(500, "Failed to fetch events");
         });
     }
     fetchMonths(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/months`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/months`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid months response');
+                throw new StandardError(400, "Invalid months response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch months:', err);
-            throw new StandardError(500, 'Failed to fetch months');
+            .catch((err) => {
+            console.error("Failed to fetch months:", err);
+            throw new StandardError(500, "Failed to fetch months");
         });
     }
     fetchBills(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/bills`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/bills`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid bills response');
+                throw new StandardError(400, "Invalid bills response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch bills:', err);
-            throw new StandardError(500, 'Failed to fetch bills');
+            .catch((err) => {
+            console.error("Failed to fetch bills:", err);
+            throw new StandardError(500, "Failed to fetch bills");
         });
     }
     fetchRoutes(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/routes`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/routes`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid routes response');
+                throw new StandardError(400, "Invalid routes response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch routes:', err);
-            throw new StandardError(500, 'Failed to fetch routes');
+            .catch((err) => {
+            console.error("Failed to fetch routes:", err);
+            throw new StandardError(500, "Failed to fetch routes");
         });
     }
     fetchTeams(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/teams`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/teams`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid teams response');
+                throw new StandardError(400, "Invalid teams response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch teams:', err);
-            throw new StandardError(500, 'Failed to fetch teams');
+            .catch((err) => {
+            console.error("Failed to fetch teams:", err);
+            throw new StandardError(500, "Failed to fetch teams");
         });
     }
     fetchLabels(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/labels`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/labels`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid labels response');
+                throw new StandardError(400, "Invalid labels response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch labels:', err);
-            throw new StandardError(500, 'Failed to fetch labels');
+            .catch((err) => {
+            console.error("Failed to fetch labels:", err);
+            throw new StandardError(500, "Failed to fetch labels");
         });
     }
     fetchGroups(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/groups`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/groups`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid groups response');
+                throw new StandardError(400, "Invalid groups response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch groups:', err);
-            throw new StandardError(500, 'Failed to fetch groups');
+            .catch((err) => {
+            console.error("Failed to fetch groups:", err);
+            throw new StandardError(500, "Failed to fetch groups");
         });
     }
     fetchSkills(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/skills`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/skills`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid skills response');
+                throw new StandardError(400, "Invalid skills response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch skills:', err);
-            throw new StandardError(500, 'Failed to fetch skills');
+            .catch((err) => {
+            console.error("Failed to fetch skills:", err);
+            throw new StandardError(500, "Failed to fetch skills");
         });
     }
     fetchSessions(body = {}, cancelToken, headers = {}) {
-        if (!this.companyId || this.companyId.trim() === '') {
-            throw new StandardError(400, 'Company ID is required');
+        if (!this.companyId || this.companyId.trim() === "") {
+            throw new StandardError(400, "Company ID is required");
         }
-        return this._fetch('POST', `/company/${this.companyId}/sessions`, JSON.stringify(body), cancelToken, {
+        return this._fetch("POST", `/company/${this.companyId}/sessions`, JSON.stringify(body), cancelToken, {
             ...headers,
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
         })
-            .then(response => {
+            .then((response) => {
             if (!response || !Array.isArray(response)) {
-                throw new StandardError(400, 'Invalid sessions response');
+                throw new StandardError(400, "Invalid sessions response");
             }
             return response;
         })
-            .catch(err => {
-            console.error('Failed to fetch sessions:', err);
-            throw new StandardError(500, 'Failed to fetch sessions');
+            .catch((err) => {
+            console.error("Failed to fetch sessions:", err);
+            throw new StandardError(500, "Failed to fetch sessions");
         });
     }
     /* ── Email delivery tracking ──────────────────────────────────────── */
@@ -945,7 +1042,7 @@ export class AvroQueryClient {
             return this.post({
                 path: `/email/${emailId}`,
                 data: formData,
-                progressUpdateCallback
+                progressUpdateCallback,
             });
         }
         catch (error) {
@@ -957,7 +1054,7 @@ export class AvroQueryClient {
             return this.post({
                 path: `/bill/${billId}/email`,
                 data: JSON.stringify(body),
-                headers: { 'Content-Type': 'application/json' }
+                headers: { "Content-Type": "application/json" },
             });
         }
         catch (error) {