@oxyhq/services 6.9.15 → 6.9.17

package/src/ui/stores/accountStore.js

@@ -1,196 +0,0 @@
-"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

@@ -1,53 +0,0 @@
-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

@@ -1,192 +0,0 @@
-"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

@@ -1,16 +0,0 @@
-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

@@ -1,47 +0,0 @@
-"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

@@ -1,30 +0,0 @@
-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

@@ -1,113 +0,0 @@
-"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

@@ -1,24 +0,0 @@
-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 {};