@oxy.so/core 1.0.0

package/dist/types/mixins/OxyServices.user.d.ts

@@ -0,0 +1,558 @@
+/**
+ * User Management Methods Mixin
+ */
+import type { User, Notification, NotificationPreferences, UserPreferences, SearchProfilesResponse, PrivacySettings } from '../models/interfaces';
+import type { UserNameResponse, UserProfileUpdate, RecommendationRequest, RecommendationItem, ThemePreference } from '@oxy.so/contracts';
+import type { OxyServicesBase } from '../OxyServices.base';
+import { type PaginationParams, type FollowGraphParams } from '../utils/apiUtils';
+/**
+ * Response of the single follow/unfollow toggle route
+ * (`POST /users/:id/follow` and `DELETE /users/:id/follow`). The route reports a
+ * status message, which side of the toggle was applied, and the post-write
+ * follower/following counts for the affected users.
+ */
+export interface FollowMutationResult {
+    /** Human-readable status message. */
+    message: string;
+    /** Which side of the toggle was applied, when reported by the route. */
+    action?: 'follow' | 'unfollow';
+    /** Post-write counts, when reported by the route. */
+    counts?: {
+        /** The target user's follower count after the write. */
+        followers: number;
+        /** The viewer's following count after the write. */
+        following: number;
+    };
+}
+/** Per-user outcome returned by `POST /users/follow/bulk`. */
+export interface BulkFollowEntry {
+    /** The user ID that was processed. */
+    userId: string;
+    /** Whether the follow was applied (or already in place) without error. */
+    success: boolean;
+    /** Whether the caller was already following this user before the request. */
+    alreadyFollowing: boolean;
+}
+/** Response shape of `POST /users/follow/bulk`. */
+export interface BulkFollowResult {
+    /** Per-user outcomes, in request order. */
+    results: BulkFollowEntry[];
+    /** Number of users newly followed by this request. */
+    followedCount: number;
+}
+/**
+ * The authenticated viewer's OWN social graph, ids-only — the response of
+ * `GET /users/me/graph`. Consolidates the accounts the viewer follows, the
+ * subset who follow back (mutuals), and the accounts the viewer has blocked
+ * into one payload so a consumer can fetch its whole viewer graph in a single
+ * round trip instead of three. Each list is server-bounded; bare ids only (no
+ * hydrated DTOs) because the consumer hydrates/ranks itself.
+ */
+export interface ViewerGraph {
+    /** Accounts the viewer follows (most-recent first, bounded). */
+    followingIds: string[];
+    /** Accounts the viewer follows that ALSO follow the viewer back (bounded). */
+    mutualIds: string[];
+    /** Accounts the viewer has blocked (bounded). */
+    blockedIds: string[];
+    /** Accounts the viewer has restricted (bounded). */
+    restrictedIds: string[];
+}
+/** Per-user outcome returned by `POST /users/unfollow/bulk`. */
+export interface BulkUnfollowEntry {
+    /** The user ID that was processed. */
+    userId: string;
+    /** Whether the unfollow was applied (or already absent) without error. */
+    success: boolean;
+    /** Whether the caller was following this user before the request. */
+    wasFollowing: boolean;
+}
+/** Response shape of `POST /users/unfollow/bulk`. */
+export interface BulkUnfollowResult {
+    /** Per-user outcomes, in request order. */
+    results: BulkUnfollowEntry[];
+    /** Number of users newly unfollowed by this request. */
+    unfollowedCount: number;
+}
+export declare function OxyServicesUserMixin<T extends typeof OxyServicesBase>(Base: T): {
+    new (...args: any[]): {
+        /**
+         * Service-token request, implemented by the auth mixin earlier in the
+         * composition pipeline (see `mixins/index.ts`). The user mixin is typed
+         * against `OxyServicesBase`, which does not carry the auth mixin's methods,
+         * so this `declare` surfaces the inherited runtime method to TypeScript
+         * without re-implementing it. Used by `getUsersByIds` to authenticate the
+         * server-to-server `/users/by-ids` bulk fetch with a bearer service token.
+         */
+        makeServiceRequest: <R = unknown>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: unknown, userId?: string) => Promise<R>;
+        /**
+         * Raw service credentials stored by `configureServiceAuth()` on the auth
+         * mixin (earlier in the pipeline). Surfaced here via `declare` — for the
+         * same typing reason as `makeServiceRequest` above — so `getUsersByIds` can
+         * detect whether this instance is service-configured (a backend) and pick
+         * the bearer-service path, or fall back to the user-session path (a browser/
+         * RN client). Both are `null` until `configureServiceAuth(apiKey, apiSecret)`
+         * is called.
+         */
+        _serviceApiKey: string | null;
+        _serviceApiSecret: string | null;
+        /**
+         * Get profile by username.
+         *
+         * @param username - The profile's username.
+         * @param options.cache - Defaults to `true` (5-minute TTL), matching prior
+         *   behavior. Pass `{ cache: false }` to force a registry-fresh read: the
+         *   request bypasses BOTH the cache lookup and the post-fetch cache write
+         *   (see {@link HttpService.request}'s `cache` handling), so it neither
+         *   serves nor overwrites any entry already cached for this key — a
+         *   previously cached response (if one exists) is left in place until its
+         *   own TTL expires or is explicitly invalidated elsewhere. Use this when a
+         *   caller must observe a just-written change (e.g. a privacy/consent flag)
+         *   that would otherwise be masked by the TTL window.
+         */
+        getProfileByUsername(username: string, options?: {
+            cache?: boolean;
+        }): Promise<User>;
+        /**
+         * Lightweight username lookup for login flows.
+         * Returns minimal public info: exists, color, avatar, name.displayName.
+         * Faster than getProfileByUsername — no stats, no formatting.
+         */
+        lookupUsername(username: string): Promise<{
+            exists: boolean;
+            username: string;
+            color: string | null;
+            avatar: string | null;
+            name: UserNameResponse;
+        }>;
+        /**
+         * Search user profiles
+         */
+        searchProfiles(query: string, pagination?: PaginationParams): Promise<SearchProfilesResponse>;
+        /**
+         * Resolve a fediverse handle to an Oxy user profile.
+         * Performs WebFinger discovery and returns the user, or null if not found.
+         * @param handle - Fediverse handle (e.g. "@user@mastodon.social" or "user@domain")
+         */
+        resolveProfile(handle: string): Promise<User | null>;
+        /**
+         * Resolve (find or create) a non-local user. All user creation for
+         * external accounts (federated, agent, automated) goes through this
+         * method — calling services never write user data directly.
+         */
+        resolveExternalUser(data: {
+            type: "federated" | "agent" | "automated";
+            username: string;
+            actorUri?: string;
+            domain?: string;
+            displayName?: string;
+            avatar?: string;
+            bio?: string;
+            ownerId?: string;
+        }): Promise<User>;
+        /**
+         * Get profile recommendations.
+         *
+         * Public discovery read — works WITHOUT authentication. The SDK attaches the
+         * access token automatically when one is available (personalized via
+         * mutual-connection overlap), and falls back to popular public profiles when
+         * the caller is logged out. This deliberately does NOT use `withAuthRetry`,
+         * which would throw an authentication timeout for logged-out callers before
+         * the request is ever sent.
+         *
+         * Routing (two server endpoints, both validated against the same
+         * `@oxy.so/contracts` recommendation schemas so the wire shape cannot drift):
+         *
+         *  - **GET `/profiles/recommendations`** (cached) is used for the simple,
+         *    back-compatible case: no options at all, or only `excludeTypes` and/or
+         *    `limit`. `excludeTypes` is sent as a comma-joined query param and
+         *    `limit` as a numeric query param — byte-for-byte identical to the legacy
+         *    behavior so every existing caller keeps the same request and cache key.
+         *  - **POST `/profiles/recommendations`** is used whenever any of the scored
+         *    (v2) fields — `boosts`, `excludeIds`, `signalWeights`, `clientId`, or
+         *    `offset` — is present. The full options object is validated with
+         *    `recommendationRequestSchema` and sent as the request body. The POST is
+         *    cached by the HttpService keyed on the serialized body, so repeated
+         *    identical scored requests are deduplicated/cached just like the GET path.
+         *
+         * @param options - {@link RecommendationRequest} from `@oxy.so/contracts`.
+         *   Omitted entirely (or `{ excludeTypes }`) preserves the legacy GET path.
+         */
+        getProfileRecommendations(options?: RecommendationRequest): Promise<RecommendationItem[]>;
+        /**
+         * Get profiles similar to a given user, based on co-follower overlap.
+         */
+        getSimilarProfiles(userId: string, limitOrParams?: number | {
+            limit?: number;
+            offset?: number;
+        }): Promise<User[]>;
+        /**
+         * Get user by ID.
+         *
+         * @param userId - The target user's id.
+         * @param options.cache - Defaults to `true` (5-minute TTL), matching prior
+         *   behavior. Pass `{ cache: false }` to force a registry-fresh read: the
+         *   request bypasses BOTH the cache lookup and the post-fetch cache write
+         *   (see {@link HttpService.request}'s `cache` handling), so it neither
+         *   serves nor overwrites any entry already cached for this key — a
+         *   previously cached response (if one exists) is left in place until its
+         *   own TTL expires or is explicitly invalidated elsewhere. Use this when a
+         *   caller must observe a just-written change (e.g. a privacy/consent flag)
+         *   that would otherwise be masked by the TTL window.
+         */
+        getUserById(userId: string, options?: {
+            cache?: boolean;
+        }): Promise<User>;
+        /**
+         * Fetch many users by id in one round-trip per chunk.
+         *
+         * Built for feed/hydration call sites that would otherwise issue one
+         * `getUserById` request per unique author (the classic M+1). Ids are
+         * deduplicated and validated (empty/blank ids dropped) before being split
+         * into chunks of {@link USERS_BY_IDS_CHUNK_SIZE} and POSTed to
+         * `/users/by-ids` as `{ ids }`. The server returns the matched users as a
+         * flat `User[]` (order is not guaranteed and the caller is expected to map
+         * by `id`); each is run through `normalizeUserIdentity`, matching
+         * `getUserById`.
+         *
+         * **Dual-mode auth.** `/users/by-ids` is `optionalUserOrServiceAuth` on
+         * oxy-api: it accepts a service token, a user session, or an anonymous
+         * caller, and returns the SAME public `{ data: PublicUserProfile[] }`
+         * payload (canonical `name.displayName` + `_count`) in every case — no
+         * viewer-specific fields. This method picks the path automatically:
+         * - **Service-configured host (backend):** when `configureServiceAuth(apiKey,
+         *   apiSecret)` has been called, the chunk is fetched via `makeServiceRequest`
+         *   (attaches `Authorization: Bearer <serviceToken>`). This is the
+         *   server-to-server feed/notification hydration path (e.g. Mention's
+         *   `PostHydrationService`) and is unchanged.
+         * - **Plain client (browser / React Native with a user session):** when no
+         *   service credentials are configured, the chunk is fetched via
+         *   `makeRequest`, which attaches the configured user bearer. oxy-api's CSRF
+         *   middleware skips bearer-authenticated writes, and `makeRequest` only
+         *   fetches a CSRF token for cookie-only (no-bearer) state-changing requests,
+         *   so the user-bearer POST is sent without CSRF and succeeds. Previously
+         *   this method always used the service path, so every client-side caller
+         *   silently received `[]` because `getServiceToken()` had no credentials.
+         *
+         * Both paths run results through `normalizeUserIdentity` and unwrap the
+         * API's `{ data }` envelope identically (`makeServiceRequest` is literally
+         * `makeRequest` plus a bearer service header).
+         *
+         * Resilience: chunks are independent. A failed chunk is logged and skipped
+         * — the method returns every user that resolved successfully rather than
+         * discarding the whole call on one chunk's failure. An empty/whitespace-only
+         * input resolves immediately with `[]` and performs no network call.
+         *
+         * Not cached at the SDK layer: the response is keyed on a multi-id POST body
+         * (low hit rate) and the backend maintains its own per-id Redis cache.
+         */
+        getUsersByIds(ids: string[]): Promise<User[]>;
+        /**
+         * Get current user
+         */
+        getCurrentUser(): Promise<User>;
+        /**
+         * Update user profile.
+         *
+         * Invalidates the SDK-side response cache for every endpoint that can
+         * return this user — the list is owned by {@link evictOxyIdentityCache}, so
+         * a new identity read is added in one place instead of to each writer
+         * separately (this method's own hand-written copy had already drifted from
+         * the server-side one, missing `GET /auth/lookup/*` and
+         * `GET /profiles/resolve`). The account forest (`GET /accounts` and the
+         * caller's own detail row) is swept too — a personal account IS this user,
+         * and `AccountNode.account` embeds the whole profile — from the list that
+         * {@link evictOxyAccountForestCache} owns, for the same reason: the accounts
+         * mixin writes those keys as well, and two hand-written copies drift.
+         *
+         * TanStack Query handles offline queuing automatically.
+         */
+        updateProfile(updates: UserProfileUpdate): Promise<User>;
+        /**
+         * Get privacy settings for a user
+         * @param userId - The user ID (defaults to current user)
+         */
+        getPrivacySettings(userId?: string): Promise<PrivacySettings>;
+        /**
+         * Update privacy settings.
+         *
+         * Invalidates the cached `GET /privacy/<id>/privacy` response (the exact
+         * key `getPrivacySettings` reads, scoped to the same `id`) after the write.
+         * `getPrivacySettings` caches for ~2 minutes (identity-scoped); without
+         * busting that entry, a follow-up read within the TTL window returns the
+         * pre-update settings. `clearCacheEntry` deletes every identity-scoped
+         * variant of the key.
+         * @param settings - Partial privacy settings object
+         * @param userId - The user ID (defaults to current user)
+         */
+        updatePrivacySettings(settings: Partial<PrivacySettings>, userId?: string): Promise<PrivacySettings>;
+        /**
+         * Update the authenticated user's notification preferences.
+         *
+         * Thin wrapper over `updateProfile` that constrains the patch to known
+         * notification channels — same persistence path, same cache invalidation,
+         * but type-safe at the call site.
+         */
+        updateNotificationPreferences(preferences: Partial<NotificationPreferences>): Promise<User>;
+        /**
+         * Update the authenticated user's general preferences (language, theme,
+         * reduce-motion, timezone). Persisted on the User document via
+         * `PUT /users/me` — same cache-invalidation behaviour as `updateProfile`.
+         */
+        updateUserPreferences(preferences: Partial<UserPreferences>): Promise<User>;
+        /**
+         * Update the authenticated user's portable theme preference (light/dark/
+         * system + Bloom color-preset key). Persisted on the User document via the
+         * SAME `PUT /users/me` settings path as the other preferences — same cache
+         * invalidation — so the next cold boot serves it on the self/session payload
+         * with no extra network call. The full object is written (both `mode` and
+         * `colorPreset` are required by the API).
+         */
+        updateThemePreference(themePreference: ThemePreference): Promise<User>;
+        /**
+         * Request account verification
+         */
+        requestAccountVerification(reason: string, evidence?: string): Promise<{
+            message: string;
+            requestId: string;
+        }>;
+        /**
+         * Download account data export
+         */
+        downloadAccountData(format?: "json" | "csv"): Promise<Blob>;
+        /**
+         * Delete account permanently.
+         *
+         * Signs `delete:{publicKey}:{timestamp}` with the locally-stored identity
+         * private key and submits the signature alongside the confirmation text
+         * (must equal the user's username). The signature is the cryptographic
+         * proof of ownership — only the device holding the private key can issue
+         * a valid signature, so no password is required.
+         *
+         * @param confirmText - Must equal the user's username (verified server-side)
+         * @throws If no identity is stored on this device, or signing fails
+         */
+        deleteAccount(confirmText: string): Promise<{
+            message: string;
+        }>;
+        /**
+         * Invalidate every cached read a follow/unfollow write invalidates.
+         *
+         * Shared by the four mutation entry points (`followUser`, `unfollowUser`,
+         * `followUsers`, `unfollowUsers`) so they can never drift on which caches a
+         * write busts.
+         *
+         * The follower/following/mutuals LISTS are cleared by PREFIX rather than by
+         * exact key. Those reads are paginated and ordered, so one logical list is
+         * spread across many content-addressed keys
+         * (`GET:/users/<id>/followers:{"limit":"20","offset":"40","sort":"oldest"}`);
+         * an exact-key clear would only bust whichever page/sort variant happened to
+         * be read last and would leave every other page stale. `clearCacheByPrefix`
+         * deletes all of them, and all identity-scoped variants of each.
+         */
+        invalidateFollowGraphCaches(targetUserIds: string[]): void;
+        /**
+         * Follow a user.
+         *
+         * Invalidates the cached `GET /users/<id>/follow-status` response after
+         * the write. `getFollowStatus` caches for ~1 minute (identity-scoped);
+         * without busting that entry, a `FollowButton` that remounts within the
+         * TTL window re-reads the STALE pre-write status and reverts the optimistic
+         * UI (the "follow resets after navigating away and back" bug).
+         * `clearCacheEntry` deletes every identity-scoped variant of the key.
+         */
+        followUser(userId: string): Promise<FollowMutationResult>;
+        /**
+         * Follow multiple users in a single request.
+         *
+         * POSTs `/users/follow/bulk` with `{ userIds }` (server caps the batch at
+         * 200). Returns the per-user outcomes and the count of users newly
+         * followed. An empty `userIds` array resolves immediately with an empty
+         * result and performs no network call.
+         */
+        followUsers(userIds: string[]): Promise<BulkFollowResult>;
+        /**
+         * Unfollow multiple users in a single request.
+         *
+         * POSTs `/users/unfollow/bulk` with `{ userIds }` (server caps the batch at
+         * 200). Returns the per-user outcomes and the count of users newly
+         * unfollowed. An empty `userIds` array resolves immediately with an empty
+         * result and performs no network call.
+         */
+        unfollowUsers(userIds: string[]): Promise<BulkUnfollowResult>;
+        /**
+         * Unfollow a user
+         */
+        unfollowUser(userId: string): Promise<FollowMutationResult>;
+        /**
+         * Get follow status
+         */
+        getFollowStatus(userId: string): Promise<{
+            isFollowing: boolean;
+        }>;
+        /**
+         * Resolve the viewer's follow status for MANY users in one round-trip per
+         * chunk. Built for list UIs (a page of `FollowButton`s) that would otherwise
+         * fire one `getFollowStatus` per button (the classic N+1).
+         *
+         * Ids are deduplicated and validated (empty/blank ids dropped), split into
+         * chunks of {@link FOLLOW_STATUS_CHUNK_SIZE} (the server's bulk cap), and
+         * POSTed to `/users/follow-status/bulk` as `{ userIds }`. The per-chunk
+         * `{ statuses }` maps are merged into one `Record<string, boolean>` covering
+         * every requested id — ids the viewer does not follow come back `false`.
+         *
+         * Uncached (`{ cache: false }`): the UI store owns follow-status freshness
+         * and writes optimistically on every mutation, so an SDK cache here would
+         * serve a stale status right after a follow/unfollow. An empty/whitespace-
+         * only input resolves immediately with `{}` and performs no network call.
+         */
+        getFollowStatuses(userIds: string[]): Promise<Record<string, boolean>>;
+        /**
+         * Get user followers.
+         *
+         * `sort` orders the underlying follow edges — `recent` (newest first, the
+         * server default) or `oldest`. Because the response is cached and the cache
+         * key is content-addressed on the query params, each `limit`/`offset`/`sort`
+         * combination is its own entry.
+         */
+        getUserFollowers(userId: string, pagination?: FollowGraphParams): Promise<{
+            followers: User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        /**
+         * Get user following. `sort` behaves as in {@link getUserFollowers}.
+         */
+        getUserFollowing(userId: string, pagination?: FollowGraphParams): Promise<{
+            following: User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        /**
+         * Get user mutuals ("followers you know" — users the authenticated viewer
+         * follows who also follow `userId`). The viewer is derived server-side from auth.
+         */
+        getUserMutuals(userId: string, pagination?: FollowGraphParams): Promise<{
+            mutuals: User[];
+            total: number;
+            hasMore: boolean;
+        }>;
+        /**
+         * Get the authenticated VIEWER's OWN mutual-follow user ids — the accounts the
+         * viewer follows that ALSO follow the viewer back (a bidirectional follow
+         * edge). The viewer is derived server-side from the SDK's auth token (never a
+         * param), so there is no target id to pass.
+         *
+         * Returns a bounded, lean list of ids meant to SEED a "Mutuals" feed (the
+         * consumer hydrates/ranks the posts itself) — distinct from
+         * {@link getUserMutuals}, which returns hydrated "followers you know" DTOs
+         * about ANOTHER profile. An anonymous caller resolves to an empty array.
+         */
+        getMutualUserIds(params?: {
+            limit?: number;
+        }): Promise<string[]>;
+        /**
+         * Get the authenticated VIEWER's bounded "follows-of-follows" user ids — the
+         * union of the accounts followed by the accounts the viewer follows (a
+         * two-hop walk of the follow graph), MINUS the viewer's own follows and the
+         * viewer themselves. The viewer is derived server-side from the SDK's auth
+         * token (never a param), so there is no target id to pass.
+         *
+         * Returns a bounded, lean list of ids meant to SEED a friends-of-friends
+         * feed (the consumer hydrates/ranks the posts itself), ordered by frequency
+         * (accounts followed by more of the viewer's follows first), then recency.
+         * An anonymous caller resolves to an empty array. Mirrors
+         * {@link getMutualUserIds}'s caching posture.
+         */
+        getFollowsOfFollowsIds(params?: {
+            limit?: number;
+        }): Promise<string[]>;
+        /**
+         * Get the authenticated VIEWER's OWN social graph — the accounts they follow,
+         * the subset who follow back (mutuals), and the accounts they have blocked —
+         * as ONE ids-only payload. The viewer is derived server-side from the SDK's
+         * auth token (never a param).
+         *
+         * Consolidates what were three separate round trips (`getUserFollowing` /
+         * `getMutualUserIds` / `getBlockedUsers`) into a single request so a consumer
+         * can prime its whole viewer graph at once. Mirrors {@link getMutualUserIds}'s
+         * caching posture (2-minute identity-scoped cache); the follow/unfollow/block/
+         * unblock write methods bust this entry so a local mutation is reflected
+         * immediately. An anonymous caller resolves to empty lists.
+         */
+        getViewerGraph(): Promise<ViewerGraph>;
+        /**
+         * Get notifications
+         */
+        getNotifications(): Promise<Notification[]>;
+        /**
+         * Get unread notification count
+         */
+        getUnreadCount(): Promise<number>;
+        /**
+         * Create notification
+         */
+        createNotification(data: Partial<Notification>): Promise<Notification>;
+        /**
+         * Mark notification as read
+         */
+        markNotificationAsRead(notificationId: string): Promise<void>;
+        /**
+         * Mark all notifications as read
+         */
+        markAllNotificationsAsRead(): Promise<void>;
+        /**
+         * Delete notification
+         */
+        deleteNotification(notificationId: string): Promise<void>;
+        httpService: import("../HttpService").HttpService;
+        cloudURL: string;
+        config: import("../OxyServices.base").OxyConfig;
+        __resetTokensForTests(): void;
+        makeRequest<T_1>(method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE", url: string, data?: any, options?: import("../HttpService").RequestOptions): Promise<T_1>;
+        getBaseURL(): string;
+        getClient(): import("../HttpService").HttpService;
+        createLinkedClient(config: import("../OxyServices.base").OxyConfig): import("..").LinkedHttpClient;
+        getMetrics(): {
+            totalRequests: number;
+            successfulRequests: number;
+            failedRequests: number;
+            cacheHits: number;
+            cacheMisses: number;
+            averageResponseTime: number;
+        };
+        clearCache(): void;
+        clearCacheEntry(key: string): void;
+        clearCacheByPrefix(prefix: string): number;
+        getCacheStats(): {
+            size: number;
+            hits: number;
+            misses: number;
+            hitRate: number;
+        };
+        getCloudURL(): string;
+        setTokens(accessToken: string): void;
+        clearTokens(): void;
+        onTokensChanged(listener: (accessToken: string | null) => void): () => void;
+        _cachedUserId: string | null | undefined;
+        _cachedAccessToken: string | null;
+        getCurrentUserId(): string | null;
+        hasValidToken(): boolean;
+        getAccessToken(): string | null;
+        getAccessTokenExpiry(): number | null;
+        waitForAuth(timeoutMs?: number): Promise<boolean>;
+        withAuthRetry<T_1>(operation: () => Promise<T_1>, operationName: string, options?: {
+            maxRetries?: number;
+            retryDelay?: number;
+            authTimeoutMs?: number;
+        }): Promise<T_1>;
+        validate(): Promise<boolean>;
+        handleError(error: unknown): Error;
+        healthCheck(): Promise<{
+            status: string;
+            users?: number;
+            timestamp?: string;
+            [key: string]: any;
+        }>;
+    };
+} & T;