@oxyhq/services 6.9.13 → 6.9.15

package/src/ui/stores/accountStore.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAccountLoadingSession = exports.useAccountError = exports.useAccountLoading = exports.useAccounts = exports.useAccountStore = void 0;
+const zustand_1 = require("zustand");
+const core_1 = require("@oxyhq/core");
+const initialState = {
+    accounts: {},
+    accountOrder: [],
+    accountsArray: [],
+    loading: false,
+    loadingSessionIds: new Set(),
+    error: null,
+};
+exports.useAccountStore = (0, zustand_1.create)((set, get) => ({
+    ...initialState,
+    setAccounts: (accounts) => set((state) => {
+        const accountMap = {};
+        const order = [];
+        const seenSessionIds = new Set();
+        for (const account of accounts) {
+            if (seenSessionIds.has(account.sessionId))
+                continue;
+            seenSessionIds.add(account.sessionId);
+            accountMap[account.sessionId] = account;
+            order.push(account.sessionId);
+        }
+        const accountsArray = (0, core_1.buildAccountsArray)(accountMap, order);
+        const sameOrder = order.length === state.accountOrder.length &&
+            order.every((id, i) => id === state.accountOrder[i]);
+        const sameAccounts = sameOrder &&
+            order.every(id => {
+                const existing = state.accounts[id];
+                const newAccount = accountMap[id];
+                return existing &&
+                    existing.sessionId === newAccount.sessionId &&
+                    existing.userId === newAccount.userId &&
+                    existing.avatar === newAccount.avatar &&
+                    existing.avatarUrl === newAccount.avatarUrl;
+            });
+        if (sameAccounts)
+            return {};
+        return { accounts: accountMap, accountOrder: order, accountsArray };
+    }),
+    addAccount: (account) => set((state) => {
+        // Check if account with same sessionId exists
+        if (state.accounts[account.sessionId]) {
+            // Update existing
+            const existing = state.accounts[account.sessionId];
+            if (existing.avatar === account.avatar && existing.avatarUrl === account.avatarUrl) {
+                return {}; // No change
+            }
+            const newAccounts = { ...state.accounts, [account.sessionId]: account };
+            return {
+                accounts: newAccounts,
+                accountsArray: (0, core_1.buildAccountsArray)(newAccounts, state.accountOrder),
+            };
+        }
+        const newAccounts = { ...state.accounts, [account.sessionId]: account };
+        const newOrder = [account.sessionId, ...state.accountOrder];
+        return {
+            accounts: newAccounts,
+            accountOrder: newOrder,
+            accountsArray: (0, core_1.buildAccountsArray)(newAccounts, newOrder),
+        };
+    }),
+    updateAccount: (sessionId, updates) => set((state) => {
+        const existing = state.accounts[sessionId];
+        if (!existing)
+            return {};
+        const updated = { ...existing, ...updates };
+        if (existing.avatar === updated.avatar && existing.avatarUrl === updated.avatarUrl) {
+            return {}; // No change
+        }
+        const newAccounts = { ...state.accounts, [sessionId]: updated };
+        return {
+            accounts: newAccounts,
+            accountsArray: (0, core_1.buildAccountsArray)(newAccounts, state.accountOrder),
+        };
+    }),
+    removeAccount: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId])
+            return {};
+        const { [sessionId]: _removed, ...rest } = state.accounts;
+        const newOrder = state.accountOrder.filter(id => id !== sessionId);
+        return {
+            accounts: rest,
+            accountOrder: newOrder,
+            accountsArray: (0, core_1.buildAccountsArray)(rest, newOrder),
+        };
+    }),
+    moveAccountToTop: (sessionId) => set((state) => {
+        if (!state.accounts[sessionId])
+            return {};
+        const filtered = state.accountOrder.filter(id => id !== sessionId);
+        const newOrder = [sessionId, ...filtered];
+        return {
+            accountOrder: newOrder,
+            accountsArray: (0, core_1.buildAccountsArray)(state.accounts, newOrder),
+        };
+    }),
+    setLoading: (loading) => set({ loading }),
+    setLoadingSession: (sessionId, loading) => set((state) => {
+        const newSet = new Set(state.loadingSessionIds);
+        if (loading) {
+            newSet.add(sessionId);
+        }
+        else {
+            newSet.delete(sessionId);
+        }
+        return { loadingSessionIds: newSet };
+    }),
+    setError: (error) => set({ error }),
+    loadAccounts: async (sessionIds, oxyServices, existingAccounts = [], preserveOrder = true) => {
+        const state = get();
+        const uniqueSessionIds = Array.from(new Set(sessionIds));
+        if (uniqueSessionIds.length === 0) {
+            get().setAccounts([]);
+            return;
+        }
+        // Try to get data from TanStack Query cache first
+        try {
+            // This will be called from a component, so we need to access queryClient differently
+            // For now, we'll keep the API call but optimize it
+            const existingMap = new Map(existingAccounts.map(a => [a.sessionId, a]));
+            for (const account of Object.values(state.accounts)) {
+                existingMap.set(account.sessionId, account);
+            }
+            const missingSessionIds = uniqueSessionIds.filter(id => !existingMap.has(id));
+            if (missingSessionIds.length === 0) {
+                const ordered = uniqueSessionIds
+                    .map(id => existingMap.get(id))
+                    .filter((acc) => acc !== undefined);
+                get().setAccounts(ordered);
+                return;
+            }
+            if (state.loading) {
+                return;
+            }
+            set({ loading: true, error: null });
+            try {
+                const batchResults = await oxyServices.getUsersBySessions(missingSessionIds);
+                const accountMap = new Map();
+                for (const { sessionId, user: userData } of batchResults) {
+                    if (userData && !accountMap.has(sessionId)) {
+                        const existing = existingMap.get(sessionId);
+                        accountMap.set(sessionId, (0, core_1.createQuickAccount)(sessionId, userData, existing, (fileId, variant) => oxyServices.getFileDownloadUrl(fileId, variant)));
+                    }
+                }
+                for (const [sessionId, account] of accountMap) {
+                    existingMap.set(sessionId, account);
+                }
+                const orderToUse = preserveOrder ? uniqueSessionIds : [...uniqueSessionIds, ...state.accountOrder];
+                const seen = new Set();
+                const ordered = [];
+                for (const sessionId of orderToUse) {
+                    if (seen.has(sessionId))
+                        continue;
+                    seen.add(sessionId);
+                    const account = existingMap.get(sessionId);
+                    if (account)
+                        ordered.push(account);
+                }
+                get().setAccounts(ordered);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+                if (__DEV__) {
+                    console.error('AccountStore: Failed to load accounts:', error);
+                }
+                set({ error: errorMessage });
+            }
+            finally {
+                set({ loading: false });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to load accounts';
+            if (__DEV__) {
+                console.error('AccountStore: Failed to load accounts:', error);
+            }
+            set({ error: errorMessage, loading: false });
+        }
+    },
+    reset: () => set(initialState),
+}));
+// Selectors for performance - return cached array to prevent infinite loops
+const useAccounts = () => {
+    return (0, exports.useAccountStore)(state => state.accountsArray);
+};
+exports.useAccounts = useAccounts;
+const useAccountLoading = () => (0, exports.useAccountStore)(s => s.loading);
+exports.useAccountLoading = useAccountLoading;
+const useAccountError = () => (0, exports.useAccountStore)(s => s.error);
+exports.useAccountError = useAccountError;
+const useAccountLoadingSession = (sessionId) => (0, exports.useAccountStore)(s => s.loadingSessionIds.has(sessionId));
+exports.useAccountLoadingSession = useAccountLoadingSession;

package/src/ui/stores/assetStore.d.ts

@@ -0,0 +1,53 @@
+import type { Asset, AssetUploadProgress, AssetLink } from '@oxyhq/core';
+interface AssetState {
+    assets: Record<string, Asset>;
+    uploadProgress: Record<string, AssetUploadProgress>;
+    loading: {
+        uploading: boolean;
+        linking: boolean;
+        deleting: boolean;
+    };
+    errors: {
+        upload?: string;
+        link?: string;
+        delete?: string;
+    };
+    setAsset: (asset: Asset) => void;
+    setAssets: (assets: Asset[]) => void;
+    removeAsset: (assetId: string) => void;
+    setUploadProgress: (fileId: string, progress: AssetUploadProgress) => void;
+    removeUploadProgress: (fileId: string) => void;
+    addLink: (assetId: string, link: AssetLink) => void;
+    removeLink: (assetId: string, app: string, entityType: string, entityId: string) => void;
+    setUploading: (uploading: boolean) => void;
+    setLinking: (linking: boolean) => void;
+    setDeleting: (deleting: boolean) => void;
+    setUploadError: (error?: string) => void;
+    setLinkError: (error?: string) => void;
+    setDeleteError: (error?: string) => void;
+    clearErrors: () => void;
+    getAssetsByApp: (app: string) => Asset[];
+    getAssetsByEntity: (app: string, entityType: string, entityId: string) => Asset[];
+    getAssetUsageCount: (assetId: string) => number;
+    isAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => boolean;
+    reset: () => void;
+}
+export declare const useAssetStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AssetState>>;
+export declare const useAssets: () => Asset[];
+export declare const useAsset: (assetId: string) => Asset;
+export declare const useUploadProgress: () => Record<string, AssetUploadProgress>;
+export declare const useAssetLoading: () => {
+    uploading: boolean;
+    linking: boolean;
+    deleting: boolean;
+};
+export declare const useAssetErrors: () => {
+    upload?: string;
+    link?: string;
+    delete?: string;
+};
+export declare const useAssetsByApp: (app: string) => Asset[];
+export declare const useAssetsByEntity: (app: string, entityType: string, entityId: string) => Asset[];
+export declare const useAssetUsageCount: (assetId: string) => number;
+export declare const useIsAssetLinked: (assetId: string, app: string, entityType: string, entityId: string) => boolean;
+export {};

package/src/ui/stores/assetStore.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsAssetLinked = exports.useAssetUsageCount = exports.useAssetsByEntity = exports.useAssetsByApp = exports.useAssetErrors = exports.useAssetLoading = exports.useUploadProgress = exports.useAsset = exports.useAssets = exports.useAssetStore = void 0;
+const zustand_1 = require("zustand");
+const initialState = {
+    assets: {},
+    uploadProgress: {},
+    loading: {
+        uploading: false,
+        linking: false,
+        deleting: false,
+    },
+    errors: {},
+};
+exports.useAssetStore = (0, zustand_1.create)((set, get) => ({
+    ...initialState,
+    // Asset management
+    setAsset: (asset) => {
+        set((state) => ({
+            assets: {
+                ...state.assets,
+                [asset.id]: asset,
+            },
+        }));
+    },
+    setAssets: (assets) => {
+        set((state) => {
+            const assetMap = assets.reduce((acc, asset) => {
+                acc[asset.id] = asset;
+                return acc;
+            }, {});
+            return {
+                assets: {
+                    ...state.assets,
+                    ...assetMap,
+                },
+            };
+        });
+    },
+    removeAsset: (assetId) => {
+        set((state) => {
+            const { [assetId]: removed, ...rest } = state.assets;
+            return { assets: rest };
+        });
+    },
+    // Upload progress
+    setUploadProgress: (fileId, progress) => {
+        set((state) => ({
+            uploadProgress: {
+                ...state.uploadProgress,
+                [fileId]: progress,
+            },
+        }));
+    },
+    removeUploadProgress: (fileId) => {
+        set((state) => {
+            const { [fileId]: removed, ...rest } = state.uploadProgress;
+            return { uploadProgress: rest };
+        });
+    },
+    // Link management
+    addLink: (assetId, link) => {
+        set((state) => {
+            const asset = state.assets[assetId];
+            if (!asset)
+                return state;
+            // Check if link already exists
+            const existingLink = asset.links.find((l) => l.app === link.app &&
+                l.entityType === link.entityType &&
+                l.entityId === link.entityId);
+            if (existingLink)
+                return state;
+            const updatedAsset = {
+                ...asset,
+                links: [...asset.links, link],
+                usageCount: asset.links.length + 1,
+            };
+            return {
+                assets: {
+                    ...state.assets,
+                    [assetId]: updatedAsset,
+                },
+            };
+        });
+    },
+    removeLink: (assetId, app, entityType, entityId) => {
+        set((state) => {
+            const asset = state.assets[assetId];
+            if (!asset)
+                return state;
+            const filteredLinks = asset.links.filter((link) => !(link.app === app &&
+                link.entityType === entityType &&
+                link.entityId === entityId));
+            const updatedAsset = {
+                ...asset,
+                links: filteredLinks,
+                usageCount: filteredLinks.length,
+                status: filteredLinks.length === 0 ? 'trash' : asset.status,
+            };
+            return {
+                assets: {
+                    ...state.assets,
+                    [assetId]: updatedAsset,
+                },
+            };
+        });
+    },
+    // Loading states
+    setUploading: (uploading) => {
+        set((state) => ({
+            loading: { ...state.loading, uploading },
+        }));
+    },
+    setLinking: (linking) => {
+        set((state) => ({
+            loading: { ...state.loading, linking },
+        }));
+    },
+    setDeleting: (deleting) => {
+        set((state) => ({
+            loading: { ...state.loading, deleting },
+        }));
+    },
+    // Error management
+    setUploadError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, upload: error },
+        }));
+    },
+    setLinkError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, link: error },
+        }));
+    },
+    setDeleteError: (error) => {
+        set((state) => ({
+            errors: { ...state.errors, delete: error },
+        }));
+    },
+    clearErrors: () => {
+        set({ errors: {} });
+    },
+    // Utility methods
+    getAssetsByApp: (app) => {
+        const { assets } = get();
+        return Object.values(assets).filter((asset) => asset.links.some((link) => link.app === app));
+    },
+    getAssetsByEntity: (app, entityType, entityId) => {
+        const { assets } = get();
+        return Object.values(assets).filter((asset) => asset.links.some((link) => link.app === app &&
+            link.entityType === entityType &&
+            link.entityId === entityId));
+    },
+    getAssetUsageCount: (assetId) => {
+        const { assets } = get();
+        const asset = assets[assetId];
+        return asset ? asset.usageCount : 0;
+    },
+    isAssetLinked: (assetId, app, entityType, entityId) => {
+        const { assets } = get();
+        const asset = assets[assetId];
+        if (!asset)
+            return false;
+        return asset.links.some((link) => link.app === app &&
+            link.entityType === entityType &&
+            link.entityId === entityId);
+    },
+    // Reset store
+    reset: () => {
+        set(initialState);
+    },
+}));
+// Selector hooks for convenience
+const useAssets = () => (0, exports.useAssetStore)((state) => Object.values(state.assets));
+exports.useAssets = useAssets;
+const useAsset = (assetId) => (0, exports.useAssetStore)((state) => state.assets[assetId]);
+exports.useAsset = useAsset;
+const useUploadProgress = () => (0, exports.useAssetStore)((state) => state.uploadProgress);
+exports.useUploadProgress = useUploadProgress;
+const useAssetLoading = () => (0, exports.useAssetStore)((state) => state.loading);
+exports.useAssetLoading = useAssetLoading;
+const useAssetErrors = () => (0, exports.useAssetStore)((state) => state.errors);
+exports.useAssetErrors = useAssetErrors;
+// Typed selectors for specific use cases
+const useAssetsByApp = (app) => (0, exports.useAssetStore)((state) => state.getAssetsByApp(app));
+exports.useAssetsByApp = useAssetsByApp;
+const useAssetsByEntity = (app, entityType, entityId) => (0, exports.useAssetStore)((state) => state.getAssetsByEntity(app, entityType, entityId));
+exports.useAssetsByEntity = useAssetsByEntity;
+const useAssetUsageCount = (assetId) => (0, exports.useAssetStore)((state) => state.getAssetUsageCount(assetId));
+exports.useAssetUsageCount = useAssetUsageCount;
+const useIsAssetLinked = (assetId, app, entityType, entityId) => (0, exports.useAssetStore)((state) => state.isAssetLinked(assetId, app, entityType, entityId));
+exports.useIsAssetLinked = useIsAssetLinked;

package/src/ui/stores/authStore.d.ts

@@ -0,0 +1,16 @@
+import type { User } from '@oxyhq/core';
+export interface AuthState {
+    user: User | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    error: string | null;
+    lastUserFetch: number | null;
+    loginSuccess: (user: User) => void;
+    loginFailure: (error: string) => void;
+    logout: () => void;
+    fetchUser: (oxyServices: {
+        getCurrentUser: () => Promise<User>;
+    }, forceRefresh?: boolean) => Promise<void>;
+    setUser: (user: User) => void;
+}
+export declare const useAuthStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AuthState>>;

package/src/ui/stores/authStore.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuthStore = void 0;
+const zustand_1 = require("zustand");
+const core_1 = require("@oxyhq/core");
+const debug = (0, core_1.createDebugLogger)('AuthStore');
+exports.useAuthStore = (0, zustand_1.create)((set, get) => ({
+    user: null,
+    isAuthenticated: false,
+    isLoading: false,
+    error: null,
+    lastUserFetch: null,
+    loginSuccess: (user) => set({
+        isLoading: false,
+        isAuthenticated: true,
+        user,
+        lastUserFetch: Date.now(),
+    }),
+    loginFailure: (error) => set({ isLoading: false, error }),
+    logout: () => set({
+        user: null,
+        isAuthenticated: false,
+        lastUserFetch: null,
+    }),
+    setUser: (user) => set({ user, lastUserFetch: Date.now() }),
+    fetchUser: async (oxyServices, forceRefresh = false) => {
+        const state = get();
+        const now = Date.now();
+        const cacheAge = state.lastUserFetch ? now - state.lastUserFetch : Number.POSITIVE_INFINITY;
+        const cacheValid = cacheAge < 5 * 60 * 1000; // 5 minutes cache
+        // Use cached data if available and not forcing refresh
+        if (!forceRefresh && state.user && cacheValid) {
+            debug.log('Using cached user data (age:', cacheAge, 'ms)');
+            return;
+        }
+        set({ isLoading: true, error: null });
+        try {
+            const user = await oxyServices.getCurrentUser();
+            set({ user, isLoading: false, isAuthenticated: true, lastUserFetch: now });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Failed to fetch user';
+            debug.error('Error fetching user:', error);
+            set({ error: errorMessage, isLoading: false });
+        }
+    },
+}));

package/src/ui/stores/fileStore.d.ts

@@ -0,0 +1,30 @@
+import type { FileMetadata } from '@oxyhq/core';
+export interface FileUploadAggregateProgress {
+    current: number;
+    total: number;
+}
+interface FileState {
+    files: Record<string, FileMetadata>;
+    order: string[];
+    uploading: boolean;
+    deleting: string | null;
+    uploadProgress: FileUploadAggregateProgress | null;
+    setFiles: (files: FileMetadata[], opts?: {
+        merge?: boolean;
+    }) => void;
+    addFile: (file: FileMetadata, opts?: {
+        prepend?: boolean;
+    }) => void;
+    updateFile: (id: string, patch: Partial<FileMetadata>) => void;
+    removeFile: (id: string) => void;
+    setUploading: (val: boolean) => void;
+    setDeleting: (id: string | null) => void;
+    setUploadProgress: (p: FileUploadAggregateProgress | null) => void;
+    reset: () => void;
+}
+export declare const useFileStore: import("zustand").UseBoundStore<import("zustand").StoreApi<FileState>>;
+export declare const useFiles: () => FileMetadata[];
+export declare const useUploading: () => boolean;
+export declare const useUploadAggregateProgress: () => FileUploadAggregateProgress | null;
+export declare const useDeleting: () => string | null;
+export {};

package/src/ui/stores/fileStore.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeleting = exports.useUploadAggregateProgress = exports.useUploading = exports.useFiles = exports.useFileStore = void 0;
+const zustand_1 = require("zustand");
+// Shallow compare two file metadata objects by keys/values
+function shallowEqualFile(a, b) {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const k of aKeys) {
+        // treat metadata/variants shallowly by reference
+        if (a[k] !== b[k])
+            return false;
+    }
+    return true;
+}
+const initialState = {
+    files: {},
+    order: [],
+    uploading: false,
+    deleting: null,
+    uploadProgress: null,
+};
+exports.useFileStore = (0, zustand_1.create)((set, get) => ({
+    ...initialState,
+    setFiles: (files, opts) => set(state => {
+        const merge = opts?.merge !== false; // default true
+        if (!merge) {
+            const map = {};
+            const order = [];
+            files.forEach(f => { map[f.id] = f; order.push(f.id); });
+            // detect if identical to avoid redundant updates
+            const sameOrder = order.length === state.order.length && order.every((id, i) => id === state.order[i]);
+            let sameFiles = sameOrder;
+            if (sameOrder) {
+                sameFiles = order.every(id => state.files[id] && shallowEqualFile(state.files[id], map[id]));
+            }
+            if (sameOrder && sameFiles)
+                return state;
+            return { files: map, order };
+        }
+        const newFiles = { ...state.files };
+        const newOrder = [...state.order];
+        let changed = false;
+        files.forEach(f => {
+            const prev = state.files[f.id];
+            const merged = { ...(prev || {}), ...f };
+            if (!prev || !shallowEqualFile(prev, merged)) {
+                newFiles[f.id] = merged;
+                changed = true;
+            }
+            if (!newOrder.includes(f.id)) {
+                newOrder.unshift(f.id);
+                changed = true;
+            }
+        });
+        if (!changed)
+            return state;
+        return { files: newFiles, order: newOrder };
+    }),
+    addFile: (file, opts) => set(state => {
+        const prepend = opts?.prepend !== false; // default true
+        if (state.files[file.id]) {
+            if (shallowEqualFile(state.files[file.id], file))
+                return state;
+            return { files: { ...state.files, [file.id]: file } };
+        }
+        return {
+            files: { ...state.files, [file.id]: file },
+            order: prepend ? [file.id, ...state.order] : [...state.order, file.id],
+        };
+    }),
+    updateFile: (id, patch) => set(state => {
+        const existing = state.files[id];
+        if (!existing)
+            return state;
+        const updated = { ...existing, ...patch };
+        if (shallowEqualFile(existing, updated))
+            return state;
+        return { files: { ...state.files, [id]: updated } };
+    }),
+    removeFile: (id) => set(state => {
+        if (!state.files[id])
+            return state;
+        const { [id]: _removed, ...rest } = state.files;
+        const newOrder = state.order.filter(fid => fid !== id);
+        return { files: rest, order: newOrder };
+    }),
+    setUploading: (val) => set({ uploading: val }),
+    setDeleting: (id) => set({ deleting: id }),
+    setUploadProgress: (p) => set({ uploadProgress: p }),
+    reset: () => set(initialState),
+}));
+// selectors
+const useFiles = () => {
+    const files = (0, exports.useFileStore)(s => s.files);
+    const order = (0, exports.useFileStore)(s => s.order);
+    // Return stable array when contents unchanged
+    const out = order.map((id) => files[id]);
+    return out;
+};
+exports.useFiles = useFiles;
+const useUploading = () => (0, exports.useFileStore)(s => s.uploading);
+exports.useUploading = useUploading;
+const useUploadAggregateProgress = () => (0, exports.useFileStore)(s => s.uploadProgress);
+exports.useUploadAggregateProgress = useUploadAggregateProgress;
+const useDeleting = () => (0, exports.useFileStore)(s => s.deleting);
+exports.useDeleting = useDeleting;

package/src/ui/stores/followStore.d.ts

@@ -0,0 +1,24 @@
+import type { OxyServices } from '@oxyhq/core';
+interface FollowState {
+    followingUsers: Record<string, boolean>;
+    loadingUsers: Record<string, boolean>;
+    fetchingUsers: Record<string, boolean>;
+    errors: Record<string, string | null>;
+    followerCounts: Record<string, number>;
+    followingCounts: Record<string, number>;
+    loadingCounts: Record<string, boolean>;
+    setFollowingStatus: (userId: string, isFollowing: boolean) => void;
+    clearFollowError: (userId: string) => void;
+    resetFollowState: () => void;
+    fetchFollowStatus: (userId: string, oxyServices: OxyServices) => Promise<void>;
+    toggleFollowUser: (userId: string, oxyServices: OxyServices, isCurrentlyFollowing: boolean) => Promise<void>;
+    setFollowerCount: (userId: string, count: number) => void;
+    setFollowingCount: (userId: string, count: number) => void;
+    updateCountsFromFollowAction: (targetUserId: string, action: 'follow' | 'unfollow', counts: {
+        followers: number;
+        following: number;
+    }, currentUserId?: string) => void;
+    fetchUserCounts: (userId: string, oxyServices: OxyServices) => Promise<void>;
+}
+export declare const useFollowStore: import("zustand").UseBoundStore<import("zustand").StoreApi<FollowState>>;
+export {};