@singi-labs/sifa-sdk 0.9.19 → 0.9.20

package/dist/keys-D-vNPzXx.d.ts

@@ -0,0 +1,1085 @@
+import { E as ExternalAccount, S as SkillSuggestion } from './index-DYUYJxOs.js';
+import { F as FollowFeedPage, a as FollowProfileItem, b as FeatureAllowlistEntry, c as FeatureFlag } from './feed-DHTy7fUN.js';
+
+/**
+ * Foundation HTTP client for talking to the Sifa AppView.
+ *
+ * Stateless. Consumers supply a {@link SifaApiConfig} per call (the React
+ * hooks read it from context; non-React consumers pass it explicitly). No
+ * singletons, no module-level state.
+ */
+/** Configuration passed to every fetcher. */
+interface SifaApiConfig {
+    /** Base URL of the sifa-api AppView, e.g. `https://api.sifa.id`. No trailing slash. */
+    baseUrl: string;
+    /**
+     * Optional fetch implementation. Defaults to {@link globalThis.fetch}.
+     * Lets Next.js consumers pass their cache-enhanced fetch; node/Expo
+     * consumers can leave this unset.
+     */
+    fetch?: typeof fetch;
+}
+/** Options accepted by {@link apiFetch}. */
+interface ApiFetchOptions {
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** Request body. Serialized to JSON automatically. */
+    body?: unknown;
+    /** AbortSignal. Defaults to `AbortSignal.timeout(timeoutMs)` if `timeoutMs` is set. */
+    signal?: AbortSignal;
+    /** Per-call timeout in milliseconds. Default: 10_000. Ignored if `signal` is provided. */
+    timeoutMs?: number;
+    /** Retry on HTTP 429 up to 3 times with the server's `Retry-After` delay (capped at 3s). */
+    retryOn429?: boolean;
+    /** Additional headers. `Content-Type: application/json` is set automatically when `body` is present. */
+    headers?: Record<string, string>;
+    credentials?: RequestCredentials;
+    cache?: RequestCache;
+    /**
+     * Next.js-specific cache hints. Ignored on non-Next runtimes. Passed
+     * through transparently as part of {@link RequestInit}.
+     */
+    next?: {
+        revalidate?: number | false;
+        tags?: string[];
+    };
+}
+/** Error thrown by {@link apiFetch} on non-2xx responses. */
+declare class ApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body?: unknown);
+}
+/**
+ * Generic fetcher used by all SDK query and mutation functions.
+ *
+ * Returns parsed JSON typed as `T`. Throws {@link ApiError} on non-2xx
+ * responses. Use {@link apiFetchOrNull} when 404 should resolve to `null`
+ * instead.
+ */
+declare function apiFetch<T = unknown>(config: SifaApiConfig, path: string, options?: ApiFetchOptions): Promise<T>;
+/**
+ * Variant of {@link apiFetch} that resolves to `null` on HTTP 404 instead
+ * of throwing. Useful for "fetch by handle" reads where missing is
+ * expected (e.g. unknown profile).
+ */
+declare function apiFetchOrNull<T>(config: SifaApiConfig, path: string, options?: ApiFetchOptions): Promise<T | null>;
+/**
+ * Result returned by record-write mutations (create / update / delete).
+ *
+ * Never throws -- writes against the user's PDS can fail in many ways
+ * (network, PDS unreachable, rate limit) and the UI needs structured
+ * results to render appropriate messages.
+ */
+interface WriteResult {
+    success: boolean;
+    error?: string;
+    /**
+     * PDS hostname returned by sifa-api when a write failed at the user's
+     * Personal Data Server (issue #167). Lets the UI render
+     * "Your data server (eurosky.social) isn't responding" instead of a
+     * generic "Request failed (500)".
+     */
+    pdsHost?: string;
+}
+/** Result returned by create mutations. Includes the newly created `rkey`. */
+interface CreateResult extends WriteResult {
+    rkey?: string;
+}
+/**
+ * Write mutation against the Sifa AppView. Wraps {@link apiFetch} with the
+ * never-throws contract used by all sifa-web mutations: returns a
+ * structured {@link WriteResult} on both success and failure, and
+ * preserves the `pdsHost` field when the AppView reports a PDS-side
+ * failure (issue #167).
+ *
+ * On success: returns `{ success: true, ...payload }` where `payload` is
+ * whatever the server returned in JSON (or `{}` for 204).
+ *
+ * On failure: returns `{ success: false, error, pdsHost? }`. Never throws.
+ *
+ * Use {@link apiWriteCreate} when you specifically need the `rkey` from a
+ * create response folded into the result shape.
+ */
+declare function apiWrite<TExtra extends object = Record<never, never>>(config: SifaApiConfig, path: string, method: 'POST' | 'PUT' | 'DELETE' | 'PATCH', options?: Omit<ApiFetchOptions, 'method'>): Promise<WriteResult & TExtra>;
+/**
+ * Write mutation that expects the server to return a record key (`rkey`)
+ * in its response body. Wraps {@link apiWrite} and folds the `rkey` into
+ * the result shape so consumers get `{ success, rkey?, error?, pdsHost? }`.
+ *
+ * If the server returns additional fields (e.g. `feedUrl` from external
+ * account creation), pass them via the `TExtra` generic to keep them
+ * typed.
+ */
+declare function apiWriteCreate<TExtra extends object = Record<never, never>>(config: SifaApiConfig, path: string, body: unknown, options?: Omit<ApiFetchOptions, 'method' | 'body'>): Promise<CreateResult & TExtra>;
+
+/** Industry/domain entry on the profile self record. */
+interface ProfileIndustryInput {
+    industry: string;
+    domain?: string;
+}
+/**
+ * Location payload accepted by `updateProfileSelf`.
+ *
+ * Accepts both shapes during the community.lexicon.location.address
+ * migration. Prefer `locality` (new) over `city` (legacy) when sending.
+ * The API's locationSchema is a Zod union that resolves either input.
+ */
+interface ProfileSelfLocation {
+    country: string;
+    countryCode?: string;
+    region?: string;
+    city?: string;
+    locality?: string;
+}
+/** Body accepted by {@link updateProfileSelf}. */
+interface UpdateProfileSelfInput {
+    headline?: string;
+    about?: string;
+    /** Schema.org Person.givenName from id.sifa.profile.self.givenName. */
+    givenName?: string;
+    /** Schema.org Person.familyName from id.sifa.profile.self.familyName. */
+    familyName?: string;
+    industries?: ProfileIndustryInput[];
+    location?: ProfileSelfLocation;
+    website?: string;
+    openTo?: string[];
+    preferredWorkplace?: string[];
+    availableFromUtc?: number;
+    availableToUtc?: number;
+}
+/** Update the authenticated user's `id.sifa.profile.self` record. */
+declare function updateProfileSelf(config: SifaApiConfig, data: UpdateProfileSelfInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Body accepted by {@link updateProfileOverride}. */
+interface UpdateProfileOverrideInput {
+    headline?: string | null;
+    about?: string | null;
+    displayName?: string | null;
+    pronouns?: string | null;
+}
+/**
+ * Override aggregated profile fields with sifa-specific values. `null`
+ * clears the override and falls back to the upstream PDS value.
+ */
+declare function updateProfileOverride(config: SifaApiConfig, data: UpdateProfileOverrideInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Extended result for {@link refreshPds}. */
+interface RefreshPdsResult extends WriteResult {
+    displayName?: string | null;
+    avatar?: string | null;
+}
+/**
+ * Re-pull the authenticated user's `app.bsky.actor.profile` from their
+ * PDS. Returns the freshly resolved `displayName` and `avatar` on
+ * success so the UI can update without a full profile refetch.
+ */
+declare function refreshPds(config: SifaApiConfig, options?: ApiFetchOptions): Promise<RefreshPdsResult>;
+/** Extended result for {@link uploadAvatar}. */
+interface UploadAvatarResult extends WriteResult {
+    /** Publicly accessible URL of the newly uploaded avatar. */
+    url?: string;
+}
+/**
+ * Upload a new avatar via `multipart/form-data`. Pass either a `File`
+ * (browser) or any `Blob` (Expo, node). The SDK leaves `Content-Type`
+ * unset so the runtime can set the multipart boundary automatically.
+ *
+ * Never throws -- inspect `result.success` and `result.url`.
+ */
+declare function uploadAvatar(config: SifaApiConfig, file: Blob, options?: ApiFetchOptions): Promise<UploadAvatarResult>;
+/** Delete the authenticated user's avatar override (revert to PDS avatar). */
+declare function deleteAvatarOverride(config: SifaApiConfig, options?: ApiFetchOptions): Promise<WriteResult>;
+
+/**
+ * Address payload accepted by `/api/profile/location` endpoints.
+ *
+ * Accepts both shapes during the community.lexicon.location.address
+ * migration. Prefer `country` + `locality` (new) over `countryCode` +
+ * `city` (legacy). The API's `locationSchema` is a Zod union that
+ * accepts either pair.
+ */
+interface ProfileLocationAddress {
+    /** Legacy alias for `country` (alpha-2). */
+    countryCode?: string;
+    /** community.lexicon.location.address field -- prefer over `countryCode`. */
+    country?: string;
+    region?: string;
+    /** Legacy alias for `locality`. */
+    city?: string;
+    /** community.lexicon.location.address field -- prefer over `city`. */
+    locality?: string;
+}
+/** Body accepted by {@link createProfileLocation} / {@link updateProfileLocation}. */
+interface ProfileLocationInput {
+    address: ProfileLocationAddress;
+    type: string;
+    label?: string;
+    isPrimary?: boolean;
+}
+/** Create a new profile location entry. */
+declare function createProfileLocation(config: SifaApiConfig, data: ProfileLocationInput, options?: ApiFetchOptions): Promise<CreateResult>;
+/** Update an existing profile location by `rkey`. */
+declare function updateProfileLocation(config: SifaApiConfig, rkey: string, data: ProfileLocationInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Delete a profile location by `rkey`. */
+declare function deleteProfileLocation(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<WriteResult>;
+
+/** Body accepted by {@link createExternalAccount} / {@link updateExternalAccount}. */
+interface ExternalAccountInput {
+    platform: string;
+    url: string;
+    label?: string;
+    feedUrl?: string;
+}
+/** Extended create result for {@link createExternalAccount}. */
+interface CreateExternalAccountResult extends WriteResult {
+    rkey?: string;
+    feedUrl?: string | null;
+}
+/** Extended write result for {@link verifyExternalAccount}. */
+interface VerifyExternalAccountResult extends WriteResult {
+    verified?: boolean;
+    verifiedVia?: string;
+}
+/** List external accounts attached to a profile. Returns `[]` on error. */
+declare function fetchExternalAccounts(config: SifaApiConfig, handleOrDid: string, options?: ApiFetchOptions): Promise<ExternalAccount[]>;
+/**
+ * Create a new external account record. Returns the newly-created `rkey`
+ * and the server-resolved `feedUrl` (sifa-api inspects the target for
+ * RSS feeds on platforms that publish them).
+ */
+declare function createExternalAccount(config: SifaApiConfig, data: ExternalAccountInput, options?: ApiFetchOptions): Promise<CreateExternalAccountResult>;
+/** Update an existing external account by `rkey`. */
+declare function updateExternalAccount(config: SifaApiConfig, rkey: string, data: ExternalAccountInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Delete an external account by `rkey`. */
+declare function deleteExternalAccount(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Mark an external account as the user's primary. */
+declare function setExternalAccountPrimary(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Clear the "primary" flag on an external account. */
+declare function unsetExternalAccountPrimary(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/**
+ * Run server-side verification on an external account (e.g. inspect
+ * the target for a keytrace claim). Returns `{ verified, verifiedVia }`
+ * on success.
+ */
+declare function verifyExternalAccount(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<VerifyExternalAccountResult>;
+
+/** Body accepted by {@link createEndorsement}. */
+interface EndorsementInput {
+    skillUri: string;
+    comment?: string;
+}
+/**
+ * Create an endorsement of another user's skill. The endorsed user
+ * must confirm before the endorsement appears on their profile (the
+ * endorsement record is on the endorser's PDS; a separate confirmation
+ * record on the endorsed user's PDS gates display).
+ */
+declare function createEndorsement(config: SifaApiConfig, data: EndorsementInput, options?: ApiFetchOptions): Promise<CreateResult>;
+
+/** Extended result for {@link refreshOrcidPublications}. */
+interface RefreshOrcidPublicationsResult extends WriteResult {
+    added?: number;
+    removed?: number;
+}
+/**
+ * Hide an ORCID-imported publication from the user's profile. The
+ * `putCode` is the ORCID-side identifier; the underlying record stays
+ * in the index, only its display is suppressed.
+ */
+declare function hideOrcidPublication(config: SifaApiConfig, putCode: number, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Restore a previously-hidden ORCID publication. */
+declare function unhideOrcidPublication(config: SifaApiConfig, putCode: number, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Hide a standard (auto-imported) publication by its AT URI. */
+declare function hideStandardPublication(config: SifaApiConfig, uri: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Restore a previously-hidden standard publication. */
+declare function unhideStandardPublication(config: SifaApiConfig, uri: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Bulk-hide standard publications by AT URI list. */
+declare function bulkHideStandardPublications(config: SifaApiConfig, uris: string[], options?: ApiFetchOptions): Promise<WriteResult>;
+/** Bulk-unhide standard publications by AT URI list. */
+declare function bulkUnhideStandardPublications(config: SifaApiConfig, uris: string[], options?: ApiFetchOptions): Promise<WriteResult>;
+/** Hide an `id.sifa.profile.publication` (user-authored publication record). */
+declare function hideSifaPublication(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Restore a previously-hidden Sifa publication. */
+declare function unhideSifaPublication(config: SifaApiConfig, rkey: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/**
+ * Re-pull the authenticated user's ORCID publications. Returns counts
+ * of added and removed records. The server returns `{ error: '...' }`
+ * inline (not via HTTP status) on quota / linkage failures; the SDK
+ * folds that into `{ success: false, error }` to keep the contract
+ * consistent with other mutations.
+ */
+declare function refreshOrcidPublications(config: SifaApiConfig, options?: ApiFetchOptions): Promise<RefreshOrcidPublicationsResult>;
+
+/** Item types that can be hidden on the authenticated user's profile. */
+declare const HIDDEN_ITEM_TYPES: readonly ["position", "education", "certification", "project", "volunteering", "publication", "course", "honor", "language", "externalAccount"];
+type HiddenItemType = (typeof HIDDEN_ITEM_TYPES)[number];
+/** Source from which an item originates; disambiguates `item_id`. */
+declare const HIDDEN_ITEM_SOURCES: readonly ["pds", "standard", "orcid"];
+type HiddenItemSource = (typeof HIDDEN_ITEM_SOURCES)[number];
+interface HideProfileItemInput {
+    itemType: HiddenItemType;
+    source: HiddenItemSource;
+    /** rkey for `pds`, AT-URI for `standard`, ORCID putCode as text for `orcid`. */
+    itemId: string;
+}
+interface BulkHideProfileItemInput {
+    itemType: HiddenItemType;
+    source: HiddenItemSource;
+    itemIds: string[];
+}
+/**
+ * Hide one profile item. The underlying record stays on the user's PDS;
+ * only its display on sifa.id is suppressed.
+ */
+declare function hideProfileItem(config: SifaApiConfig, input: HideProfileItemInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Restore a previously-hidden profile item. */
+declare function unhideProfileItem(config: SifaApiConfig, input: HideProfileItemInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Bulk-hide profile items sharing the same `itemType` + `source`. */
+declare function bulkHideProfileItems(config: SifaApiConfig, input: BulkHideProfileItemInput, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Bulk-unhide profile items sharing the same `itemType` + `source`. */
+declare function bulkUnhideProfileItems(config: SifaApiConfig, input: BulkHideProfileItemInput, options?: ApiFetchOptions): Promise<WriteResult>;
+
+/** Public, aggregate stats shown on the homepage and similar surfaces. */
+interface StatsResponse {
+    profileCount: number;
+    avatars: string[];
+    atproto: {
+        userCount: number;
+        growthPerSecond: number;
+        timestamp: number;
+    } | null;
+}
+/**
+ * Homepage stats (profile count, avatar samples, ATproto growth). Public
+ * endpoint -- safe to cache. Returns `null` on any error so callers can
+ * render a graceful empty state.
+ */
+declare function fetchStats(config: SifaApiConfig, options?: ApiFetchOptions): Promise<StatsResponse | null>;
+
+/** Catalog entry describing an ATproto app that Sifa surfaces activity for. */
+interface AppRegistryEntry {
+    id: string;
+    name: string;
+    category: string;
+    collectionPrefixes: string[];
+    scanCollections: string[];
+    urlPattern?: string;
+    color: string;
+}
+/** Compact app representation returned by the hidden-apps endpoint. */
+interface HiddenApp {
+    id: string;
+    name: string;
+    category: string;
+}
+interface FetchHiddenAppsOptions extends ApiFetchOptions {
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls.
+     * `credentials: 'include'` does NOT propagate browser cookies in RSC,
+     * so authenticated server fetches must forward the header explicitly.
+     */
+    cookieHeader?: string;
+}
+/**
+ * Public app registry shown across discovery surfaces. Heavily cached.
+ * Returns `[]` on any error.
+ */
+declare function fetchAppsRegistry(config: SifaApiConfig, options?: ApiFetchOptions): Promise<AppRegistryEntry[]>;
+/**
+ * Apps the authenticated user has chosen to hide from their activity feed.
+ * Requires an authenticated session. Returns `[]` on any error (including
+ * the unauthenticated case).
+ */
+declare function fetchHiddenApps(config: SifaApiConfig, options?: FetchHiddenAppsOptions): Promise<HiddenApp[]>;
+
+/** Profile entry returned by the search endpoint. */
+interface ProfileSearchResult {
+    did?: string;
+    handle: string;
+    displayName?: string;
+    headline?: string;
+    avatar?: string;
+    about?: string;
+    currentRole?: string;
+    currentCompany?: string;
+    industry?: string;
+    domain?: string;
+    countryCode?: string;
+    locationCountry?: string;
+    preferredWorkplace?: string[];
+    claimed?: boolean;
+    blueskyVerified?: boolean;
+    blueskyVerifiedAt?: string | null;
+}
+interface SearchFilters {
+    q?: string;
+    skill?: string;
+    country?: string;
+    industry?: string;
+    domain?: string;
+    workplace?: string;
+    app?: string;
+    limit?: number;
+}
+interface SearchResponse {
+    profiles: ProfileSearchResult[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+/** Skill typeahead suggestion. */
+interface SkillSearchResult {
+    name: string;
+    slug: string;
+    category: string;
+    userCount: number;
+}
+interface FilterOptions {
+    countries: {
+        countryCode: string;
+        country: string;
+        count: number;
+    }[];
+    industries: {
+        industry: string;
+        count: number;
+    }[];
+    apps: {
+        appId: string;
+        count: number;
+    }[];
+}
+/**
+ * Search profiles by free-text query and optional filters. Returns an
+ * empty result set when no filters are provided (matching sifa-web's
+ * "no input, no fetch" behavior).
+ */
+declare function fetchSearchProfiles(config: SifaApiConfig, filters: SearchFilters, options?: ApiFetchOptions): Promise<SearchResponse>;
+/**
+ * Skill typeahead. Returns up to 8 matches for the given prefix. Empty
+ * input returns an empty array without hitting the server.
+ */
+declare function fetchSkillSuggestions(config: SifaApiConfig, query: string, options?: ApiFetchOptions): Promise<SkillSearchResult[]>;
+/** Available filter facets (countries, industries, apps) for search UI. */
+declare function fetchSearchFilters(config: SifaApiConfig, options?: ApiFetchOptions): Promise<FilterOptions>;
+/**
+ * Canonical-skill search backing the position-editor and similar
+ * skill-pickers. Hits `/api/skills/search` (the canonical-skills DB
+ * lookup) which is distinct from {@link fetchSkillSuggestions}'s
+ * `/api/search/skills` (the profile-skill typeahead).
+ *
+ * Returns `[]` on empty input (no network call) or any error.
+ */
+declare function searchSkills(config: SifaApiConfig, query: string, limit?: number, options?: ApiFetchOptions): Promise<SkillSuggestion[]>;
+
+/** Lightweight profile representation used by discovery endpoints. */
+interface SimilarProfile {
+    did: string;
+    handle: string;
+    displayName?: string | null;
+    avatar?: string | null;
+    headline?: string | null;
+    currentRole?: string | null;
+    currentCompany?: string | null;
+    industry?: string | null;
+    domain?: string | null;
+}
+interface SuggestionProfile {
+    did: string;
+    handle: string;
+    displayName?: string;
+    headline?: string;
+    avatarUrl?: string;
+    source: string;
+    dismissed: boolean;
+    blueskyVerified?: boolean;
+}
+interface SuggestionsResponse {
+    onSifa: SuggestionProfile[];
+    notOnSifa: SuggestionProfile[];
+    cursor?: string;
+}
+interface FeaturedProfile {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+    pronouns?: string;
+    headline?: string;
+    about?: string;
+    currentRole?: string;
+    currentCompany?: string;
+    locationCountry?: string;
+    locationRegion?: string;
+    /** Legacy alias for `locationLocality`; emitted by sifa-api during the additive response window. */
+    locationCity?: string;
+    /** community.lexicon.location.address field name -- prefer over `locationCity`. */
+    locationLocality?: string;
+    countryCode?: string;
+    location?: string;
+    website?: string;
+    openTo?: string[];
+    preferredWorkplace?: string[];
+    availableFromUtc?: number;
+    availableToUtc?: number;
+    followersCount?: number;
+    atprotoFollowersCount?: number;
+    pdsProvider?: {
+        name: string;
+        host: string;
+    } | null;
+    claimed: boolean;
+    featuredDate: string;
+}
+/** Profiles similar to the given DID (matchmaking). Returns `[]` on error. */
+declare function fetchSimilarProfiles(config: SifaApiConfig, did: string, opts?: {
+    limit?: number;
+} & ApiFetchOptions): Promise<SimilarProfile[]>;
+interface FetchSuggestionsOptions extends ApiFetchOptions {
+    source?: string;
+    includeDismissed?: boolean;
+    cursor?: string;
+    limit?: number;
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls.
+     * `credentials: 'include'` does NOT propagate browser cookies in RSC,
+     * so authenticated server fetches must forward the header explicitly.
+     */
+    cookieHeader?: string;
+}
+/** Discovery suggestions feed. Resolves to empty arrays on error. */
+declare function fetchSuggestions(config: SifaApiConfig, opts?: FetchSuggestionsOptions): Promise<SuggestionsResponse>;
+/** Count of pending suggestions since an optional timestamp. */
+declare function fetchSuggestionCount(config: SifaApiConfig, since?: string, options?: ApiFetchOptions): Promise<number>;
+/** Featured profile (rotated by sifa-api). Returns `null` when none. */
+declare function fetchFeaturedProfile(config: SifaApiConfig, options?: ApiFetchOptions): Promise<FeaturedProfile | null>;
+
+interface FollowProfile {
+    did: string;
+    handle: string;
+    displayName?: string;
+    headline?: string;
+    avatarUrl?: string;
+    source: string;
+    claimed: boolean;
+    followedAt: string;
+    blueskyVerified?: boolean;
+    blueskyVerifiedAt?: string | null;
+}
+interface FollowingResponse {
+    follows: FollowProfile[];
+    cursor?: string;
+}
+/** People the authenticated user follows. Empty on error. */
+declare function fetchFollowing(config: SifaApiConfig, opts?: {
+    source?: string;
+    cursor?: string;
+    limit?: number;
+} & ApiFetchOptions): Promise<FollowingResponse>;
+/**
+ * Result of {@link followUser}. Extends {@link WriteResult} with the
+ * follow `rkey` returned by sifa-api on success. Self-follow + invalid
+ * handle surface as `success: false` with the server-provided message;
+ * dup-follow is idempotent (sifa-api E7) and resolves as `success: true`.
+ */
+interface FollowUserResult extends WriteResult {
+    rkey?: string;
+    /** DID of the followed subject (server-resolved from the handle). */
+    subjectDid?: string;
+}
+/**
+ * Create an `id.sifa.graph.follow` record on the caller's PDS via the
+ * AppView. Idempotent on duplicate (server catches the unique-violation
+ * and returns 200, per sifa-api#673 E7).
+ */
+declare function followUser(config: SifaApiConfig, handle: string, opts?: {
+    note?: string;
+} & Omit<ApiFetchOptions, 'method' | 'body'>): Promise<FollowUserResult>;
+/** Delete the authenticated viewer's `id.sifa.graph.follow` for `handle`. */
+declare function unfollowUser(config: SifaApiConfig, handle: string, opts?: Omit<ApiFetchOptions, 'method' | 'body'>): Promise<WriteResult>;
+interface FollowListPage {
+    follows: FollowProfile[];
+    cursor: string | null;
+}
+interface FetchFollowListOptions extends ApiFetchOptions {
+    cursor?: string;
+    limit?: number;
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls
+     * (mirrors {@link FetchActivityFeedOptions}; required for authenticated
+     * server fetches because `credentials: 'include'` does not propagate
+     * cookies from RSC).
+     */
+    cookieHeader?: string;
+}
+/**
+ * Paginated list of `handle`'s followers. Returns an empty page on error
+ * so the UI can render a graceful "no followers yet" state.
+ */
+declare function getFollowers(config: SifaApiConfig, handle: string, opts?: FetchFollowListOptions): Promise<FollowListPage>;
+/** Paginated list of who `handle` follows. */
+declare function getFollowing(config: SifaApiConfig, handle: string, opts?: FetchFollowListOptions): Promise<FollowListPage>;
+/**
+ * @deprecated The `/api/following/feed` surface was reverted (sifa-api#674).
+ *   Per `decisions/activity-data-strategy.md` the Sifa Timeline + ATmosphere
+ *   Stream are two distinct surfaces with different data paths (Barazo API
+ *   for Timeline, live PDS reads + Valkey for Stream). These collapsed feed
+ *   types are no longer consumed. Scheduled for removal in next major bump.
+ */
+interface FetchFollowingFeedOptions extends ApiFetchOptions {
+    cursor?: string;
+    limit?: number;
+    /**
+     * Comma-separated category filter (per sifa-api#673 TR10). Forwarded
+     * as-is; the server validates allowed values.
+     */
+    categories?: string[];
+    cookieHeader?: string;
+}
+/**
+ * V5 home feed: Sifa events + curated ATmosphere creation events filtered
+ * by the authenticated viewer's followees. Composite cursor (per E5/TR4).
+ * Returns an empty page on error.
+ *
+ * @deprecated The `/api/following/feed` surface was reverted (sifa-api#674).
+ *   Per `decisions/activity-data-strategy.md` the Sifa Timeline + ATmosphere
+ *   Stream are two distinct surfaces with different data paths (Barazo API
+ *   for Timeline, live PDS reads + Valkey for Stream). This fetcher is no
+ *   longer consumed. Scheduled for removal in next major bump.
+ */
+declare function getFollowingFeed(config: SifaApiConfig, opts?: FetchFollowingFeedOptions): Promise<FollowFeedPage>;
+
+/**
+ * Options shared by the cursor-paginated follow-graph endpoints introduced in
+ * `sifa-api#674` (mutuals + bluesky-suggestions). Mirrors
+ * `FetchFollowListOptions` in `./follow.ts` but the response wrapper here uses
+ * the `{ items, cursor }` shape (not `{ follows, cursor }`).
+ */
+interface FetchFollowProfilePageOptions extends ApiFetchOptions {
+    cursor?: string;
+    limit?: number;
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls
+     * (mirrors `FetchFollowListOptions`; required for authenticated server
+     * fetches because `credentials: 'include'` does not propagate cookies from
+     * RSC).
+     */
+    cookieHeader?: string;
+}
+/** Page of {@link FollowProfileItem} rows with an opaque next-page cursor. */
+interface FollowProfilePageResponse {
+    items: FollowProfileItem[];
+    cursor: string | null;
+}
+/**
+ * Cursor-paginated list of mutual sifa-source follows for `handleOrDid`
+ * (X↔Y both follow each other on Sifa). Backed by
+ * `GET /api/profile/{handleOrDid}/mutuals` from `sifa-api#674`. Public —
+ * does not require auth. Returns an empty page on error.
+ */
+declare function getMutuals(config: SifaApiConfig, handleOrDid: string, opts?: FetchFollowProfilePageOptions): Promise<FollowProfilePageResponse>;
+/**
+ * Cursor-paginated list of Sifa users the viewer follows on Bluesky but NOT
+ * on Sifa, filtered to people active on Sifa. Backed by
+ * `GET /api/me/bluesky-suggestions` from `sifa-api#674`. Auth-required.
+ * Returns an empty page on error.
+ */
+declare function getBlueskySuggestions(config: SifaApiConfig, opts?: FetchFollowProfilePageOptions): Promise<FollowProfilePageResponse>;
+
+/**
+ * Options for {@link listFeatureAllowlist}. Supports the same `cookieHeader`
+ * passthrough as the other admin reads for RSC contexts.
+ */
+interface ListFeatureAllowlistOptions extends ApiFetchOptions {
+    cookieHeader?: string;
+}
+/** Response shape of `GET /api/admin/feature-allowlists/:flag`. */
+interface FeatureAllowlistResponse {
+    items: FeatureAllowlistEntry[];
+}
+/**
+ * List all DIDs on the given feature flag's allowlist. Admin-gated server-
+ * side (caller must be an admin). Returns an empty list on error so the UI
+ * can render a graceful empty state.
+ */
+declare function listFeatureAllowlist(config: SifaApiConfig, flag: FeatureFlag, opts?: ListFeatureAllowlistOptions): Promise<FeatureAllowlistResponse>;
+/**
+ * Add (or upsert the note for) a DID on the given flag's allowlist. Maps to
+ * `POST /api/admin/feature-allowlists/{flag}`. Returns a {@link WriteResult};
+ * never throws.
+ */
+declare function addFeatureAllowlist(config: SifaApiConfig, flag: FeatureFlag, did: string, opts?: {
+    note?: string;
+} & Omit<ApiFetchOptions, 'method' | 'body'>): Promise<WriteResult>;
+/**
+ * Remove a DID from the given flag's allowlist. Maps to
+ * `DELETE /api/admin/feature-allowlists/{flag}/{did}`. Returns a
+ * {@link WriteResult}; never throws.
+ */
+declare function removeFeatureAllowlist(config: SifaApiConfig, flag: FeatureFlag, did: string, opts?: Omit<ApiFetchOptions, 'method' | 'body'>): Promise<WriteResult>;
+
+interface QuotedPostAuthor {
+    did: string;
+    handle: string;
+    displayName?: string;
+    avatar?: string;
+}
+interface QuotedPostImage {
+    thumb: string;
+    fullsize: string;
+    alt?: string;
+}
+interface QuotedPostView {
+    uri: string;
+    cid: string;
+    author: QuotedPostAuthor;
+    text: string;
+    createdAt: string;
+    images?: QuotedPostImage[];
+}
+type QuotedPostResult = {
+    status: 'ok';
+    record: QuotedPostView;
+} | {
+    status: 'deleted';
+    uri: string;
+} | {
+    status: 'unavailable';
+    uri: string;
+};
+/** Max URIs per request to `POST /api/quoted-posts/resolve` (mirrors server cap). */
+declare const QUOTED_POSTS_BATCH_MAX = 20;
+interface ResolveQuotedPostsOptions extends ApiFetchOptions {
+    /** Cookie header for Next.js RSC server-side calls; ignored in browsers. */
+    cookieHeader?: string;
+}
+/**
+ * Resolve a batch of AT-URIs to their quoted-post snapshots via the Sifa AppView.
+ *
+ * Auto-deduplicates input URIs and splits requests into chunks of
+ * {@link QUOTED_POSTS_BATCH_MAX} so callers can pass an arbitrary-length array.
+ * Each chunk is fired in parallel. The server caches results in Valkey, so
+ * repeated calls for the same URI are cheap.
+ *
+ * Returns a map of `uri -> QuotedPostResult`. URIs that fail (network error,
+ * non-2xx, or the server omitting them) are absent from the map; the caller
+ * should render a skeleton or tombstone for those.
+ */
+declare function resolveQuotedPosts(config: SifaApiConfig, uris: string[], options?: ResolveQuotedPostsOptions): Promise<Record<string, QuotedPostResult>>;
+
+/**
+ * Reachability of an activity card's external destination, as reported by
+ * sifa-api's `/api/activity` enrichment (see sifa-api `url-health-checker`).
+ *
+ *   ok           -- last HEAD returned 2xx/3xx
+ *   broken       -- confirmed dead (>=2 consecutive 4xx, or >=5 consecutive 5xx)
+ *   unverifiable -- 403/429/network error; anti-bot or rate-limited, NOT dead
+ *   unknown      -- newly seen, not yet checked
+ *
+ * Consumers should only suppress UI on `'broken'`. All other values
+ * (including missing) mean "render normally".
+ */
+type ActivityItemLinkHealth = 'ok' | 'broken' | 'unverifiable' | 'unknown';
+interface HeatmapDay {
+    date: string;
+    total: number;
+    apps: {
+        appId: string;
+        count: number;
+    }[];
+}
+interface HeatmapResponse {
+    days: HeatmapDay[];
+    appTotals: {
+        appId: string;
+        appName: string;
+        total: number;
+    }[];
+    thresholds: [number, number, number, number];
+}
+interface ActivityItem {
+    uri: string;
+    cid: string;
+    collection: string;
+    rkey: string;
+    record: Record<string, unknown>;
+    appId: string;
+    appName: string;
+    category: string;
+    indexedAt: string;
+    /**
+     * Set by the server when an `app.bsky.embed.record` quote was already
+     * resolved upstream (AppView path). Mutually exclusive with `quotedPostUri`.
+     */
+    quotedPost?: QuotedPostResult;
+    /**
+     * Set by the server when an `app.bsky.embed.record` quote needs client-side
+     * resolution (PDS path). Pass batches to {@link resolveQuotedPosts}.
+     * Mutually exclusive with `quotedPost`.
+     */
+    quotedPostUri?: string;
+    /**
+     * Reachability of the card's external destination as last checked by
+     * sifa-api. Undefined for legacy responses; treat as 'unknown'.
+     * See {@link ActivityItemLinkHealth}.
+     */
+    linkHealth?: ActivityItemLinkHealth;
+}
+interface ActivityTeaserResponse {
+    items: ActivityItem[];
+    blueskyGated?: boolean;
+    backfillPending?: boolean;
+    failedApps?: string[];
+}
+interface ActivityFeedResponse {
+    items: ActivityItem[];
+    cursor: string | null;
+    hasMore: boolean;
+    availableCategories?: string[];
+    blueskyGated?: boolean;
+    failedApps?: string[];
+}
+/**
+ * Per-day activity counts for a profile across all ATproto apps. Returns
+ * `null` on any error so callers can render a graceful empty state.
+ */
+declare function fetchHeatmapData(config: SifaApiConfig, handleOrDid: string, days: number, options?: ApiFetchOptions): Promise<HeatmapResponse | null>;
+interface FetchActivityTeaserOptions extends ApiFetchOptions {
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls.
+     * Required for authenticated server fetches because `credentials: 'include'`
+     * does not propagate browser cookies in RSC.
+     */
+    cookieHeader?: string;
+}
+/**
+ * Recent activity teaser for a profile (homepage-sized slice). Caps the
+ * upstream wait so the SSR path cannot hang. Returns `null` on any error.
+ */
+declare function fetchActivityTeaser(config: SifaApiConfig, handleOrDid: string, options?: FetchActivityTeaserOptions): Promise<ActivityTeaserResponse | null>;
+interface FetchActivityFeedOptions extends ApiFetchOptions {
+    category?: string;
+    limit?: number;
+    cursor?: string;
+    cookieHeader?: string;
+}
+/**
+ * Paginated activity feed for a profile. Always fresh (`cache: 'no-store'`).
+ * Returns `null` on any error.
+ */
+declare function fetchActivityFeed(config: SifaApiConfig, handleOrDid: string, options?: FetchActivityFeedOptions): Promise<ActivityFeedResponse | null>;
+
+/** Per-URI reaction state for the authenticated viewer. */
+interface ReactionStatus {
+    reacted: boolean;
+    rkey?: string;
+    collection?: string;
+}
+/** Result of checking whether the authenticated viewer has an account on a given app. */
+interface AccountCheckResult {
+    hasAccount: boolean;
+    appName: string;
+    appUrl: string;
+}
+interface FetchReactionStatusOptions extends ApiFetchOptions {
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls.
+     * Required for authenticated server fetches because `credentials: 'include'`
+     * does not propagate browser cookies in RSC.
+     */
+    cookieHeader?: string;
+}
+/**
+ * Batch-look up reaction status for multiple URIs. Returns `{}` for an
+ * empty input list (no network call) and `null` on any error.
+ */
+declare function fetchReactionStatus(config: SifaApiConfig, uris: string[], options?: FetchReactionStatusOptions): Promise<Record<string, ReactionStatus> | null>;
+interface CheckAppAccountOptions extends ApiFetchOptions {
+    cookieHeader?: string;
+}
+/**
+ * Check whether the authenticated viewer has an account on a given app.
+ * Returns `null` on any error.
+ */
+declare function checkAppAccount(config: SifaApiConfig, appId: string, options?: CheckAppAccountOptions): Promise<AccountCheckResult | null>;
+/** Result of a successful {@link createReaction}. */
+interface ReactionResult {
+    uri: string;
+    rkey: string;
+}
+/** Structured error returned by {@link createReaction} on failure. */
+interface ReactionError {
+    type: 'scope_insufficient' | 'error';
+    /** When `type === 'scope_insufficient'`, the lexicon scope the user must re-authorize for. */
+    requiredScope?: string;
+}
+/**
+ * Create a reaction (like / star) on a target ATproto record.
+ *
+ * Returns a discriminated-union result instead of the generic
+ * {@link WriteResult} shape because reactions have a distinct
+ * "scope insufficient" failure that callers handle differently from
+ * other errors (it triggers an OAuth scope-upgrade flow rather than
+ * an error toast).
+ *
+ * Never throws.
+ */
+declare function createReaction(config: SifaApiConfig, targetUri: string, appId: string, targetCid?: string, options?: ApiFetchOptions): Promise<{
+    ok: true;
+    data: ReactionResult;
+} | {
+    ok: false;
+    error: ReactionError;
+}>;
+/**
+ * Delete a reaction (like / star) on a target ATproto record. Returns
+ * `{ success: true }` on 2xx, `{ success: false, error }` on failure.
+ */
+declare function deleteReaction(config: SifaApiConfig, targetUri: string, appId: string, options?: ApiFetchOptions): Promise<WriteResult>;
+
+/** Voter on a roadmap item. */
+interface RoadmapVoter {
+    did: string;
+    avatarUrl?: string;
+}
+/** Map of item key -> vote tally and voter list. */
+type RoadmapVotesResponse = Record<string, {
+    count: number;
+    voters: RoadmapVoter[];
+}>;
+/**
+ * Public roadmap vote tallies, keyed by item. Returns `{}` on any error.
+ */
+declare function fetchRoadmapVotes(config: SifaApiConfig, options?: ApiFetchOptions): Promise<RoadmapVotesResponse>;
+interface FetchMyRoadmapVotesOptions extends ApiFetchOptions {
+    /**
+     * Pass the caller's `Cookie` header on Next.js RSC server-side calls.
+     * Required for authenticated server fetches because `credentials: 'include'`
+     * does not propagate browser cookies in RSC.
+     */
+    cookieHeader?: string;
+}
+/**
+ * Roadmap items the authenticated user has voted on. Returns `[]` on any
+ * error or when the response payload is shaped unexpectedly.
+ */
+declare function fetchMyRoadmapVotes(config: SifaApiConfig, options?: FetchMyRoadmapVotesOptions): Promise<string[]>;
+/** Cast a vote on a roadmap item by its key. */
+declare function castRoadmapVote(config: SifaApiConfig, key: string, options?: ApiFetchOptions): Promise<WriteResult>;
+/** Retract a previously-cast roadmap vote. */
+declare function retractRoadmapVote(config: SifaApiConfig, key: string, options?: ApiFetchOptions): Promise<WriteResult>;
+
+/** Extended write result for {@link deleteAccount}. */
+interface DeleteAccountResult extends WriteResult {
+    /** The deleted handle, returned by the server for confirmation UIs. */
+    handle?: string;
+}
+/**
+ * Reset the authenticated user's Sifa profile.
+ *
+ * `deletePdsData: true` also deletes the corresponding records on the
+ * user's PDS. `deletePdsData: false` only removes the AppView's
+ * indexed state -- the records on the PDS are left intact and could be
+ * re-indexed later.
+ *
+ * Destructive. Server enforces session check + attestation; the SDK
+ * does not gate on additional confirmation. Wrap call sites in your
+ * own modal if you want a UX confirmation step.
+ */
+declare function resetProfile(config: SifaApiConfig, deletePdsData: boolean, options?: ApiFetchOptions): Promise<WriteResult>;
+/**
+ * Delete the authenticated user's account. Returns the deleted handle
+ * on success (used by the post-delete confirmation screen).
+ *
+ * `deletePdsData: true` also deletes the corresponding records on the
+ * user's PDS; `false` leaves the PDS records intact.
+ *
+ * Destructive. Same caveat as {@link resetProfile}.
+ */
+declare function deleteAccount(config: SifaApiConfig, deletePdsData: boolean, options?: ApiFetchOptions): Promise<DeleteAccountResult>;
+
+/**
+ * Query key factory for TanStack Query.
+ *
+ * Keys are read-only tuples; the hierarchy matches the SDK's fetcher
+ * grouping. Use these instead of inline arrays so consumers can target
+ * `queryClient.invalidateQueries({ queryKey: keys.profile.all() })` and
+ * similar patterns without typos.
+ *
+ * Convention: every leaf key starts with the namespace ('sifa') so
+ * consumers can invalidate everything Sifa-related in one call.
+ */
+declare const sifaQueryKeys: {
+    readonly all: () => readonly ["sifa"];
+    readonly profile: {
+        readonly all: () => readonly ["sifa", "profile"];
+        readonly byHandle: (handleOrDid: string) => readonly ["sifa", "profile", string];
+        readonly atFundLink: (did: string) => readonly ["sifa", "profile", "at-fund-link", string];
+        readonly externalAccounts: (handleOrDid: string) => readonly ["sifa", "profile", "external-accounts", string];
+    };
+    readonly position: {
+        readonly all: () => readonly ["sifa", "position"];
+        readonly byOwner: (did: string) => readonly ["sifa", "position", "by-owner", string];
+    };
+    readonly search: {
+        readonly all: () => readonly ["sifa", "search"];
+        readonly profiles: (filters: Record<string, unknown>) => readonly ["sifa", "search", "profiles", Record<string, unknown>];
+        readonly skills: (query: string) => readonly ["sifa", "search", "skills", string];
+        readonly canonicalSkills: (query: string, limit: number) => readonly ["sifa", "search", "canonical-skills", string, number];
+        readonly filters: () => readonly ["sifa", "search", "filters"];
+    };
+    readonly discovery: {
+        readonly all: () => readonly ["sifa", "discovery"];
+        readonly similar: (did: string, limit: number) => readonly ["sifa", "discovery", "similar", string, number];
+        readonly suggestions: (opts: Record<string, unknown>) => readonly ["sifa", "discovery", "suggestions", Record<string, unknown>];
+        readonly suggestionCount: (since: string | undefined) => readonly ["sifa", "discovery", "suggestion-count", string | null];
+        readonly featured: () => readonly ["sifa", "discovery", "featured"];
+    };
+    readonly follow: {
+        readonly all: () => readonly ["sifa", "follow"];
+        readonly following: (opts: Record<string, unknown>) => readonly ["sifa", "follow", "following", Record<string, unknown>];
+        readonly followers: (handle: string) => readonly ["sifa", "follow", "followers", string];
+        readonly followingOf: (handle: string) => readonly ["sifa", "follow", "following-of", string];
+        readonly feed: (opts: Record<string, unknown>) => readonly ["sifa", "follow", "feed", Record<string, unknown>];
+        readonly mutuals: (handle: string) => readonly ["sifa", "follow", "mutuals", string];
+        readonly blueskySuggestions: () => readonly ["sifa", "follow", "bluesky-suggestions"];
+    };
+    readonly admin: {
+        readonly all: () => readonly ["sifa", "admin"];
+        readonly featureAllowlist: (flag: string) => readonly ["sifa", "admin", "feature-allowlist", string];
+    };
+    readonly stats: {
+        readonly all: () => readonly ["sifa", "stats"];
+        readonly homepage: () => readonly ["sifa", "stats", "homepage"];
+    };
+    readonly apps: {
+        readonly all: () => readonly ["sifa", "apps"];
+        readonly registry: () => readonly ["sifa", "apps", "registry"];
+        readonly hidden: () => readonly ["sifa", "apps", "hidden"];
+    };
+    readonly activity: {
+        readonly all: () => readonly ["sifa", "activity"];
+        readonly heatmap: (handleOrDid: string, days: number) => readonly ["sifa", "activity", "heatmap", string, number];
+        readonly teaser: (handleOrDid: string) => readonly ["sifa", "activity", "teaser", string];
+        readonly feed: (handleOrDid: string, opts: Record<string, unknown>) => readonly ["sifa", "activity", "feed", string, Record<string, unknown>];
+    };
+    readonly endorsement: {
+        readonly all: () => readonly ["sifa", "endorsement"];
+        readonly count: (did: string) => readonly ["sifa", "endorsement", "count", string];
+    };
+    readonly stream: {
+        readonly all: () => readonly ["sifa", "stream"];
+        readonly networkCount: (did: string) => readonly ["sifa", "stream", "network-count", string];
+    };
+    readonly reactions: {
+        readonly all: () => readonly ["sifa", "reactions"];
+        readonly status: (uris: string[]) => readonly ["sifa", "reactions", "status", string[]];
+        readonly accountCheck: (appId: string) => readonly ["sifa", "reactions", "account-check", string];
+    };
+    readonly roadmap: {
+        readonly all: () => readonly ["sifa", "roadmap"];
+        readonly votes: () => readonly ["sifa", "roadmap", "votes"];
+        readonly myVotes: () => readonly ["sifa", "roadmap", "my-votes"];
+    };
+};
+type SifaQueryKey = ReturnType<typeof sifaQueryKeys.all> | ReturnType<typeof sifaQueryKeys.profile.all> | ReturnType<typeof sifaQueryKeys.profile.byHandle> | ReturnType<typeof sifaQueryKeys.profile.atFundLink> | ReturnType<typeof sifaQueryKeys.profile.externalAccounts> | ReturnType<typeof sifaQueryKeys.position.all> | ReturnType<typeof sifaQueryKeys.position.byOwner> | ReturnType<typeof sifaQueryKeys.search.all> | ReturnType<typeof sifaQueryKeys.search.profiles> | ReturnType<typeof sifaQueryKeys.search.canonicalSkills> | ReturnType<typeof sifaQueryKeys.search.skills> | ReturnType<typeof sifaQueryKeys.search.filters> | ReturnType<typeof sifaQueryKeys.discovery.all> | ReturnType<typeof sifaQueryKeys.discovery.similar> | ReturnType<typeof sifaQueryKeys.discovery.suggestions> | ReturnType<typeof sifaQueryKeys.discovery.suggestionCount> | ReturnType<typeof sifaQueryKeys.discovery.featured> | ReturnType<typeof sifaQueryKeys.follow.all> | ReturnType<typeof sifaQueryKeys.follow.following> | ReturnType<typeof sifaQueryKeys.follow.followers> | ReturnType<typeof sifaQueryKeys.follow.followingOf> | ReturnType<typeof sifaQueryKeys.follow.feed> | ReturnType<typeof sifaQueryKeys.follow.mutuals> | ReturnType<typeof sifaQueryKeys.follow.blueskySuggestions> | ReturnType<typeof sifaQueryKeys.admin.all> | ReturnType<typeof sifaQueryKeys.admin.featureAllowlist> | ReturnType<typeof sifaQueryKeys.stats.all> | ReturnType<typeof sifaQueryKeys.stats.homepage> | ReturnType<typeof sifaQueryKeys.apps.all> | ReturnType<typeof sifaQueryKeys.apps.registry> | ReturnType<typeof sifaQueryKeys.apps.hidden> | ReturnType<typeof sifaQueryKeys.activity.all> | ReturnType<typeof sifaQueryKeys.activity.heatmap> | ReturnType<typeof sifaQueryKeys.activity.teaser> | ReturnType<typeof sifaQueryKeys.activity.feed> | ReturnType<typeof sifaQueryKeys.endorsement.all> | ReturnType<typeof sifaQueryKeys.endorsement.count> | ReturnType<typeof sifaQueryKeys.stream.all> | ReturnType<typeof sifaQueryKeys.stream.networkCount> | ReturnType<typeof sifaQueryKeys.reactions.all> | ReturnType<typeof sifaQueryKeys.reactions.status> | ReturnType<typeof sifaQueryKeys.reactions.accountCheck> | ReturnType<typeof sifaQueryKeys.roadmap.all> | ReturnType<typeof sifaQueryKeys.roadmap.votes> | ReturnType<typeof sifaQueryKeys.roadmap.myVotes>;
+
+export { type ReactionStatus as $, type AccountCheckResult as A, type BulkHideProfileItemInput as B, type CheckAppAccountOptions as C, type DeleteAccountResult as D, type EndorsementInput as E, type FeatureAllowlistResponse as F, HIDDEN_ITEM_TYPES as G, HIDDEN_ITEM_SOURCES as H, type HeatmapDay as I, type HeatmapResponse as J, type HiddenApp as K, type HiddenItemSource as L, type HiddenItemType as M, type HideProfileItemInput as N, type ListFeatureAllowlistOptions as O, type ProfileIndustryInput as P, type ProfileLocationAddress as Q, type ProfileLocationInput as R, type ProfileSearchResult as S, type ProfileSelfLocation as T, QUOTED_POSTS_BATCH_MAX as U, type QuotedPostAuthor as V, type QuotedPostImage as W, type QuotedPostResult as X, type QuotedPostView as Y, type ReactionError as Z, type ReactionResult as _, type ActivityFeedResponse as a, hideOrcidPublication as a$, type RefreshOrcidPublicationsResult as a0, type RefreshPdsResult as a1, type ResolveQuotedPostsOptions as a2, type RoadmapVoter as a3, type RoadmapVotesResponse as a4, type SearchFilters as a5, type SearchResponse as a6, type SifaApiConfig as a7, type SifaQueryKey as a8, type SimilarProfile as a9, deleteExternalAccount as aA, deleteProfileLocation as aB, deleteReaction as aC, fetchActivityFeed as aD, fetchActivityTeaser as aE, fetchAppsRegistry as aF, fetchExternalAccounts as aG, fetchFeaturedProfile as aH, fetchFollowing as aI, fetchHeatmapData as aJ, fetchHiddenApps as aK, fetchMyRoadmapVotes as aL, fetchReactionStatus as aM, fetchRoadmapVotes as aN, fetchSearchFilters as aO, fetchSearchProfiles as aP, fetchSimilarProfiles as aQ, fetchSkillSuggestions as aR, fetchStats as aS, fetchSuggestionCount as aT, fetchSuggestions as aU, followUser as aV, getBlueskySuggestions as aW, getFollowers as aX, getFollowing as aY, getFollowingFeed as aZ, getMutuals as a_, type SkillSearchResult as aa, type StatsResponse as ab, type SuggestionProfile as ac, type SuggestionsResponse as ad, type UpdateProfileOverrideInput as ae, type UpdateProfileSelfInput as af, type UploadAvatarResult as ag, type VerifyExternalAccountResult as ah, type WriteResult as ai, addFeatureAllowlist as aj, apiFetch as ak, apiFetchOrNull as al, apiWrite as am, apiWriteCreate as an, bulkHideProfileItems as ao, bulkHideStandardPublications as ap, bulkUnhideProfileItems as aq, bulkUnhideStandardPublications as ar, castRoadmapVote as as, checkAppAccount as at, createEndorsement as au, createExternalAccount as av, createProfileLocation as aw, createReaction as ax, deleteAccount as ay, deleteAvatarOverride as az, type ActivityItem as b, hideProfileItem as b0, hideSifaPublication as b1, hideStandardPublication as b2, listFeatureAllowlist as b3, refreshOrcidPublications as b4, refreshPds as b5, removeFeatureAllowlist as b6, resetProfile as b7, resolveQuotedPosts as b8, retractRoadmapVote as b9, searchSkills as ba, setExternalAccountPrimary as bb, sifaQueryKeys as bc, unfollowUser as bd, unhideOrcidPublication as be, unhideProfileItem as bf, unhideSifaPublication as bg, unhideStandardPublication as bh, unsetExternalAccountPrimary as bi, updateExternalAccount as bj, updateProfileLocation as bk, updateProfileOverride as bl, updateProfileSelf as bm, uploadAvatar as bn, verifyExternalAccount as bo, type ActivityItemLinkHealth as c, type ActivityTeaserResponse as d, ApiError as e, type ApiFetchOptions as f, type AppRegistryEntry as g, type CreateExternalAccountResult as h, type CreateResult as i, type ExternalAccountInput as j, type FeaturedProfile as k, type FetchActivityFeedOptions as l, type FetchActivityTeaserOptions as m, type FetchFollowListOptions as n, type FetchFollowProfilePageOptions as o, type FetchFollowingFeedOptions as p, type FetchHiddenAppsOptions as q, type FetchMyRoadmapVotesOptions as r, type FetchReactionStatusOptions as s, type FetchSuggestionsOptions as t, type FilterOptions as u, type FollowListPage as v, type FollowProfile as w, type FollowProfilePageResponse as x, type FollowUserResult as y, type FollowingResponse as z };