@oxyhq/services 30.0.0 → 30.0.1

package/lib/typescript/commonjs/ui/hooks/queries/paymentTypes.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Payment / wallet / subscription domain types.
+ *
+ * These model the JSON shapes the Oxy API actually returns for the
+ * payment-related read endpoints, so the corresponding query hooks
+ * (`useUserSubscription`, `useUserPayments`, `useUserWallet`,
+ * `useUserWalletTransactions`) expose precise types instead of `any`.
+ *
+ * Source of truth (API):
+ *  - Subscription:  GET /subscription/:userId   -> billing-first normalized
+ *                   subscription JSON (Stripe `BillingSubscription` with legacy
+ *                   `Subscription` fallback), or `{ plan: 'basic' }` when none.
+ *  - Payments:      GET /payments/user          -> `Payment[]` (sendSuccess).
+ *  - Wallet:        GET /wallet/:userId         -> `Wallet` (sendSuccess).
+ *  - Transactions:  GET /wallet/transactions/:userId
+ *                   -> `WalletTransactionsResponse` (sendPaginated envelope).
+ *
+ * All `Date` columns are serialized as ISO-8601 strings over the wire.
+ *
+ * Note: `@oxyhq/services` deliberately does NOT re-export these from
+ * `@oxyhq/core`. They live here because they describe the return shape of
+ * the services-layer query hooks; consumers that need core domain types
+ * import those directly from `@oxyhq/core`.
+ */
+/** Subscription tier. Mirrors the `plan` enum on the API `Subscription` model. */
+export type SubscriptionPlan = 'basic' | 'pro' | 'business';
+/** Lifecycle state of a subscription. */
+export type SubscriptionStatus = 'active' | 'canceled' | 'expired';
+/** Feature flags toggled by the active subscription plan. */
+export interface SubscriptionFeatures {
+    analytics: boolean;
+    premiumBadge: boolean;
+    unlimitedFollowing: boolean;
+    higherUploadLimits: boolean;
+    promotedPosts: boolean;
+    businessTools: boolean;
+}
+/**
+ * A user's subscription.
+ *
+ * When a user has never subscribed, the API returns the minimal fallback
+ * `{ plan: 'basic' }`; every other field is therefore optional so the type
+ * covers both the persisted document and the fallback.
+ */
+export interface Subscription {
+    plan: SubscriptionPlan;
+    status?: SubscriptionStatus;
+    /** Account this subscription belongs to (absent on the basic fallback). */
+    userId?: string;
+    /** ISO-8601 timestamp the current period started. */
+    startDate?: string;
+    /** ISO-8601 timestamp the current period ends / renews. */
+    endDate?: string;
+    autoRenew?: boolean;
+    paymentMethod?: string;
+    latestInvoice?: string;
+    features?: SubscriptionFeatures;
+    /** ISO-8601 creation timestamp. */
+    createdAt?: string;
+    /** ISO-8601 last-update timestamp. */
+    updatedAt?: string;
+}
+/**
+ * A billing / payment history entry, derived from `deposit` and `purchase`
+ * transactions on the API side (`GET /payments/user`).
+ */
+export interface Payment {
+    id: string;
+    userId: string;
+    type: string;
+    amount: number;
+    status: string;
+    description?: string;
+    itemId?: string;
+    itemType?: string;
+    /** ISO-8601 timestamp the payment was created (maps to `createdAt`). */
+    timestamp?: string;
+    /** ISO-8601 timestamp the payment settled, when applicable. */
+    completedAt?: string;
+}
+/** FairCoin wallet balance for a user (`GET /wallet/:userId`). */
+export interface Wallet {
+    userId: string;
+    balance: number;
+    /** On-chain withdrawal address, `null` until one is set. */
+    address: string | null;
+}
+/** Direction/category of a wallet transaction. */
+export type WalletTransactionType = 'deposit' | 'withdrawal' | 'transfer' | 'purchase';
+/** Settlement state of a wallet transaction. */
+export type WalletTransactionStatus = 'pending' | 'completed' | 'failed' | 'cancelled';
+/**
+ * A single wallet ledger entry returned by the transaction-history endpoint.
+ *
+ * The populated `userId` / `recipientId` may arrive either as a bare id
+ * string or as a `{ _id, username }` object depending on Mongoose
+ * population, so both shapes are modelled.
+ */
+export interface WalletTransaction {
+    id: string;
+    userId: string | {
+        _id: string;
+        username?: string;
+    };
+    type: WalletTransactionType;
+    amount: number;
+    status: WalletTransactionStatus;
+    description?: string;
+    recipientId?: string | {
+        _id: string;
+        username?: string;
+    } | null;
+    itemId?: string;
+    itemType?: string;
+    /** ISO-8601 creation timestamp (maps to `createdAt`). */
+    timestamp?: string;
+    /** ISO-8601 settlement timestamp, when applicable. */
+    completedAt?: string;
+}
+/** Pagination metadata attached to a paginated list response. */
+export interface WalletPagination {
+    total: number;
+    limit: number;
+    offset: number;
+    hasMore: boolean;
+}
+/**
+ * Paginated envelope returned by `GET /wallet/transactions/:userId`.
+ *
+ * The HTTP layer preserves the `{ data, pagination }` shape for paginated
+ * responses (it only unwraps the plain `{ data }` success envelope), so
+ * callers receive the list under `data`.
+ */
+export interface WalletTransactionsResponse {
+    data: WalletTransaction[];
+    pagination: WalletPagination;
+}
+//# sourceMappingURL=paymentTypes.d.ts.map

package/lib/typescript/commonjs/ui/hooks/queries/paymentTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paymentTypes.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/paymentTypes.ts"],"names":[],"mappings":"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"}

package/lib/typescript/commonjs/ui/hooks/queries/queryKeys.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Centralized query keys for TanStack Query
+ *
+ * Following best practices:
+ * - Use arrays for hierarchical keys
+ * - Include all parameters in the key
+ * - Use consistent naming conventions
+ */
+import type { QueryClient } from '@tanstack/react-query';
+export declare const queryKeys: {
+    readonly accounts: {
+        readonly all: readonly ["accounts"];
+        readonly lists: () => readonly ["accounts", "list"];
+        readonly list: (sessionIds: string[]) => readonly ["accounts", "list", string[]];
+        readonly details: () => readonly ["accounts", "detail"];
+        readonly detail: (sessionId: string) => readonly ["accounts", "detail", string];
+        readonly current: (sessionId?: string | null) => readonly ["accounts", "current", string] | readonly ["accounts", "current"];
+        readonly settings: () => readonly ["accounts", "settings"];
+    };
+    readonly users: {
+        readonly all: readonly ["users"];
+        readonly lists: () => readonly ["users", "list"];
+        readonly list: (userIds: string[]) => readonly ["users", "list", string[]];
+        readonly details: () => readonly ["users", "detail"];
+        readonly detail: (userId: string) => readonly ["users", "detail", string];
+        /** Viewer-scoped single-profile fetch by user id (`relationship` is viewer-relative). */
+        readonly detailForViewer: (userId: string, viewerId: string) => readonly ["users", "detail", string, "viewer", string];
+        /**
+         * Viewer-scoped single-profile fetch by username (`relationship` is
+         * viewer-relative). Username is normalized to `trim().toLowerCase()` here
+         * so the hook key and any external seeder (e.g. Mention's precache) agree
+         * by construction — normalize once, never at call sites.
+         */
+        readonly byUsername: (username: string, viewerId: string) => readonly ["users", "detail", "username", string, "viewer", string];
+        readonly profile: (sessionId: string) => readonly ["users", "detail", string, "profile"];
+    };
+    readonly sessions: {
+        readonly all: readonly ["sessions"];
+        readonly lists: () => readonly ["sessions", "list"];
+        readonly list: (userId?: string) => readonly ["sessions", "list", string | undefined];
+        readonly details: () => readonly ["sessions", "detail"];
+        readonly detail: (sessionId: string) => readonly ["sessions", "detail", string];
+        readonly active: () => readonly ["sessions", "active"];
+        readonly device: (deviceId: string) => readonly ["sessions", "device", string];
+    };
+    readonly devices: {
+        readonly all: readonly ["devices"];
+        readonly lists: () => readonly ["devices", "list"];
+        readonly list: (accountScope?: string) => readonly ["devices", "list", string | undefined];
+        readonly details: () => readonly ["devices", "detail"];
+        readonly detail: (deviceId: string) => readonly ["devices", "detail", string];
+    };
+    readonly privacy: {
+        readonly all: readonly ["privacy"];
+        readonly settings: (userId?: string) => readonly ["privacy", "settings", string];
+    };
+    readonly security: {
+        readonly all: readonly ["security"];
+        readonly activity: (limit?: number, offset?: number, eventType?: string) => readonly ["security", "activity", number | undefined, number | undefined, string | undefined];
+        readonly recent: (limit: number) => readonly ["security", "recent", number];
+        readonly infinite: (limit: number, eventType?: string) => readonly ["security", "infinite", number, string | undefined];
+    };
+    readonly authMethods: {
+        readonly all: readonly ["authMethods"];
+        readonly list: (userId?: string) => readonly ["authMethods", "list", string];
+    };
+    readonly storage: {
+        readonly all: readonly ["storage"];
+        readonly usage: (accountScope?: string) => readonly ["storage", "usage", string | undefined];
+    };
+    readonly files: {
+        readonly all: readonly ["files"];
+        readonly list: (ownerId?: string) => readonly ["files", "list", string];
+    };
+    readonly connectedApps: {
+        readonly all: readonly ["connectedApps"];
+        readonly list: () => readonly ["connectedApps", "list"];
+    };
+    readonly follow: {
+        readonly all: readonly ["follow"];
+        readonly counts: (userId: string) => readonly ["follow", "counts", string];
+    };
+    readonly payments: {
+        readonly all: readonly ["payments"];
+        readonly subscription: (userId?: string) => readonly ["payments", "subscription", string];
+        readonly history: (userId?: string) => readonly ["payments", "history", string];
+        readonly wallet: (userId?: string) => readonly ["payments", "wallet", string];
+        readonly walletTransactions: (limit?: number, offset?: number, userId?: string) => readonly ["payments", "wallet", string, "transactions", number | undefined, number | undefined];
+    };
+};
+/**
+ * Helper to invalidate all account-related queries
+ */
+export declare const invalidateAccountQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all user-related queries
+ */
+export declare const invalidateUserQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all session-related queries
+ */
+export declare const invalidateSessionQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all device-related queries
+ */
+export declare const invalidateDeviceQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all privacy-settings queries
+ */
+export declare const invalidatePrivacyQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all security-activity queries
+ */
+export declare const invalidateSecurityQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all storage-usage queries
+ */
+export declare const invalidateStorageQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate the user's linked auth-methods list (call after linking
+ * or removing a passkey / password / identity key).
+ */
+export declare const invalidateAuthMethodsQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate all payments / wallet / subscription queries
+ */
+export declare const invalidatePaymentsQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate the user's connected-apps list
+ */
+export declare const invalidateConnectedAppsQueries: (queryClient: QueryClient) => void;
+/**
+ * Helper to invalidate the user's file library (all owners). Pass an ownerId via
+ * `queryKeys.files.list(ownerId)` for a scoped invalidation instead.
+ */
+export declare const invalidateFileQueries: (queryClient: QueryClient) => void;
+//# sourceMappingURL=queryKeys.d.ts.map

package/lib/typescript/commonjs/ui/hooks/queries/queryKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryKeys.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/queryKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,eAAO,MAAM,SAAS;;;;oCAKC,MAAM,EAAE;;qCAEP,MAAM;uCACJ,MAAM,GAAG,IAAI;;;;;;iCAWnB,MAAM,EAAE;;kCAEP,MAAM;QACvB,yFAAyF;2CAC/D,MAAM,YAAY,MAAM;QAElD;;;;;WAKG;wCACoB,MAAM,YAAY,MAAM;sCAQ1B,MAAM;;;;;iCAOX,MAAM;;qCAEF,MAAM;;oCAEP,MAAM;;;;;uCAOH,MAAM;;oCAET,MAAM;;;;qCAML,MAAM;;;;oCAMP,MAAM,WAAW,MAAM,cAAc,MAAM;iCAE9C,MAAM;mCAEJ,MAAM,cAAc,MAAM;;;;iCAO5B,MAAM;;;;wCAMC,MAAM;;;;kCAOZ,MAAM;;;;;;;;kCAYN,MAAM;;;;yCAMC,MAAM;oCAEX,MAAM;mCAEP,MAAM;8CAEK,MAAM,WAAW,MAAM,WAAW,MAAM;;CAU/D,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,aAAa,WAAW,KAAG,IAEnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,WAAW,KAAG,IAEhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,aAAa,WAAW,KAAG,IAEnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,uBAAuB,GAAI,aAAa,WAAW,KAAG,IAElE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,aAAa,WAAW,KAAG,IAEnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,GAAI,aAAa,WAAW,KAAG,IAEpE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,wBAAwB,GAAI,aAAa,WAAW,KAAG,IAEnE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GAAI,aAAa,WAAW,KAAG,IAEvE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,yBAAyB,GAAI,aAAa,WAAW,KAAG,IAEpE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,8BAA8B,GAAI,aAAa,WAAW,KAAG,IAEzE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,WAAW,KAAG,IAEhE,CAAC"}

package/lib/typescript/commonjs/ui/hooks/queries/useAccountQueries.d.ts

@@ -0,0 +1,87 @@
+import type { ConnectedApp, User } from '@oxyhq/core';
+/**
+ * Get user profile by session ID
+ */
+export declare const useUserProfile: (sessionId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<User>, Error>;
+/**
+ * Get multiple user profiles by session IDs (batch query)
+ */
+export declare const useUserProfiles: (sessionIds: string[], options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<User | null, Error>[];
+/**
+ * Get current authenticated user.
+ *
+ * Hydrates from `GET /users/me` (the bearer identifies the session) rather than
+ * `GET /session/user/:activeSessionId`. Post zero-cookie cutover the bearer is
+ * the single source of session truth, so keying the CURRENT user off a session
+ * id in the URL was a second, independently-updated source that could disagree
+ * with the bearer during an account switch — the request fired under the
+ * previous account's token against the new account's session id and 404'd. The
+ * query KEY stays scoped to the active account so the cache re-scopes (and
+ * refetches) on a switch; only the URL stopped carrying a session id.
+ *
+ * The store-mirror effect must NOT overwrite the in-memory user while a
+ * write mutation is in flight — otherwise a stale background refetch
+ * landing between optimistic update and server-confirmed update would
+ * revert the optimistic value and flicker the UI.
+ *
+ * We gate the mirror on the mutation-cache state for any mutation that
+ * touches `User` shape (profile, avatar, settings, privacy). When any of
+ * those is in flight we skip the mirror entirely; the winning onSuccess
+ * handler is responsible for writing the final value to the store.
+ */
+export declare const useCurrentUser: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<User>, Error>;
+/**
+ * Get user by ID (identity-by-id).
+ *
+ * Keyed on the viewer-INDEPENDENT `queryKeys.users.detail(id)`: this hook is
+ * the card-identity workhorse (name, avatar, username, verified) and does NOT
+ * read the viewer-relative `relationship` field. Keeping the key
+ * viewer-independent lets external by-id identity seeders / precache layers
+ * (e.g. Mention's card enrichment) that all write `queryKeys.users.detail(id)`
+ * share a single cache entry — a viewer-scoped key would dead-end every seed
+ * and cause avatar/name flashes plus N+1 fetches.
+ *
+ * A viewer-scoped, relationship-aware by-id PROFILE fetch is intentionally NOT
+ * this hook — it would be a separate future `useUserProfileById` keyed on
+ * `queryKeys.users.detailForViewer(id, viewerId)`. No current consumer reads
+ * `relationship` from a by-id fetch (only the username path does).
+ */
+export declare const useUserById: (userId: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<User>, Error>;
+/**
+ * Get user profile by username
+ */
+export declare const useUserByUsername: (username: string | null, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<User>, Error>;
+/**
+ * Batch get users by session IDs (optimized single API call)
+ */
+export declare const useUsersBySessions: (sessionIds: string[], options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<{
+    sessionId: string;
+    user: User | null;
+}[]>, Error>;
+/**
+ * List the third-party OAuth applications the current user has connected via
+ * the consent flow (`GET /auth/grants`). Drives the "Connected apps" management
+ * screen.
+ */
+export declare const useConnectedApps: (options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<ConnectedApp[]>, Error>;
+/**
+ * Get privacy settings for a user
+ */
+export declare const usePrivacySettings: (userId?: string, options?: {
+    enabled?: boolean;
+}) => import("@tanstack/react-query").UseQueryResult<NoInfer<import("@oxyhq/core").PrivacySettings>, Error>;
+//# sourceMappingURL=useAccountQueries.d.ts.map

package/lib/typescript/commonjs/ui/hooks/queries/useAccountQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAccountQueries.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/useAccountQueries.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAMtD;;GAEG;AACH,eAAO,MAAM,cAAc,GAAI,WAAW,MAAM,GAAG,IAAI,EAAE,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,yEAevF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAAI,YAAY,MAAM,EAAE,EAAE,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,yEAepF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,yEA2D7D,CAAC;AAsBF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,MAAM,GAAG,IAAI,EAAE,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,yEAejF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,GAAG,IAAI,EAAE,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,yEA6CzF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,YAAY,MAAM,EAAE,EAAE,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE;;;YAevF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,mFAgB/D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAS,MAAM,EAAE,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,0GAwBlF,CAAC"}

package/lib/typescript/commonjs/ui/hooks/queries/useAuthMethods.d.ts

@@ -0,0 +1,212 @@
+import type { AuthMethodEntry, AuthMethodsResponse } from '@oxyhq/contracts';
+/**
+ * The current account's linked authentication methods (`GET /auth/methods`),
+ * plus convenience projections. Backs the security / account surfaces that let a
+ * user see and manage their passwords, identity key, social logins, and passkeys.
+ *
+ * `passkeys` is the `type === 'webauthn'` subset — one entry per registered
+ * credential. Invalidate via `queryKeys.authMethods.all` after linking a passkey
+ * (`useOxy().addPasskey()` does this) or removing one.
+ */
+export declare const useAuthMethods: (options?: {
+    enabled?: boolean;
+}) => {
+    /** Every linked auth method. Empty while loading. */
+    methods: readonly AuthMethodEntry[];
+    /** The registered passkeys (a `type === 'webauthn'` subset of `methods`). */
+    passkeys: AuthMethodEntry[];
+    /** The account's DID, or `null` while loading. */
+    did: string | null;
+    data: NoInfer<AuthMethodsResponse>;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthMethodsResponse>, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<NoInfer<AuthMethodsResponse>>;
+} | {
+    /** Every linked auth method. Empty while loading. */
+    methods: readonly AuthMethodEntry[];
+    /** The registered passkeys (a `type === 'webauthn'` subset of `methods`). */
+    passkeys: AuthMethodEntry[];
+    /** The account's DID, or `null` while loading. */
+    did: string | null;
+    data: NoInfer<AuthMethodsResponse>;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthMethodsResponse>, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<NoInfer<AuthMethodsResponse>>;
+} | {
+    /** Every linked auth method. Empty while loading. */
+    methods: readonly AuthMethodEntry[];
+    /** The registered passkeys (a `type === 'webauthn'` subset of `methods`). */
+    passkeys: AuthMethodEntry[];
+    /** The account's DID, or `null` while loading. */
+    did: string | null;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthMethodsResponse>, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<NoInfer<AuthMethodsResponse>>;
+} | {
+    /** Every linked auth method. Empty while loading. */
+    methods: readonly AuthMethodEntry[];
+    /** The registered passkeys (a `type === 'webauthn'` subset of `methods`). */
+    passkeys: AuthMethodEntry[];
+    /** The account's DID, or `null` while loading. */
+    did: string | null;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthMethodsResponse>, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<NoInfer<AuthMethodsResponse>>;
+} | {
+    /** Every linked auth method. Empty while loading. */
+    methods: readonly AuthMethodEntry[];
+    /** The registered passkeys (a `type === 'webauthn'` subset of `methods`). */
+    passkeys: AuthMethodEntry[];
+    /** The account's DID, or `null` while loading. */
+    did: string | null;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthMethodsResponse>, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<NoInfer<AuthMethodsResponse>>;
+} | {
+    /** Every linked auth method. Empty while loading. */
+    methods: readonly AuthMethodEntry[];
+    /** The registered passkeys (a `type === 'webauthn'` subset of `methods`). */
+    passkeys: AuthMethodEntry[];
+    /** The account's DID, or `null` while loading. */
+    did: string | null;
+    data: NoInfer<AuthMethodsResponse>;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<NoInfer<AuthMethodsResponse>, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<NoInfer<AuthMethodsResponse>>;
+};
+//# sourceMappingURL=useAuthMethods.d.ts.map

package/lib/typescript/commonjs/ui/hooks/queries/useAuthMethods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAuthMethods.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/useAuthMethods.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAO7E;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE;IAmB1D,qDAAqD;;IAErD,6EAA6E;;IAE7E,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJlD,qDAAqD;;IAErD,6EAA6E;;IAE7E,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJlD,qDAAqD;;IAErD,6EAA6E;;IAE7E,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJlD,qDAAqD;;IAErD,6EAA6E;;IAE7E,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJlD,qDAAqD;;IAErD,6EAA6E;;IAE7E,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAJlD,qDAAqD;;IAErD,6EAA6E;;IAE7E,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGrD,CAAC"}

package/lib/typescript/commonjs/ui/hooks/queries/useFileQueries.d.ts

@@ -0,0 +1,50 @@
+/**
+ * User file-library queries + cache helpers.
+ *
+ * The file list is owned by React Query (`useInfiniteQuery`), NOT a zustand
+ * store: server pages live in the query cache, and every optimistic mutation
+ * (upload / delete / visibility) edits that cache via the pure `*InCache`
+ * helpers below. The `queryFn` is side-effect-free — it only fetches and maps a
+ * page. This is what lets the file manager stay effect-free while preserving
+ * infinite scroll, pull-to-refresh, and optimistic upload reconciliation.
+ */
+import { type InfiniteData, type QueryClient } from '@tanstack/react-query';
+import type { FileMetadata } from '@oxyhq/core';
+/** Files fetched per page. */
+export declare const FILES_PAGE_SIZE = 40;
+/** Raw file record as returned by `oxyServices.listUserFiles` / `assetUpload`. */
+export interface RawUserFile {
+    id: string;
+    originalName?: string;
+    sha256?: string;
+    mime?: string;
+    size?: number;
+    createdAt?: string;
+    metadata?: Record<string, unknown>;
+    variants?: unknown[];
+}
+/** One page of the infinite file list. */
+export interface UserFilesPage {
+    files: FileMetadata[];
+    total: number;
+    hasMore: boolean;
+    nextOffset: number;
+}
+export type UserFilesInfinite = InfiniteData<UserFilesPage>;
+/** Normalize a raw API file record into the client `FileMetadata` shape. */
+export declare function mapRawFileToMetadata(raw: RawUserFile): FileMetadata;
+/**
+ * Infinite-paginated list of the owner's files. Fires on mount and whenever
+ * `ownerId` changes (a new key); `staleTime: 0` reloads on every open. The
+ * rendered list is `data.pages.flatMap(p => p.files)`.
+ */
+export declare const useUserFilesInfinite: (ownerId?: string) => import("@tanstack/react-query").UseInfiniteQueryResult<InfiniteData<UserFilesPage, unknown>, Error>;
+/** Prepend an (optimistic) file to the first page. */
+export declare function prependFileToCache(queryClient: QueryClient, ownerId: string | undefined, file: FileMetadata): void;
+/** Remove a file (by id) from every page. */
+export declare function removeFileFromCache(queryClient: QueryClient, ownerId: string | undefined, fileId: string): void;
+/** Swap an optimistic file (by id) for its persisted counterpart. */
+export declare function replaceFileInCache(queryClient: QueryClient, ownerId: string | undefined, oldId: string, newFile: FileMetadata): void;
+/** Shallow-merge a metadata patch into a cached file (e.g. visibility change). */
+export declare function patchFileMetadataInCache(queryClient: QueryClient, ownerId: string | undefined, fileId: string, metadataPatch: Record<string, unknown>): void;
+//# sourceMappingURL=useFileQueries.d.ts.map

package/lib/typescript/commonjs/ui/hooks/queries/useFileQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFileQueries.d.ts","sourceRoot":"","sources":["../../../../../../src/ui/hooks/queries/useFileQueries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAEH,KAAK,YAAY,EACjB,KAAK,WAAW,EACnB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD,8BAA8B;AAC9B,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,kFAAkF;AAClF,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACxB;AAED,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC1B,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,MAAM,iBAAiB,GAAG,YAAY,CAAC,aAAa,CAAC,CAAC;AAE5D,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,WAAW,GAAG,YAAY,CAWnE;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,wGAsBpD,CAAC;AAiBF,sDAAsD;AACtD,wBAAgB,kBAAkB,CAC9B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,IAAI,EAAE,YAAY,GACnB,IAAI,CAUN;AAED,6CAA6C;AAC7C,wBAAgB,mBAAmB,CAC/B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,MAAM,EAAE,MAAM,GACf,IAAI,CAIN;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAC9B,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,YAAY,GACtB,IAAI,CAIN;AAED,kFAAkF;AAClF,wBAAgB,wBAAwB,CACpC,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACvC,IAAI,CAYN"}