@statezero/core 0.2.38 → 0.2.39

package/dist/syncEngine/registries/querysetStoreGraph.js

@@ -0,0 +1,174 @@
+import { Graph } from "graphlib";
+/**
+ * Simple graph for tracking queryset store ancestry
+ */
+export class QuerysetStoreGraph {
+    constructor() {
+        this.graph = new Graph({ directed: true });
+        this.processedQuerysets = new Set(); // Track UUIDs of processed querysets
+    }
+    /**
+     * Add a queryset and its parent relationship to the graph
+     */
+    addQueryset(queryset) {
+        if (!queryset)
+            return;
+        if (this.processedQuerysets.has(queryset.key)) {
+            return; // Already processed, skip
+        }
+        let current = queryset;
+        while (current && !this.processedQuerysets.has(current.key)) {
+            const currentKey = current.semanticKey;
+            const currentUuid = current.key;
+            this.processedQuerysets.add(currentUuid);
+            this.graph.setNode(currentKey);
+            if (current.__parent) {
+                const parentKey = current.__parent.semanticKey;
+                this.graph.setNode(parentKey);
+                // Determine if we can create an edge to parent
+                // Parent must be a valid data source (superset of child's data needs)
+                const canLinkToParent = currentKey !== parentKey &&
+                    this._isValidParentForEdge(current.__parent._serializerOptions, current._serializerOptions, current.__parent._orderBy, current._orderBy);
+                if (canLinkToParent) {
+                    this.graph.setEdge(currentKey, parentKey);
+                }
+                current = current.__parent;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    /**
+     * Find the root (topmost ancestor) of a queryset chain within a subset.
+     * Traverses up the graph but only considers nodes that are in the subset.
+     * Uses the graph to "jump" through nodes not in subset to find connections.
+     *
+     * @param {Object} queryset - The queryset to analyze
+     * @param {Set|null} subset - Set of semanticKeys to consider. If null, considers all nodes in graph.
+     * @returns {Object} { isRoot: boolean, root: semanticKey|null }
+     */
+    findRoot(queryset, subset = null) {
+        // Validate input - null/undefined is a programming error
+        if (!queryset) {
+            throw new Error("findRoot was called with a null object, instead of a queryset");
+        }
+        // Handle queryset without semanticKey
+        if (!queryset.semanticKey) {
+            throw new Error("findRoot was called on an object without a semanticKey, which means its not a queryset. findRoot only works on querysets");
+        }
+        const semanticKey = queryset.semanticKey;
+        if (!this.graph.hasNode(semanticKey)) {
+            this.addQueryset(queryset);
+        }
+        // If no subset provided, consider all nodes in the graph
+        subset = subset || new Set(this.graph.nodes());
+        // Traverse ALL the way up to find the HIGHEST ancestor in the subset
+        const visited = new Set();
+        let current = semanticKey;
+        let highestInSubset = null;
+        while (current && !visited.has(current)) {
+            visited.add(current);
+            // Check if current node is in subset
+            if (subset.has(current)) {
+                highestInSubset = current;
+            }
+            // Move to parent (continue jumping even if current not in subset)
+            const parents = this.graph.successors(current) || [];
+            if (parents.length > 0) {
+                current = parents[0];
+            }
+            else {
+                break;
+            }
+        }
+        if (highestInSubset) {
+            if (highestInSubset === semanticKey) {
+                // This queryset itself is the highest in subset
+                return { isRoot: true, root: semanticKey };
+            }
+            else {
+                // Found a higher ancestor in subset
+                return { isRoot: false, root: highestInSubset };
+            }
+        }
+        // No nodes found in subset
+        return { isRoot: true, root: null };
+    }
+    /**
+     * Check if parent queryset is a valid data source for creating an edge.
+     * Parent must have data that is a superset of what child needs.
+     * Child with offset must sync independently (can't derive window from parent).
+     *
+     * @param {Object} parentOpts - Parent's serializerOptions
+     * @param {Object} childOpts - Child's serializerOptions
+     * @param {Array|undefined} parentOrderBy - Parent's ordering
+     * @param {Array|undefined} childOrderBy - Child's ordering
+     * @returns {boolean} - True if parent is valid for edge creation
+     */
+    _isValidParentForEdge(parentOpts = {}, childOpts = {}, parentOrderBy, childOrderBy) {
+        // Cannot link if parent has offset > 0 (paginated parent has subset of data)
+        // Note: offset: 0 is treated as no offset (start from beginning)
+        if (parentOpts.offset != null && parentOpts.offset > 0) {
+            return false;
+        }
+        // Cannot link if parent has limit - child may need items beyond parent's limit window
+        // (filtered items matching child could exist beyond parent's limit cutoff)
+        // If child has same filter + same limit, they'd have same semanticKey (no edge needed)
+        if (parentOpts.limit != null) {
+            return false;
+        }
+        // Cannot link if child has offset > 0 - must sync independently
+        // We can't derive which items are at positions N-M from the parent's full data
+        // because that requires the server's ordering logic
+        // Note: offset: 0 is treated as no offset (start from beginning)
+        if (childOpts.offset != null && childOpts.offset > 0) {
+            return false;
+        }
+        // Note: ordering doesn't matter for linking since parent has no limit (checked above)
+        // Parent has all items, so child can re-sort locally regardless of ordering
+        // Cannot link if parent has different depth
+        // Different depth means different nested data structure
+        if (parentOpts.depth != null && parentOpts.depth !== childOpts.depth) {
+            return false;
+        }
+        // Cannot link if parent has fields that are not a superset of child's fields
+        // Parent must have all fields that child needs
+        if (parentOpts.fields != null) {
+            // If child needs all fields (null) but parent restricts fields, cannot link
+            if (childOpts.fields == null) {
+                return false;
+            }
+            // Check if parent's fields contain all of child's fields
+            const parentFields = new Set(parentOpts.fields);
+            const childHasFieldsNotInParent = childOpts.fields.some(f => !parentFields.has(f));
+            if (childHasFieldsNotInParent) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Check if two orderings are equivalent.
+     * @param {Array|undefined} orderBy1
+     * @param {Array|undefined} orderBy2
+     * @returns {boolean}
+     */
+    _orderingsMatch(orderBy1, orderBy2) {
+        // Both undefined/null = match
+        if (!orderBy1 && !orderBy2)
+            return true;
+        // One defined, one not = no match
+        if (!orderBy1 || !orderBy2)
+            return false;
+        // Different lengths = no match
+        if (orderBy1.length !== orderBy2.length)
+            return false;
+        // Compare each field
+        return orderBy1.every((field, i) => field === orderBy2[i]);
+    }
+    clear() {
+        this.graph = new Graph({ directed: true });
+        this.processedQuerysets = new Set();
+    }
+}

package/dist/syncEngine/registries/querysetStoreRegistry.d.ts

@@ -0,0 +1,72 @@
+/**
+ * A dynamic wrapper that always returns the latest queryset results
+ * This class proxies array operations to always reflect the current state
+ * of the underlying QuerysetStore.
+ */
+export class LiveQueryset {
+    constructor(queryset: any);
+    /**
+     * Serializes the lqs as a simple array of objects, for freezing e.g in the metric stores
+     */
+    serialize(): any;
+    /**
+     * Refresh the queryset data from the database
+     * Delegates to the underlying store's sync method
+     */
+    refreshFromDb(): any;
+    /**
+     * Get the current items from the store
+     * @private
+     * @returns {Array} The current items in the queryset
+     */
+    private getCurrentItems;
+    #private;
+}
+export class QuerysetStoreRegistry {
+    _stores: Map<any, any>;
+    _tempStores: WeakMap<object, any>;
+    followingQuerysets: Map<any, any>;
+    syncManager: () => void;
+    querysetStoreGraph: QuerysetStoreGraph;
+    _groupSyncCache: Map<any, any>;
+    clear(): void;
+    setSyncManager(syncManager: any): void;
+    /**
+     * Add a queryset to the following set for a semantic key
+     */
+    addFollowingQueryset(semanticKey: any, queryset: any): void;
+    getStore(queryset: any): any;
+    /**
+     * Get the current state of the queryset, wrapped in a LiveQueryset
+     * @param {Object} queryset - The queryset
+     * @param {Boolean} sync - Schedule a sync of the queryset with the backend
+     * @returns {LiveQueryset} - A live view of the queryset
+     */
+    getEntity(queryset: Object, sync?: boolean): LiveQueryset;
+    /**
+     * Set ground truth for a queryset
+     * @param {Object} queryset - The queryset
+     * @param {Array} instances - Array of instances to set as ground truth
+     * @returns {Array} - The set instances
+     */
+    setEntity(queryset: Object, instances: any[]): any[];
+    /**
+     * Get all queryset stores for a specific model class
+     * @param {ModelClass} ModelClass - The model class to get stores for
+     * @returns {Array} - Array of queryset stores for this model
+     */
+    getAllStoresForModel(ModelClass: any): any[];
+    /**
+     * Sync a queryset, coordinating with its chain to minimize DB calls.
+     * The root fetches from DB, children filter from cached results.
+     * Uses operationId to coordinate - whoever arrives first creates the promise,
+     * the root takes over and resolves it.
+     *
+     * @param {Object} queryset - The queryset to sync
+     * @param {string} operationId - Unique ID for this sync operation (for coordination)
+     * @param {Set} dbSyncedKeys - Set of semanticKeys that are dbSynced (followedQuerysets)
+     */
+    groupSync(queryset: Object, operationId: string, dbSyncedKeys: Set<any>): Promise<void>;
+}
+export const querysetStoreRegistry: QuerysetStoreRegistry;
+import { QuerysetStoreGraph } from './querysetStoreGraph.js';

package/dist/syncEngine/registries/querysetStoreRegistry.js

@@ -0,0 +1,335 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LiveQueryset_queryset, _LiveQueryset_ModelClass, _LiveQueryset_proxy, _LiveQueryset_array;
+import { QuerysetStore } from '../stores/querysetStore.js';
+import { modelStoreRegistry } from '../registries/modelStoreRegistry.js';
+import { wrapReactiveQuerySet } from '../../reactiveAdaptor.js';
+import { processQuery, getRequiredFields, pickRequiredFields } from '../../filtering/localFiltering.js';
+import { filter } from '../../filtering/localFiltering.js';
+import { makeApiCall } from '../../flavours/django/makeApiCall.js';
+import { QuerysetStoreGraph } from './querysetStoreGraph.js';
+import { isNil, pick } from 'lodash-es';
+import hash from 'object-hash';
+import { Operation } from '../stores/operation.js';
+import { Cache } from '../cache/cache.js';
+/**
+ * A dynamic wrapper that always returns the latest queryset results
+ * This class proxies array operations to always reflect the current state
+ * of the underlying QuerysetStore.
+ */
+export class LiveQueryset {
+    constructor(queryset) {
+        _LiveQueryset_queryset.set(this, void 0);
+        _LiveQueryset_ModelClass.set(this, void 0);
+        _LiveQueryset_proxy.set(this, void 0);
+        _LiveQueryset_array.set(this, []);
+        // used internally
+        __classPrivateFieldSet(this, _LiveQueryset_queryset, queryset, "f");
+        __classPrivateFieldSet(this, _LiveQueryset_ModelClass, queryset.ModelClass, "f");
+        __classPrivateFieldGet(this, _LiveQueryset_array, "f").queryset = queryset;
+        __classPrivateFieldGet(this, _LiveQueryset_array, "f").ModelClass = queryset.ModelClass;
+        // Create a proxy that intercepts all array access
+        __classPrivateFieldSet(this, _LiveQueryset_proxy, new Proxy(__classPrivateFieldGet(this, _LiveQueryset_array, "f"), {
+            get: (target, prop, receiver) => {
+                // Expose the touch method through the proxy
+                if (prop === "touch") {
+                    return () => this.touch();
+                }
+                if (prop === "serialize") {
+                    return () => this.serialize();
+                }
+                // Special handling for iterators and common array methods
+                if (prop === Symbol.iterator) {
+                    return () => this.getCurrentItems()[Symbol.iterator]();
+                }
+                else if (typeof prop === "string" &&
+                    [
+                        "forEach",
+                        "map",
+                        "filter",
+                        "reduce",
+                        "some",
+                        "every",
+                        "find",
+                    ].includes(prop)) {
+                    return (...args) => this.getCurrentItems()[prop](...args);
+                }
+                else if (prop === "length") {
+                    return this.getCurrentItems().length;
+                }
+                else if (typeof prop === "string" && !isNaN(parseInt(prop))) {
+                    // Handle numeric indices
+                    return this.getCurrentItems()[prop];
+                }
+                return target[prop];
+            },
+        }), "f");
+        return __classPrivateFieldGet(this, _LiveQueryset_proxy, "f");
+    }
+    /**
+     * Serializes the lqs as a simple array of objects, for freezing e.g in the metric stores
+     */
+    serialize() {
+        const store = querysetStoreRegistry.getStore(__classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
+        // Get the current primary keys from the store
+        const pks = store.render();
+        // Map primary keys to full model objects
+        return pks.map((pk) => {
+            // Get the full model instance from the model store
+            const pkField = __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").primaryKeyField;
+            return __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").fromPk(pk, __classPrivateFieldGet(this, _LiveQueryset_queryset, "f")).serialize();
+        });
+    }
+    /**
+     * Refresh the queryset data from the database
+     * Delegates to the underlying store's sync method
+     */
+    refreshFromDb() {
+        const store = querysetStoreRegistry.getStore(__classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
+        return store.sync(true);
+    }
+    /**
+     * Get the current items from the store
+     * @private
+     * @returns {Array} The current items in the queryset
+     */
+    getCurrentItems() {
+        const store = querysetStoreRegistry.getStore(__classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
+        // Get the current primary keys from the store
+        const pks = store.render();
+        // Map primary keys to full model objects
+        const instances = pks
+            .map((pk) => {
+            // Get the full model instance from the model store
+            const pkField = __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").primaryKeyField;
+            return __classPrivateFieldGet(this, _LiveQueryset_ModelClass, "f").fromPk(pk, __classPrivateFieldGet(this, _LiveQueryset_queryset, "f"));
+        });
+        return instances;
+    }
+}
+_LiveQueryset_queryset = new WeakMap(), _LiveQueryset_ModelClass = new WeakMap(), _LiveQueryset_proxy = new WeakMap(), _LiveQueryset_array = new WeakMap();
+export class QuerysetStoreRegistry {
+    constructor() {
+        this._stores = new Map(); // Map<semanticKey, Store>
+        this._tempStores = new WeakMap(); // WeakMap<Queryset, Store>
+        this.followingQuerysets = new Map(); // Map<semanticKey, Set<queryset>>
+        this.syncManager = () => { console.warn("SyncManager not set for QuerysetStoreRegistry"); };
+        this.querysetStoreGraph = new QuerysetStoreGraph();
+        // Cache for groupSync coordination
+        // Map<operationId, { promise, resolve, rootKey, pks, ModelClass }>
+        this._groupSyncCache = new Map();
+    }
+    clear() {
+        this._stores.forEach((store) => {
+            this.syncManager.unfollowModel(this, store.modelClass);
+        });
+        this._stores = new Map();
+        this.followingQuerysets = new Map();
+        this.querysetStoreGraph.clear();
+    }
+    setSyncManager(syncManager) {
+        this.syncManager = syncManager;
+    }
+    /**
+     * Add a queryset to the following set for a semantic key
+     */
+    addFollowingQueryset(semanticKey, queryset) {
+        if (!this.followingQuerysets.has(semanticKey)) {
+            this.followingQuerysets.set(semanticKey, new Set());
+        }
+        this.followingQuerysets.get(semanticKey).add(queryset);
+    }
+    getStore(queryset) {
+        if (isNil(queryset) || isNil(queryset.ModelClass)) {
+            throw new Error("QuerysetStoreRegistry.getStore requires a valid queryset");
+        }
+        this.querysetStoreGraph.addQueryset(queryset);
+        // Check if we already have a temporary store for this exact QuerySet instance
+        if (this._tempStores.has(queryset)) {
+            return this._tempStores.get(queryset);
+        }
+        // Get the semanticKey
+        const semanticKey = queryset.semanticKey;
+        // Check if we have a permanent store with this semanticKey
+        if (this._stores.has(semanticKey)) {
+            this.addFollowingQueryset(semanticKey, queryset);
+            return this._stores.get(semanticKey);
+        }
+        // Check if any parent in the chain has a temp store with the same semantic key
+        // This ensures that materialized querysets (created via fetch/create/etc) share
+        // the same store as their parent queryset when they have the same semantic key
+        let current = queryset.__parent;
+        while (current) {
+            if (this._tempStores.has(current) && current.semanticKey === semanticKey) {
+                return this._tempStores.get(current);
+            }
+            current = current.__parent;
+        }
+        // Create a new temporary store
+        const fetchQueryset = async ({ ast, modelClass, canonical_id }) => {
+            // Directly assemble the request and call the API to avoid recursive logic from the
+            // queryset back to the registry / store
+            const payload = {
+                ...ast,
+                type: 'list'
+            };
+            const response = await makeApiCall(queryset, 'list', payload, null, // operationId
+            null, // beforeExit
+            canonical_id, // canonical_id for caching
+            { namespace: 'sync', timeout: 30000 } // Sync ops on separate queue
+            );
+            return response.data;
+        };
+        const store = new QuerysetStore(queryset.ModelClass, fetchQueryset, queryset, null, // No initial ground truth - will render from model store if needed
+        null, // Initial operations
+        { isTemp: true });
+        // Store it in the temp store map
+        this._tempStores.set(queryset, store);
+        return store;
+    }
+    /**
+     * Get the current state of the queryset, wrapped in a LiveQueryset
+     * @param {Object} queryset - The queryset
+     * @param {Boolean} sync - Schedule a sync of the queryset with the backend
+     * @returns {LiveQueryset} - A live view of the queryset
+     */
+    getEntity(queryset, sync = false) {
+        if (isNil(queryset))
+            throw new Error(`qsStoreRegistry: getEntity cannot be called without a queryset`);
+        const semanticKey = queryset.semanticKey;
+        this.addFollowingQueryset(semanticKey, queryset);
+        let store;
+        // If we have a temporary store, promote it
+        if (this._tempStores.has(queryset)) {
+            store = this._tempStores.get(queryset);
+            store.isTemp = false; // Promote to permanent store
+            store.registerWithModelStore(); // Register for model store changes now that it's permanent
+            this._stores.set(semanticKey, store);
+            this.syncManager.followModel(this, queryset.ModelClass);
+        }
+        // Otherwise, ensure we have a permanent store
+        else if (!this._stores.has(semanticKey)) {
+            store = this.getStore(queryset);
+            store.isTemp = false;
+            store.registerWithModelStore(); // Register for model store changes now that it's permanent
+            this._stores.set(semanticKey, store);
+            this.syncManager.followModel(this, queryset.ModelClass);
+        }
+        else {
+            store = this._stores.get(semanticKey);
+        }
+        const liveQueryset = new LiveQueryset(queryset);
+        if (sync)
+            store.sync();
+        return wrapReactiveQuerySet(liveQueryset);
+    }
+    /**
+     * Set ground truth for a queryset
+     * @param {Object} queryset - The queryset
+     * @param {Array} instances - Array of instances to set as ground truth
+     * @returns {Array} - The set instances
+     */
+    setEntity(queryset, instances) {
+        if (isNil(queryset) || isNil(instances))
+            return [];
+        const semanticKey = queryset.semanticKey;
+        this.addFollowingQueryset(semanticKey, queryset);
+        let store;
+        if (this._stores.has(semanticKey)) {
+            store = this._stores.get(semanticKey);
+        }
+        else {
+            // If we have a temp store, promote it
+            if (this._tempStores.has(queryset)) {
+                store = this._tempStores.get(queryset);
+                store.isTemp = false; // Promote to permanent store
+                store.registerWithModelStore(); // Register for model store changes now that it's permanent
+                this._stores.set(semanticKey, store);
+            }
+            else {
+                // Create a new permanent store
+                store = this.getStore(queryset);
+                store.isTemp = false;
+                store.registerWithModelStore(); // Register for model store changes now that it's permanent
+                this._stores.set(semanticKey, store);
+            }
+        }
+        store.setGroundTruth(instances.map(instance => instance[queryset.ModelClass.primaryKeyField] || instance));
+        return instances;
+    }
+    /**
+     * Get all queryset stores for a specific model class
+     * @param {ModelClass} ModelClass - The model class to get stores for
+     * @returns {Array} - Array of queryset stores for this model
+     */
+    getAllStoresForModel(ModelClass) {
+        if (!ModelClass)
+            return [];
+        return Array.from(this._stores.values()).filter(store => store.modelClass === ModelClass);
+    }
+    /**
+     * Sync a queryset, coordinating with its chain to minimize DB calls.
+     * The root fetches from DB, children filter from cached results.
+     * Uses operationId to coordinate - whoever arrives first creates the promise,
+     * the root takes over and resolves it.
+     *
+     * @param {Object} queryset - The queryset to sync
+     * @param {string} operationId - Unique ID for this sync operation (for coordination)
+     * @param {Set} dbSyncedKeys - Set of semanticKeys that are dbSynced (followedQuerysets)
+     */
+    async groupSync(queryset, operationId, dbSyncedKeys) {
+        if (isNil(queryset))
+            return;
+        const semanticKey = queryset.semanticKey;
+        const ModelClass = queryset.ModelClass;
+        // Convert dbSyncedKeys to semanticKeys if needed
+        const subset = new Set();
+        for (const item of dbSyncedKeys) {
+            subset.add(typeof item === 'string' ? item : item?.semanticKey);
+        }
+        // Find the dbSynced root
+        const { isRoot, root: rootKey } = this.querysetStoreGraph.findRoot(queryset, subset);
+        const iAmRoot = isRoot || rootKey === semanticKey;
+        // Get or create cache entry - whoever arrives first creates it
+        if (!this._groupSyncCache.has(operationId)) {
+            let resolve;
+            const promise = new Promise(r => { resolve = r; });
+            this._groupSyncCache.set(operationId, { promise, resolve, pks: null, ModelClass });
+            setTimeout(() => this._groupSyncCache.delete(operationId), 5000);
+        }
+        const cached = this._groupSyncCache.get(operationId);
+        const store = this._stores.get(semanticKey);
+        if (!store) {
+            console.warn(`[groupSync] No store found for queryset: ${semanticKey}`);
+            return;
+        }
+        if (iAmRoot) {
+            // I'm the root - sync from DB (store handles everything)
+            await store.sync();
+            cached.pks = store.groundTruthPks;
+            cached.resolve();
+        }
+        else {
+            // Wait for root to finish
+            await cached.promise;
+            // Filter from cached root data
+            const rootInstances = cached.pks.map(pk => ModelClass.fromPk(pk, queryset));
+            const ast = queryset.build();
+            const filteredPks = filter(rootInstances, ast, ModelClass, false);
+            // Set ground truth and clean up inflight ops (like sync does)
+            store.setGroundTruth(filteredPks);
+            store.setOperations(store.getInflightOperations());
+            store.lastSync = Date.now();
+        }
+    }
+}
+export const querysetStoreRegistry = new QuerysetStoreRegistry();

package/dist/syncEngine/stores/metricStore.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Store for managing a single metric with optimistic updates
+ */
+export class MetricStore {
+    constructor(metricType: any, modelClass: any, queryset: any, field: null | undefined, ast: null | undefined, fetchFn: any);
+    metricType: any;
+    modelClass: any;
+    queryset: any;
+    field: any;
+    ast: any;
+    fetchFn: any;
+    groundTruthValue: any;
+    isSyncing: boolean;
+    strategy: import("../metrics/metricOptCalcs.js").MetricCalculationStrategy;
+    operations: any[];
+    confirmedOps: Set<any>;
+    metricCache: Cache;
+    _lastCalculatedValue: any;
+    reset(): void;
+    get cacheKey(): string;
+    /**
+     * Add an operation to this metric store
+     * @param {Operation} operation - The operation to add
+     */
+    addOperation(operation: Operation): void;
+    /**
+     * Update an operation in this metric store
+     * @param {Operation} operation - The operation to update
+     */
+    updateOperation(operation: Operation): void;
+    /**
+     * Confirm an operation in this metric store
+     * @param {Operation} operation - The operation to confirm
+     */
+    confirm(operation: Operation): void;
+    /**
+     * Reject an operation in this metric store
+     * @param {Operation} operation - The operation to reject
+     */
+    reject(operation: Operation): void;
+    onHydrated(): void;
+    setCache(): void;
+    clearCache(): void;
+    setGroundTruth(value: any): void;
+    /**
+     * Render the metric with current operations
+     * @returns {any} Calculated metric value
+     */
+    render(): any;
+    /**
+     * Sync metric with server
+     */
+    sync(): Promise<any>;
+}
+import { Cache } from '../cache/cache.js';