@indexnetwork/protocol 14.3.2-rc.477.1 → 17.0.0-rc.479.1

package/dist/shared/interfaces/database.network-queries.d.ts

@@ -0,0 +1,277 @@
+/**
+ * Database operations for intent-network assignment and index ownership.
+ */
+import type { UserIdentity } from '../schemas/identity.schema.js';
+import type { NetworkAssignmentMetadata } from '../schemas/network-assignment.schema.js';
+import type { ActiveIntent, AssignmentNetworkMembership, Id, IndexMemberDetails, IndexedIntentDetails, IntentNetworkFinalAssignmentResult, NetworkAssignmentContext, OwnedIndex, UpdateIndexSettingsData } from './database.entities.js';
+/** Network assignment and owner-only index operations. */
+export interface DatabaseNetworkQueries {
+    /**
+     * Intent fields needed for index appropriateness evaluation.
+     */
+    getIntentForIndexing(intentId: string): Promise<{
+        id: string;
+        payload: string;
+        userId: string;
+        sourceType: string | null;
+        sourceId: string | null;
+    } | null>;
+    /**
+     * Index + member prompts for a user in an index (only when member has autoAssign).
+     * Returns null if user is not a member or autoAssign is false.
+     */
+    getNetworkMemberContext(networkId: string, userId: string): Promise<NetworkAssignmentContext | null>;
+    /**
+     * Network memberships that should be considered for assignment policy. Unlike
+     * getUserIndexIds, this is not gated by network_members.autoAssign and carries
+     * personal-index metadata so scoped writes can include the user's personal network.
+     */
+    getAssignmentNetworkMembershipsForUser(userId: string): Promise<AssignmentNetworkMembership[]>;
+    /**
+     * Network IDs that should be considered for assignment policy. Unlike
+     * getUserIndexIds, this is not gated by network_members.autoAssign.
+     * @deprecated Prefer getAssignmentNetworkMembershipsForUser for scope-aware assignment.
+     */
+    getAssignmentNetworkIdsForUser(userId: string): Promise<string[]>;
+    /**
+     * Prompt context for assignment policy. Unlike getNetworkMemberContext, this is
+     * not gated by network_members.autoAssign.
+     */
+    getNetworkAssignmentContext(networkId: string, userId: string): Promise<NetworkAssignmentContext | null>;
+    /**
+     * Whether the intent is currently assigned to the index.
+     */
+    isIntentAssignedToIndex(intentId: string, networkId: string): Promise<boolean>;
+    /**
+     * Assigns an intent to an index (inserts intent_indexes row).
+     */
+    assignIntentToNetwork(intentId: string, networkId: string, relevancyScore?: number, assignmentMetadata?: NetworkAssignmentMetadata): Promise<void>;
+    /**
+     * Atomically assign an owned, non-archived intent only while the exact
+     * accepted network membership and network remain active. Implementations
+     * hold intent, network, and membership row locks through the insert.
+     */
+    assignIntentToNetworkIfMember(userId: string, intentId: string, networkId: string, relevancyScore?: number, assignmentMetadata?: NetworkAssignmentMetadata): Promise<IntentNetworkFinalAssignmentResult>;
+    /**
+     * Returns per-index relevancy scores for an intent's index assignments.
+     */
+    getIntentIndexScores(intentId: string): Promise<Array<{
+        networkId: string;
+        relevancyScore: number | null;
+        assignmentMetadata?: NetworkAssignmentMetadata | null;
+    }>>;
+    /**
+     * Removes an intent from an index (deletes intent_indexes row).
+     */
+    unassignIntentFromIndex(intentId: string, networkId: string): Promise<void>;
+    /**
+     * Returns all network IDs that an intent is registered to.
+     */
+    getNetworkIdsForIntent(intentId: string): Promise<string[]>;
+    /**
+     * Get indexes where the user has owner permissions.
+     * Returns full index details with member and intent counts.
+     *
+     * @param userId - The user ID to check ownership for
+     * @returns Array of owned indexes with counts
+     */
+    getOwnedIndexes(userId: string): Promise<OwnedIndex[]>;
+    /**
+     * Get public networks (joinPolicy 'anyone') that the user has not joined.
+     * Used for discovering communities available to join.
+     *
+     * @param userId - The user ID to check memberships against
+     * @returns Object containing array of public networks with owner info
+     */
+    getPublicIndexesNotJoined(userId: string): Promise<{
+        networks: Array<{
+            id: string;
+            title: string;
+            prompt: string | null;
+            memberCount: number;
+            owner: {
+                id: string;
+                name: string;
+                avatar: string | null;
+            } | null;
+        }>;
+    }>;
+    /**
+     * Check if user is an owner of a specific index.
+     *
+     * @param networkId - The index to check
+     * @param userId - The user to verify ownership for
+     * @returns True if user is an owner
+     */
+    isIndexOwner(networkId: string, userId: string): Promise<boolean>;
+    /**
+     * Check if user is a member of a specific index.
+     *
+     * @param networkId - The index to check
+     * @param userId - The user to verify membership for
+     * @returns True if user is a member
+     */
+    isNetworkMember(networkId: string, userId: string): Promise<boolean>;
+    /**
+     * Get all members of an index with their details.
+     * **OWNER ONLY** - throws if user is not an owner.
+     *
+     * @param networkId - The index to get members for
+     * @param requestingUserId - The user requesting (must be owner)
+     * @returns Array of member details with intent counts
+     * @throws Error if requestingUserId is not an owner
+     */
+    getNetworkMembersForOwner(networkId: string, requestingUserId: string): Promise<IndexMemberDetails[]>;
+    /**
+     * Get all members of an index with their details.
+     * **MEMBER ONLY** - any member of the index can list members (not just owners).
+     * Returns same shape as getNetworkMembersForOwner; email may be omitted for privacy.
+     *
+     * @param networkId - The index to get members for
+     * @param requestingUserId - The user requesting (must be a member of the index)
+     * @returns Array of member details with intent counts
+     * @throws Error if requestingUserId is not a member of the index
+     */
+    getNetworkMembersForMember(networkId: string, requestingUserId: string): Promise<IndexMemberDetails[]>;
+    /**
+     * Get all members from every network the user is a member of (deduplicated).
+     * Used for mentionable-users: anyone who shares at least one index with the requesting user.
+     *
+     * @param userId - The signed-in user
+     * @returns Array of member summaries (id, name, avatar only; no email)
+     */
+    getMembersFromUserIndexes(userId: Id<'users'>): Promise<{
+        userId: Id<'users'>;
+        name: string;
+        avatar: string | null;
+    }[]>;
+    /**
+     * Get all indexed intents for an index.
+     * **OWNER ONLY** - throws if user is not an owner.
+     *
+     * @param networkId - The index to get intents for
+     * @param requestingUserId - The user requesting (must be owner)
+     * @param options - Pagination options
+     * @returns Array of intent details with owner info
+     * @throws Error if requestingUserId is not an owner
+     */
+    getNetworkIntentsForOwner(networkId: string, requestingUserId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IndexedIntentDetails[]>;
+    /**
+     * Get all indexed intents for an index.
+     * **MEMBER ONLY** - any member of the index can list intents (not just owners).
+     *
+     * @param networkId - The index to get intents for
+     * @param requestingUserId - The user requesting (must be a member of the index)
+     * @param options - Pagination options
+     * @returns Array of intent details with owner info
+     * @throws Error if requestingUserId is not a member of the index
+     */
+    getNetworkIntentsForMember(networkId: string, requestingUserId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<IndexedIntentDetails[]>;
+    /**
+     * Get the caller's own active intents across a set of indexes.
+     * Returns intents owned by `userId` that are linked (via intent_networks)
+     * to at least one of `indexIds`. Used by network-scoped agents to honor
+     * indexScope without falling back to global getActiveIntents (which would
+     * include intents in indexes outside scope).
+     *
+     * @param userId - The intent owner (always the caller).
+     * @param indexIds - The set of network IDs to filter on. Empty → empty result.
+     * @returns Active intents owned by userId in any of indexIds, deduped by intent id.
+     */
+    getActiveIntentsAcrossIndexes(userId: string, indexIds: string[]): Promise<ActiveIntent[]>;
+    /**
+     * Update index settings.
+     * **OWNER ONLY** - throws if user is not an owner.
+     *
+     * @param networkId - The index to update
+     * @param requestingUserId - The user requesting (must be owner)
+     * @param data - The settings to update
+     * @returns The updated index
+     * @throws Error if requestingUserId is not an owner
+     */
+    updateIndexSettings(networkId: string, requestingUserId: string, data: UpdateIndexSettingsData): Promise<OwnedIndex>;
+    /**
+     * Soft-delete a network (set deletedAt).
+     * Caller must ensure network is not personal and has no other members.
+     *
+     * @param networkId - The network to soft-delete
+     */
+    softDeleteNetwork(networkId: string): Promise<void>;
+    /**
+     * Delete a user's profile (removes profile row).
+     * Used after confirmation in chat tools.
+     *
+     * @param userId - User whose profile to delete
+     */
+    deleteProfile(userId: string): Promise<void>;
+    /**
+     * Get a user's profile including its row id (for update_user_context validation).
+     *
+     * @param userId - The user whose profile to fetch
+     * @returns Profile with id, or null if not found
+     */
+    getProfileByUserId(userId: string): Promise<(UserIdentity & {
+        id: string;
+    }) | null>;
+    /**
+     * Create a new index and return its record.
+     *
+     * @param data - Title, optional prompt, optional imageUrl, optional joinPolicy
+     * @returns The created network with id, title, prompt, imageUrl, permissions
+     */
+    createNetwork(data: {
+        title: string;
+        prompt?: string | null;
+        imageUrl?: string | null;
+        joinPolicy?: 'anyone' | 'invite_only';
+    }): Promise<{
+        id: string;
+        title: string;
+        prompt: string | null;
+        imageUrl: string | null;
+        permissions: {
+            joinPolicy: 'anyone' | 'invite_only';
+            invitationLink: {
+                code: string;
+            } | null;
+        };
+    }>;
+    /**
+     * Count members in an index (for delete guard).
+     *
+     * @param networkId - The index to count
+     * @returns Number of members
+     */
+    getNetworkMemberCount(networkId: string): Promise<number>;
+    /**
+     * Add a user as a member of a network.
+     *
+     * @param networkId - The network to add to
+     * @param userId - The user to add
+     * @param role - owner | member
+     * @returns success and optionally alreadyMember if they were already in the network
+     */
+    addMemberToNetwork(networkId: string, userId: string, role: 'owner' | 'member'): Promise<{
+        success: boolean;
+        alreadyMember?: boolean;
+    }>;
+    /**
+     * Removes a user from an index.
+     * Only the network owner can remove members. Cannot remove the owner.
+     *
+     * @param networkId - The index to remove from
+     * @param userId - The user to remove
+     * @returns success, or wasOwner/notMember if removal failed
+     */
+    removeMemberFromIndex(networkId: string, userId: string): Promise<{
+        success: boolean;
+        wasOwner?: boolean;
+        notMember?: boolean;
+    }>;
+}

package/dist/shared/interfaces/database.network-queries.js

@@ -0,0 +1,4 @@
+/**
+ * Database operations for intent-network assignment and index ownership.
+ */
+export {};

package/dist/shared/interfaces/database.opportunity-queries.d.ts

@@ -0,0 +1,285 @@
+/**
+ * Database operations for HyDE documents and the opportunity lifecycle.
+ */
+import type { OutcomeOutbox } from './database.capabilities.js';
+import type { CreateHydeDocumentData, CreateOpportunityData, HydeDocument, HydeSourceType, IntentScopedOpportunityPersistenceResult, Opportunity, OpportunityActor, OpportunityNetworkEligibility, OpportunityQueryOptions, OpportunityStatus } from './database.entities.js';
+/** HyDE document and opportunity persistence operations. */
+export interface DatabaseOpportunityQueries {
+    /**
+     * Get a HyDE document by source and strategy/lens hash.
+     * Returns the first matching document when multiple target corpuses exist.
+     *
+     * @param sourceType - 'intent' | 'query'
+     * @param sourceId - Source entity ID (e.g. intent ID, user ID)
+     * @param strategy - Lens hash (SHA-256 of lens label) or legacy strategy name
+     * @returns The HyDE document or null if not found
+     */
+    getHydeDocument(sourceType: HydeSourceType, sourceId: string, strategy: string): Promise<HydeDocument | null>;
+    /**
+     * Get all HyDE documents for a source (all strategies).
+     *
+     * @param sourceType - 'intent' | 'query'
+     * @param sourceId - Source entity ID
+     * @returns Array of HyDE documents for that source
+     */
+    getHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<HydeDocument[]>;
+    /**
+     * Save a HyDE document (upsert by sourceType + sourceId + strategy/lensHash + targetCorpus).
+     *
+     * @param data - HyDE document data
+     * @returns The saved HyDE document
+     */
+    saveHydeDocument(data: CreateHydeDocumentData): Promise<HydeDocument>;
+    /**
+     * Delete all HyDE documents for a source (e.g. when intent archived).
+     *
+     * @param sourceType - 'intent' | 'query'
+     * @param sourceId - Source entity ID
+     * @returns Number of documents deleted
+     */
+    deleteHydeDocumentsForSource(sourceType: HydeSourceType, sourceId: string): Promise<number>;
+    /**
+     * Delete expired HyDE documents (expires_at <= now). Used by maintenance jobs.
+     *
+     * @returns Number of documents deleted
+     */
+    deleteExpiredHydeDocuments(): Promise<number>;
+    /**
+     * Get stale HyDE documents for refresh (e.g. createdAt < threshold).
+     *
+     * @param threshold - Date threshold; documents created before this are considered stale
+     * @returns Array of stale HyDE documents
+     */
+    getStaleHydeDocuments(threshold: Date): Promise<HydeDocument[]>;
+    /**
+     * Create a new opportunity.
+     *
+     * @param data - Opportunity creation data
+     * @returns The created opportunity
+     */
+    createOpportunity(data: CreateOpportunityData): Promise<Opportunity>;
+    /**
+     * Atomically create only while every actor still has an active membership on
+     * the actor's network. Implementations lock the membership rows through the
+     * insert commit so concurrent removal cannot race opportunity creation.
+     */
+    createOpportunityIfNetworkEligible?(data: CreateOpportunityData, eligibility: OpportunityNetworkEligibility): Promise<Opportunity | null>;
+    /**
+     * Intent-scoped discovery persistence boundary. Implementations serialize on
+     * normalized participant pair + trigger intent, re-check same-trigger recent
+     * duplicates and pair-global active negotiations, then create/expire while
+     * the existing network eligibility locks remain held.
+     */
+    persistIntentScopedOpportunityIfNetworkEligible?(data: CreateOpportunityData, expireIds: string[], eligibility: OpportunityNetworkEligibility & {
+        triggerIntentId: string;
+    }, dedupWindowMs: number): Promise<IntentScopedOpportunityPersistenceResult | null>;
+    /**
+     * Atomically update status only while the supplied participant anchors remain
+     * active and, when supplied, the opportunity still has `expectedStatus`.
+     * Used for discovery dedup reactivation races.
+     *
+     * @param id - Opportunity ID
+     * @param status - Target lifecycle status
+     * @param actors - Participant anchors that must remain network-eligible
+     * @param eligibility - Authoritative owner/network/intent scope
+     * @param expectedStatus - Optional compare-and-set source status
+     * @returns The updated opportunity, or null after eligibility/status drift
+     */
+    updateOpportunityStatusIfNetworkEligible?(id: string, status: OpportunityStatus, actors: OpportunityActor[], eligibility: OpportunityNetworkEligibility, expectedStatus?: OpportunityStatus): Promise<Opportunity | null>;
+    /**
+     * Get a single opportunity by ID.
+     *
+     * @param id - Opportunity ID
+     * @returns The opportunity or null if not found
+     */
+    getOpportunity(id: string): Promise<Opportunity | null>;
+    /**
+     * Get multiple opportunities by ID in a single batched query.
+     *
+     * Returns rows in arbitrary order; callers should index by `id`.
+     * Missing IDs are silently dropped (no error).
+     *
+     * @param ids - Opportunity IDs (deduplicated by the caller is fine but not required)
+     * @returns Opportunities found
+     */
+    getOpportunitiesByIds(ids: string[]): Promise<Opportunity[]>;
+    /**
+     * Find opportunities that superseded a previous opportunity through enrichment.
+     * Uses the existing JSONB `detection.enrichedFrom` array, so no schema-level relation is required.
+     * Results are newest-first so callers can choose the newest visible replacement.
+     *
+     * @param opportunityId - Superseded opportunity ID
+     * @returns Replacement opportunities, newest first
+     */
+    findEnrichedReplacementOpportunities(opportunityId: string): Promise<Opportunity[]>;
+    /**
+     * Resolve an opportunity identifier (full UUID or short prefix) to a full UUID.
+     * @param idOrPrefix - Full UUID or short hex prefix
+     * @param userId - The user ID (for visibility scoping)
+     * @returns Resolved ID, ambiguous marker, or null if not found
+     */
+    resolveOpportunityId(idOrPrefix: string, userId: string): Promise<{
+        id: string;
+    } | {
+        ambiguous: true;
+    } | null>;
+    /**
+     * Get opportunities for a user (as any actor role).
+     *
+     * @param userId - User ID (actor userId)
+     * @param options - Optional filters and pagination
+     * @returns Array of opportunities
+     */
+    getOpportunitiesForUser(userId: string, options?: OpportunityQueryOptions): Promise<Opportunity[]>;
+    /**
+     * Get the live candidate pool created exactly by one intent and visible to
+     * its recipient. Unlike selected-intent reads, this never falls back to an
+     * actor.intent match.
+     */
+    getLivePoolOpportunitiesForIntent(recipientUserId: string, intentId: string): Promise<Opportunity[]>;
+    /**
+     * Get opportunities in an index (for index admins).
+     *
+     * @param networkId - Network ID
+     * @param options - Optional filters and pagination
+     * @returns Array of opportunities
+     */
+    getOpportunitiesForNetwork(networkId: string, options?: OpportunityQueryOptions): Promise<Opportunity[]>;
+    /**
+     * Update an opportunity's status.
+     *
+     * @param id - Opportunity ID
+     * @param status - New status
+     * @param acceptedBy - Required when `status === 'accepted'`
+     * @param outbox - Optional IND-434 atomic outcome-capture (same-txn insert)
+     * @returns The updated opportunity or null if not found
+     */
+    updateOpportunityStatus(id: string, status: OpportunityStatus, acceptedBy?: string, outbox?: OutcomeOutbox): Promise<Opportunity | null>;
+    /**
+     * Atomically restores a taskless negotiation attempt to its pre-negotiation status.
+     * Serializes with exact-attempt task creation, then transitions only the exact
+     * still-current `negotiating` version when no qualifying negotiation task exists.
+     *
+     * @param id - Opportunity ID
+     * @param expectedUpdatedAt - Persistence boundary for this negotiation attempt
+     * @param fallbackStatus - Status restored when the guarded transition succeeds
+     * @returns The compensated opportunity, or null on a status, version, or task race
+     */
+    compensateTasklessNegotiatingOpportunity(id: string, expectedUpdatedAt: Date, fallbackStatus: 'latent' | 'draft'): Promise<Opportunity | null>;
+    /**
+     * Stamp `actedAt` on the actor matching `actorUserId` and update the
+     * opportunity's status atomically (row-lock + JSONB merge in one txn).
+     *
+     * Used by `sendNode` (status → 'pending') and `updateNode` (status →
+     * 'accepted'). The self-accept guard is enforced in the caller, not here —
+     * this method blindly stamps. Callers must pre-check `actor.actedAt` before
+     * invocation when the semantics require it (i.e. accepting).
+     *
+     * @param id - Opportunity ID
+     * @param actorUserId - The user whose actor entry should be stamped
+     * @param status - New opportunity status
+     * @param acceptedBy - Required when `status === 'accepted'`
+     * @param outbox - Optional IND-434 atomic outcome-capture (same-txn insert)
+     * @returns The updated opportunity, or null if not found
+     */
+    stampOpportunityActorAction(id: string, actorUserId: string, status: OpportunityStatus, acceptedBy?: string, outbox?: OutcomeOutbox): Promise<Opportunity | null>;
+    /**
+     * Update the `approved` field on an opportunity's introducer actor.
+     * Fetches the opportunity, patches the matching actor in JS, and writes
+     * the updated actors JSONB back. Returns the updated opportunity or null.
+     */
+    updateOpportunityActorApproval(id: string, introducerUserId: string, approved: boolean): Promise<Opportunity | null>;
+    /**
+     * Create one opportunity and expire others in a single transaction.
+     * Atomic: insert then update status to 'expired' for each id in expireIds.
+     * Used when enriching replaces overlapping opportunities so subscribers see consistent state.
+     *
+     * @param data - Opportunity creation data (caller may set status when enriched)
+     * @param expireIds - Opportunity IDs to set status to 'expired'
+     * @returns The created opportunity and the list of opportunities that were expired
+     */
+    createOpportunityAndExpireIds(data: CreateOpportunityData, expireIds: string[]): Promise<{
+        created: Opportunity;
+        expired: Opportunity[];
+    }>;
+    /** Eligibility-locked variant of create+expire for discovery persistence. */
+    createOpportunityAndExpireIdsIfNetworkEligible?(data: CreateOpportunityData, expireIds: string[], eligibility: OpportunityNetworkEligibility): Promise<{
+        created: Opportunity;
+        expired: Opportunity[];
+    } | null>;
+    /**
+     * Check if an opportunity already exists between the given actors in the index (deduplication).
+     *
+     * @param actorIds - Array of user IDs that would be actors
+     * @param networkId - Network ID
+     * @returns True if a non-expired opportunity exists with exactly these actors in this network
+     */
+    opportunityExistsBetweenActors(actorIds: string[], networkId: string): Promise<boolean>;
+    /**
+     * Find opportunities whose actors contain all the given user IDs.
+     *
+     * The `includeIntroducers` flag controls actor matching: when false (default), matching
+     * is restricted to non-introducer roles; when true, any role in `actors` counts.
+     *
+     * Index-agnostic. Ordered by updatedAt desc.
+     *
+     * @param actorIds - User IDs that must all appear in each returned opportunity's actors
+     * @param options - includeIntroducers (default false), statuses (include filter), excludeStatuses (exclude filter)
+     * @returns Matching opportunities, newest first
+     */
+    findOpportunitiesByActors(actorIds: string[], options?: {
+        includeIntroducers?: boolean;
+        statuses?: OpportunityStatus[];
+        excludeStatuses?: OpportunityStatus[];
+    }): Promise<Opportunity[]>;
+    /**
+     * IND-567 Rejection cool-down: returns the subset of `candidateUserIds` that
+     * have at least one non-draft opportunity with `discovererId` whose `updatedAt`
+     * falls within the last `windowMs` milliseconds AND whose status is `rejected`
+     * or `stalled`. Used by the evaluation node to apply a score penalty before
+     * sending candidates to the LLM, suppressing cross-query re-surfacing of
+     * recently-rejected pairs.
+     *
+     * Optional — adapters that do not implement it return `undefined`; the graph
+     * degrades gracefully (no penalty applied, dedup persist-node guard still fires).
+     *
+     * @param discovererId - User running discovery
+     * @param candidateUserIds - Candidate user IDs to check (may be empty — return [])
+     * @param windowMs - Look-back window in milliseconds
+     * @returns Candidate user IDs (subset of input) with a recent rejected/stalled opp
+     */
+    getRecentlyRejectedOpportunityCounterparties?(discovererId: string, candidateUserIds: string[], windowMs: number): Promise<string[]>;
+    /**
+     * Expire opportunities referencing an intent (e.g. when intent is archived).
+     *
+     * @param intentId - Intent ID to match in opportunity actors
+     * @returns Number of opportunities updated to expired
+     */
+    expireOpportunitiesByIntent(intentId: string): Promise<number>;
+    /**
+     * Expire opportunities for a user removed from an index.
+     *
+     * @param networkId - Network ID
+     * @param userId - User ID that was removed
+     * @returns Number of opportunities updated to expired
+     */
+    expireOpportunitiesForRemovedMember(networkId: string, userId: string): Promise<number>;
+    /**
+     * Expire opportunities whose expires_at <= now. Used by maintenance cron.
+     *
+     * @returns Number of opportunities updated to expired
+     */
+    expireStaleOpportunities(): Promise<number>;
+    /**
+     * Accept all sibling opportunities between the same actor pair in one transaction.
+     * Selects opportunities where both userId and counterpartUserId are actors and status
+     * is not accepted/expired/rejected, excludes excludeOpportunityId, then bulk-updates status to accepted.
+     * Rolls back on any failure.
+     *
+     * @param userId - First actor user ID
+     * @param counterpartUserId - Second actor user ID
+     * @param excludeOpportunityId - Opportunity ID to exclude (the one already being accepted)
+     * @returns IDs of opportunities that were updated to accepted
+     */
+    acceptSiblingOpportunities(userId: string, counterpartUserId: string, excludeOpportunityId: string): Promise<string[]>;
+}

package/dist/shared/interfaces/database.opportunity-queries.js

@@ -0,0 +1,4 @@
+/**
+ * Database operations for HyDE documents and the opportunity lifecycle.
+ */
+export {};