eggi-ai-db-schema-2 0.1.1

package/dist/lib/database-service.d.ts

@@ -0,0 +1,714 @@
+/**
+ * =============================================================================
+ * DATABASE SERVICE - Clean Object-Oriented Database Management
+ * =============================================================================
+ *
+ * Provides a singleton database service that accepts connection parameters
+ * directly. No environment variables, no AWS dependencies - just clean
+ * database operations with provided connection info.
+ *
+ * @author Eggi.ai Team
+ * @version 3.0.0 - Clean architecture with input-based connections
+ */
+import { Pool } from "pg";
+/**
+ * Database connection parameters
+ */
+export interface DatabaseConnectionConfig {
+    /** Complete database URL (if provided, other params are ignored) */
+    databaseUrl?: string;
+    /** Individual connection parameters */
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+    /** SSL configuration */
+    ssl?: boolean;
+}
+import type { ConnectionPoolConfig } from "./db";
+/**
+ * Database service configuration
+ */
+export interface DatabaseServiceConfig {
+    /** Database connection configuration (REQUIRED) */
+    connection: DatabaseConnectionConfig;
+    /** Connection pool configuration */
+    poolConfig?: ConnectionPoolConfig;
+}
+import { createMappingJobForLinkedInAccount, startMappingJob, completeMappingJob } from "../utils/mapping-job-operations";
+import { createLlmInferenceJob } from "../utils/llm-inference-job-operations";
+import { createOrganizationAssignmentJob, type OrganizationAssignmentJobMetadata, type UserExportsResult, type ExportAvailabilityResult, type ExportStatusResult } from "../utils/organization-assignment-job-operations";
+import { createOnDemandMappingJob } from "../utils/on-demand-mapping-operations";
+import { createContactInfo, upsertContactInfo, batchCreateContactInfos, batchUpsertContactInfos } from "../utils/contact-operations";
+import { getExistingUnipileAccount } from "../utils/user-operations";
+import { createUnipileAccount, upsertUnipileAccount } from "../utils/unipile-account-operations";
+import { upsertLinkedInAccountRelationshipScore, getLinkedInAccountRelationshipScore, type LinkedinRelationshipWithAccountsAndUsers } from "../utils/linkedin-account-relationship-operations";
+import { getTopClosestConnections } from "../utils/relationship-operations";
+import { getConnectionsForChromeExtension } from "../queries/minimal-connections";
+import { findOrCreateSkill, findOrCreateSkills, addProfileSkills, addWorkExperienceSkills, addEducationSkills } from "../utils/skills-operations";
+import { createIntroductionRequest } from "../utils/introduction-request-operations";
+import { createOnboardingJob } from "../utils/onboarding-operations";
+import { type QuotaCheckResult, type QuotaPeriod, type QuotaSummary } from "../utils/quota-operations";
+/**
+ * Singleton Database Service Class
+ * Manages database connections and provides type-safe query methods
+ */
+declare class DatabaseService {
+    private static instance;
+    private dbPromise;
+    private isInitialized;
+    private constructor();
+    /**
+     * Get singleton instance of DatabaseService
+     */
+    static getInstance(): DatabaseService;
+    /**
+     * Build database URL from provided connection configuration
+     */
+    private buildDatabaseUrl;
+    /**
+     * Initialize database connection with configuration
+     * REQUIRED: Must provide connection configuration
+     */
+    initialize(config: DatabaseServiceConfig): Promise<void>;
+    /**
+     * Get database instance
+     * Throws error if not initialized
+     */
+    getDb(): Promise<Pool>;
+    /**
+     * Check if database is initialized
+     */
+    isReady(): boolean;
+    createMappingJobForLinkedInAccount(params: Parameters<typeof createMappingJobForLinkedInAccount>[1]): Promise<{
+        mappingJob: import("./schema").MappingJob;
+    }>;
+    createMappingJobWithLinkedInAccounts(accountsData: Array<{
+        linkedinAccountId: number;
+        metadata?: Record<string, any>;
+    }>): Promise<{
+        mappingJobs: import("./schema").MappingJob[];
+    }>;
+    startMappingJob(mappingJobId: number, metadata?: Parameters<typeof startMappingJob>[2]): Promise<import("./schema").MappingJob>;
+    completeMappingJob(mappingJobId: number, metadata?: Parameters<typeof completeMappingJob>[2]): Promise<import("./schema").MappingJob>;
+    validateMappingJobCompletion(mappingJobId: number): Promise<{
+        isValid: boolean;
+        mappingJob?: import("./schema").MappingJob;
+        error?: string;
+    }>;
+    createLlmInferenceJob(params: Parameters<typeof createLlmInferenceJob>[1]): Promise<{
+        llmInferenceJob: import("./schema").LlmInferenceJob;
+    }>;
+    createOrganizationAssignmentJob(params: Parameters<typeof createOrganizationAssignmentJob>[1]): Promise<import("../utils/organization-assignment-job-operations").OrganizationAssignmentJob>;
+    completeOrganizationAssignmentJob(organizationAssignmentJobId: number, completionMetadata?: OrganizationAssignmentJobMetadata): Promise<import("../utils/organization-assignment-job-operations").OrganizationAssignmentJob>;
+    getOrganizationAssignmentJobById(organizationAssignmentJobId: number): Promise<import("../utils/organization-assignment-job-operations").OrganizationAssignmentJob | null>;
+    checkExportAvailability(mappingJobId: number | null, organizationId: number): Promise<ExportAvailabilityResult>;
+    checkExportAvailabilityForLinkedInAccount(linkedinAccountId: number, organizationId: number): Promise<ExportAvailabilityResult>;
+    getExportStatusByLinkedInIdentifier(linkedinIdentifierAcoa: string, organizationId: number): Promise<ExportStatusResult>;
+    /**
+     * Get paginated exports for a user (requester)
+     * @param requesterLinkedinAccountId - LinkedIn account ID of the requester
+     * @param options - Query options (page, pageSize, sort, organizationId, status)
+     * @returns Paginated list of exports with profile and organization details
+     */
+    getUserExports(requesterLinkedinAccountId: number, options?: {
+        page?: number;
+        pageSize?: number;
+        sort?: "asc" | "desc";
+        organizationId?: number;
+        status?: "pending" | "completed" | "failed" | "all";
+    }): Promise<UserExportsResult>;
+    getLatestOrganizationAssignmentJobForUser(userId: number, organizationId: number): Promise<import("../utils/organization-assignment-job-operations").OrganizationAssignmentJob | null>;
+    getLatestOrganizationAssignmentJob(mappingJobId: number, organizationId: number): Promise<import("../utils/organization-assignment-job-operations").OrganizationAssignmentJob | null>;
+    updateOrganizationAssignmentJobMetadata(organizationAssignmentJobId: number, metadata: OrganizationAssignmentJobMetadata): Promise<import("../utils/organization-assignment-job-operations").OrganizationAssignmentJob>;
+    getRelationshipScoresForMappingJob(mappingJobId: number, options?: {
+        limit?: number;
+        minScore?: number;
+    }): Promise<{
+        id: number;
+        linkedin_account_id_a: number;
+        linkedin_account_id_b: number;
+        score: number;
+        model_version: string;
+        analysis_type: string;
+        mapping_job_id: number;
+        metadata: Record<string, any>;
+        created_at: Date;
+    }[]>;
+    getEnrichedRelationshipScoresForMappingJob(mappingJobId: number, mainLinkedinAccountId: number, options?: {
+        limit?: number;
+        minScore?: number;
+        sortOrder?: "asc" | "desc";
+    }): Promise<{
+        score: number;
+        modelVersion: string;
+        analysisType: string;
+        mappingJobId: number;
+        metadata: Record<string, any>;
+        createdAt: Date;
+        otherAccount: {
+            id: number;
+            linkedinIdentifierAcoa: string | null;
+            publicIdentifier: string | null;
+            firstName: string | null;
+            lastName: string | null;
+            headline: string | null;
+            profilePictureUrl: string | null;
+        };
+    }[]>;
+    getRelationshipScoresForAccount(linkedinAccountId: number, options?: {
+        limit?: number;
+        minScore?: number;
+        modelVersion?: string;
+        sortOrder?: "asc" | "desc";
+    }): Promise<{
+        score: number;
+        modelVersion: string;
+        analysisType: string;
+        mappingJobId: number;
+        metadata: Record<string, any>;
+        createdAt: Date;
+        otherAccount: {
+            id: number;
+            linkedinIdentifierAcoa: string | null;
+            publicIdentifier: string | null;
+            firstName: string | null;
+            lastName: string | null;
+            headline: string | null;
+            profilePictureUrl: string | null;
+        };
+    }[]>;
+    getMappingJobWithLinkedInAccount(mappingJobId: number): Promise<{
+        mappingJob: import("./schema").MappingJob;
+        linkedinAccount: {
+            id: number;
+            user_id: number | null;
+            linkedin_identifier_acoa: string | null;
+            public_identifier: string | null;
+            forager_id: number;
+            first_name: string | null;
+            last_name: string | null;
+            headline: string | null;
+            summary: string | null;
+            location: string | null;
+            profile_picture_url: string | null;
+            profile_image_cloudfront_url: string | null;
+            follower_count: number | null;
+            connections_count: number | null;
+            profiles_updated_at: Date | null;
+            created_at: Date;
+        };
+        user?: {
+            id: number;
+            given_name: string | null;
+            family_name: string | null;
+            summary: string | null;
+            embedding_summary: string | null;
+            embedding: any;
+            created_at: Date;
+        } | undefined;
+    } | null>;
+    createOnboardingJob(data: Parameters<typeof createOnboardingJob>[1]): Promise<import("../utils/onboarding-operations").OnboardingJobResult>;
+    updateOnboardingJob(onboardingJobId: number, updates: {
+        currentStep?: string;
+        nextStep?: string | null;
+        completedAt?: Date | null;
+        metadata?: Record<string, any>;
+    }): Promise<import("../utils/onboarding-operations").OnboardingJobResult>;
+    updateOnboardingJobStep(onboardingJobId: number, currentStep: string, nextStep?: string, metadata?: Record<string, any>): Promise<import("../utils/onboarding-operations").OnboardingJobResult>;
+    completeOnboardingJob(onboardingJobId: number, completionMetadata?: Record<string, any>): Promise<import("../utils/onboarding-operations").OnboardingJobResult>;
+    getOnboardingJobByUserId(userId: number): Promise<import("../utils/onboarding-operations").OnboardingJobResult | null>;
+    getOnboardingJobById(onboardingJobId: number): Promise<import("../utils/onboarding-operations").OnboardingJobResult | null>;
+    createOnDemandMappingJob(data: Parameters<typeof createOnDemandMappingJob>[0]): Promise<import("../utils/on-demand-mapping-operations").OnDemandMappingJob>;
+    /**
+     * Check and increment quota for a mapping job request
+     * Returns whether the operation is allowed based on quota limits
+     */
+    checkAndIncrementMappingJobQuota(authenticatedUserId: number, organizationId: number, period?: QuotaPeriod): Promise<QuotaCheckResult>;
+    /**
+     * Get current quota status without incrementing
+     */
+    getMappingJobQuotaStatus(authenticatedUserId: number, organizationId: number, period?: QuotaPeriod): Promise<QuotaCheckResult | null>;
+    /**
+     * Get all quotas for a user across all organizations
+     * Returns quotas for all quota types (currently only mapping_jobs, but extensible)
+     */
+    getAllQuotasForUser(authenticatedUserId: number): Promise<QuotaSummary[]>;
+    /**
+     * Initialize quota records for all organization members when subscription is activated
+     * Creates daily and monthly quota records with appropriate limits based on subscription tier
+     */
+    initializeQuotasForOrganization(organizationId: number): Promise<number>;
+    getAllOnDemandMappingJobsForUserMinimal(requesterLinkedinAccountId: number, limit?: number, offset?: number): Promise<{
+        jobs: import("../utils/on-demand-mapping-operations").OnDemandMappingJobMinimal[];
+        total_items: number;
+    }>;
+    checkMappingAvailability(targetLinkedInIdentifier: string): Promise<import("../utils/mapping-job-operations").MappingAvailabilityResult>;
+    getOnDemandMappingJobById(jobId: number): Promise<import("../utils/on-demand-mapping-operations").OnDemandMappingJob | null>;
+    getMappingJobById(mappingJobId: number): Promise<{
+        id: number;
+        linkedin_account_id: number;
+        completed_at: Date | null;
+    } | null>;
+    getTargetLinkedInAccountIdForOnDemandJobInOrganization(requesterLinkedinAccountId: number, organizationId: number): Promise<number | null>;
+    checkOnDemandMappingJobExists(requesterLinkedInAccountId: number, targetLinkedInIdentifier: string): Promise<import("../utils/on-demand-mapping-operations").OnDemandMappingJob | null>;
+    updateOnDemandMappingJobId(requesterLinkedinAccountId: number, internalIdentifierAcoa: string, mappingJobId: number): Promise<import("../utils/on-demand-mapping-operations").OnDemandMappingJob>;
+    getLinkedInAccountsForUser(userId: number): Promise<import("./schema").LinkedinAccount[]>;
+    getAuthenticatedUserByCognitoId(cognitoUserId: string): Promise<import("./schema").AuthenticatedUser | null>;
+    getAuthenticatedUserByUserId(userId: number): Promise<import("./schema").AuthenticatedUser | null>;
+    getAuthenticatedUserByEmail(email: string): Promise<{
+        auth_user_id: number;
+        user_id: number | null;
+        email: string;
+    } | null>;
+    getUserByCognitoId(cognitoUserId: string): Promise<import("./schema").User | null>;
+    getExistingUnipileAccount(cognitoUserId: string, platformType: Parameters<typeof getExistingUnipileAccount>[2]): Promise<import("./schema").UnipileAccount | null>;
+    findAuthenticatedUserByCognitoId(cognitoUserId: string): Promise<import("./schema").AuthenticatedUser | null>;
+    findAuthenticatedUserById(authenticatedUserId: number): Promise<import("./schema").AuthenticatedUser | null>;
+    findAuthenticatedUserByUserId(userId: number): Promise<import("./schema").AuthenticatedUser | null>;
+    updateAuthenticatedUserAdminStatus(cognitoUserId: string, isAdmin: boolean): Promise<import("./schema").AuthenticatedUser | null>;
+    getAllAdminUsers(): Promise<import("./schema").AuthenticatedUser[]>;
+    getCachedLinkedinProfiles(acoIdentifiers: string[]): Promise<(import("../utils/linkedin-profile-cache").CachedLinkedInProfile | null)[]>;
+    getComprehensiveLinkedinProfile(identifier: string): Promise<import("../utils/linkedin-profile-cache").CachedLinkedInProfile | null>;
+    getComprehensiveLinkedinProfileById(linkedinAccountId: number): Promise<import("../utils/linkedin-profile-cache").CachedLinkedInProfile | null>;
+    createContactInfo(data: Parameters<typeof createContactInfo>[1]): Promise<import("./schema").ContactInfo>;
+    upsertContactInfo(data: Parameters<typeof upsertContactInfo>[1]): Promise<import("./schema").ContactInfo>;
+    batchCreateContactInfos(contactInfosData: Parameters<typeof batchCreateContactInfos>[1]): Promise<import("./schema").ContactInfo[]>;
+    batchUpsertContactInfos(contactInfosData: Parameters<typeof batchUpsertContactInfos>[1]): Promise<import("./schema").ContactInfo[]>;
+    getBatchUserEmails(userIds: number[]): Promise<Map<number, string[]>>;
+    createUnipileAccount(data: Parameters<typeof createUnipileAccount>[1]): Promise<import("./schema").UnipileAccount>;
+    upsertUnipileAccount(data: Parameters<typeof upsertUnipileAccount>[1]): Promise<import("./schema").UnipileAccount>;
+    getUserLinkedAccountStatus(cognitoUserId: string, activeOnly?: boolean): Promise<import("../utils/unipile-account-operations").LinkedAccountStatusMap>;
+    batchMarkAccountsAsSynced(accountIds: number[], syncTime?: Date): Promise<number>;
+    checkAcoaAlreadyConnectedToDifferentUser(linkedinIdentifierAcoa: string, currentUserId: number): Promise<number | null>;
+    upsertLinkedInAccountRelationshipScore(data: Parameters<typeof upsertLinkedInAccountRelationshipScore>[1]): Promise<import("./schema").LinkedinRelationship>;
+    getLinkedInAccountRelationshipScore(linkedinAccountIdA: number, linkedinAccountIdB: number, modelVersion: string, analysisType?: Parameters<typeof getLinkedInAccountRelationshipScore>[4]): Promise<import("./schema").LinkedinRelationship | null>;
+    getLinkedInRelationshipByIdWithAccountsAndUsers(relationshipId: number): Promise<LinkedinRelationshipWithAccountsAndUsers | null>;
+    getTopClosestConnections(cognitoUserId: string, modelVersion?: number, limit?: number, sortOrder?: Parameters<typeof getTopClosestConnections>[4]): Promise<{
+        score: number;
+        modelVersion: number | null;
+        createdAt: Date;
+        otherUser: {
+            id: number;
+            givenName: string | null;
+            familyName: string | null;
+            linkedinIdentifier: string | null;
+            profileImageUrl: string | null;
+        };
+    }[]>;
+    getConnectionsForChromeExtension(identifier: string, identifierType?: Parameters<typeof getConnectionsForChromeExtension>[2]): Promise<{
+        results: import("../queries/minimal-connections").ChromeExtensionConnection[];
+        pagination: {
+            page: number;
+            pageSize: number;
+            totalItems: number;
+            totalPages: number;
+            hasNextPage: boolean;
+            hasPreviousPage: boolean;
+        };
+    }>;
+    handlePostAuthentication(cognitoUserId: string, userId: number, signupEmail?: string): Promise<import("../utils/authentication-operations").AuthenticationResult>;
+    findOrCreateSkill(skillName: string, category?: Parameters<typeof findOrCreateSkill>[2]): Promise<{
+        id: number;
+        name: string;
+    }>;
+    findOrCreateSkills(skillInputs: Parameters<typeof findOrCreateSkills>[1]): Promise<{
+        id: number;
+        name: string;
+    }[]>;
+    addProfileSkills(profileId: number, skillInputs: Parameters<typeof addProfileSkills>[2]): Promise<{
+        added: number;
+        errors: string[];
+    }>;
+    getProfileSkills(profileId: number): Promise<{
+        skillId: number;
+        skillName: string;
+    }[]>;
+    addWorkExperienceSkills(workExperienceId: number, skillInputs: Parameters<typeof addWorkExperienceSkills>[2]): Promise<{
+        added: number;
+        errors: string[];
+    }>;
+    addEducationSkills(educationId: number, skillInputs: Parameters<typeof addEducationSkills>[2]): Promise<{
+        added: number;
+        errors: string[];
+    }>;
+    getEducationSkills(educationId: number): Promise<{
+        skill: {
+            id: number;
+            name: string;
+        };
+    }[]>;
+    getWorkExperienceSkills(workExperienceId: number): Promise<{
+        skillId: number;
+        skillName: string;
+    }[]>;
+    getPopularSkills(limit?: number): Promise<{
+        skillId: number;
+        skillName: string;
+        profileCount: number;
+    }[]>;
+    findLinkedInAccountByForagerId(foragerId: number): Promise<import("../utils/forager-linkedin-operations").LinkedInAccountResult | null>;
+    findLinkedInAccountByPublicIdentifier(publicIdentifier: string): Promise<import("../utils/forager-linkedin-operations").LinkedInAccountResult | null>;
+    findLinkedInAccountByAnyIdentifier(identifier: string | number): Promise<import("../utils/forager-linkedin-operations").LinkedInAccountResult | null>;
+    findLinkedInAccountByAcoa(linkedinIdentifierAcoa: string): Promise<import("../utils/forager-linkedin-operations").LinkedInAccountResult | null>;
+    findOrCreateLinkedInAccountByAcoa(linkedinIdentifierAcoa: string, publicIdentifier?: string, userId?: number): Promise<import("./db-types").FindOrCreateResult>;
+    findOrCreateLinkedInAccountByForagerId(foragerId: number, publicIdentifier?: string, linkedinIdentifierAcoa?: string, userId?: number): Promise<import("./db-types").FindOrCreateResult>;
+    storeCompleteLinkedInProfileByForagerId(foragerId: number, profileData: any, userId?: number, userWasCreated?: boolean): Promise<import("./db-types").CompleteLinkedInProfileResult>;
+    /**
+     * Store complete LinkedIn profile using ACoA identifier (for Ghost Genius profiles)
+     */
+    storeCompleteLinkedInProfileByAcoa(linkedinIdentifierAcoa: string, profileData: any, userId?: number, userWasCreated?: boolean): Promise<import("./db-types").CompleteLinkedInProfileResult>;
+    updateLinkedInAccountAcoaIdentifierByForagerId(foragerId: number, linkedinIdentifierAcoa: string): Promise<import("../utils/forager-linkedin-operations").LinkedInAccountResult>;
+    updateLinkedInAccountAcoaIdentifierByForagerIdWithChangeDetection(foragerId: number, linkedinIdentifierAcoa: string): Promise<{
+        account: import("../utils/forager-linkedin-operations").LinkedInAccountResult;
+        wasChanged: boolean;
+        oldValue: string | null;
+    }>;
+    updateLinkedInAccountProfilePictureUrl(linkedinAccountId: number, profilePictureUrl: string, profileImageHash?: string): Promise<any>;
+    getLinkedInAccountProfileImageHash(linkedinAccountId: number): Promise<string | null>;
+    refreshCompleteLinkedInProfileByForagerId(foragerId: number, profileData: any, userId?: number): Promise<import("./db-types").CompleteLinkedInProfileResult>;
+    findAuthenticatedUserByForagerId(foragerId: number): Promise<{
+        user_id: number;
+        linkedin_account_id: number;
+        cognito_user_id: string;
+    } | null>;
+    findAuthenticatedUserByPublicIdentifier(publicIdentifier: string): Promise<{
+        user_id: number;
+        linkedin_account_id: number;
+        cognito_user_id: string;
+    } | null>;
+    findAuthenticatedUserByAnyIdentifier(identifier: string | number): Promise<{
+        user_id: number;
+        linkedin_account_id: number;
+        cognito_user_id: string;
+    } | null>;
+    handleLinkedInProfileFetchByForagerId(foragerId: number, publicIdentifier: string, profileData: any, linkedinIdentifierAcoa?: string, providerAccountId?: string): Promise<import("./db-types").ProfileFetchResult>;
+    getMostRecentWorkExperience(linkedinAccountId: number): Promise<any>;
+    getOrganizationMembershipsForUser(userId: number): Promise<import("../utils/organization-operations").OrganizationMembershipWithDetails[]>;
+    getOrganizationById(organizationId: number): Promise<import("../utils/organization-operations").Organization | null>;
+    findOrganizationByLinkedInCompanyId(linkedinCompanyId: number): Promise<import("../utils/organization-operations").Organization | null>;
+    findOrganizationByLinkedInPublicIdentifier(linkedinPublicIdentifier: string): Promise<import("../utils/organization-operations").Organization | null>;
+    findOrganizationByDedupKey(dedupKey: string): Promise<import("../utils/organization-operations").Organization | null>;
+    updateOrganizationLinkedInPublicIdentifier(organizationId: number, linkedinPublicIdentifier: string): Promise<boolean>;
+    createCompanyMappingJob(options: {
+        sourceType: "forager_api" | "sheet_upload";
+        linkedinPublicIdentifier?: string | null;
+        metadata?: Record<string, any>;
+    }): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob>;
+    updateCompanyMappingJobLinkedInId(companyMappingJobId: number, linkedinCompanyId: number): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    updateCompanyMappingJobS3Path(companyMappingJobId: number, s3FilePath: string): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    updateCompanyMappingJobQueued(companyMappingJobId: number, employeesCount?: number): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    updateCompanyMappingJobStarted(companyMappingJobId: number): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    updateCompanyMappingJobCompleted(companyMappingJobId: number, employeesCount?: number): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    getCompanyMappingJobById(companyMappingJobId: number): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    updateCompanyMappingJobOrganizationId(companyMappingJobId: number, organizationId: number): Promise<import("../utils/company-mapping-job-operations").CompanyMappingJob | null>;
+    createRecursiveMappingJob(options: {
+        originalMappingJobId: number;
+        organizationId?: number | null;
+        metadata?: Record<string, any>;
+    }): Promise<import("../utils/recursive-mapping-job-operations").RecursiveMappingJob>;
+    getRecursiveMappingJobById(recursiveMappingJobId: number): Promise<import("../utils/recursive-mapping-job-operations").RecursiveMappingJob | null>;
+    updateRecursiveMappingJobStarted(recursiveMappingJobId: number): Promise<import("../utils/recursive-mapping-job-operations").RecursiveMappingJob>;
+    updateRecursiveMappingJobCompleted(recursiveMappingJobId: number, downstreamJobsCount: number): Promise<import("../utils/recursive-mapping-job-operations").RecursiveMappingJob>;
+    updateOrganizationSubscriptionTier(organizationId: number, subscriptionTier: "PRO_VERSION" | "WAITING_FOR_SUBSCRIPTION_SELECTION"): Promise<import("../utils/organization-operations").Organization | null>;
+    upsertSubscription(subscriptionData: {
+        organizationId: number;
+        stripeCustomerId: string;
+        stripeSubscriptionId: string;
+        stripePriceId: string;
+        status: string;
+        currentPeriodStart: Date;
+        currentPeriodEnd: Date;
+        trialStart?: Date | null;
+        trialEnd?: Date | null;
+        canceledAt?: Date | null;
+        metadata?: Record<string, any>;
+    }): Promise<import("../utils/subscription-operations").Subscription>;
+    getSubscriptionByStripeId(stripeSubscriptionId: string): Promise<import("../utils/subscription-operations").Subscription | null>;
+    getSubscriptionByOrganizationId(organizationId: number): Promise<import("../utils/subscription-operations").Subscription | null>;
+    hasOrganizationUsedFreeTrial(organizationId: number): Promise<boolean>;
+    hasUserUsedFreeTrial(userId: number): Promise<boolean>;
+    isStripeEventProcessed(stripeEventId: string): Promise<boolean>;
+    updateSubscription(stripeSubscriptionId: string, updateData: {
+        status?: string;
+        currentPeriodStart?: Date;
+        currentPeriodEnd?: Date;
+        trialStart?: Date | null;
+        trialEnd?: Date | null;
+        canceledAt?: Date | null;
+        metadata?: Record<string, any>;
+    }): Promise<import("../utils/subscription-operations").Subscription | null>;
+    getOrganizationMembers(organizationId: number): Promise<import("../utils/organization-operations").OrganizationMember[]>;
+    getOrganizationContributors(organizationId: number, limit?: number, offset?: number): Promise<import("../utils/organization-operations").OrganizationMember[]>;
+    getOrganizationContributorsCount(organizationId: number): Promise<number>;
+    getOrganizationMembersCount(organizationId: number, contributionRole?: "CONTRIBUTOR" | "VISITOR"): Promise<number>;
+    getOrganizationMembershipForUser(userId: number, organizationId: number): Promise<import("../utils/organization-operations").OrganizationMember | null>;
+    /**
+     * Get organization member by ID
+     */
+    getOrganizationMemberById(memberId: number): Promise<import("../utils/organization-operations").OrganizationMember | null>;
+    getOrganizationContributorByUserId(organizationId: number, userId: number): Promise<import("../utils/organization-operations").OrganizationMember | null>;
+    findContributorPage(organizationId: number, userId: number, limit?: number): Promise<number | null>;
+    updateOrganizationMemberRole(userId: number, organizationId: number, params: {
+        contributionRole?: "VISITOR" | "CONTRIBUTOR";
+        permissionsRole?: "REGULAR" | "ADMIN";
+    }): Promise<import("../utils/organization-operations").OrganizationMember | null>;
+    getOrganizationMemberRelationships(organizationId: number, linkedinAccountId: number, limit?: number): Promise<import("../utils/organization-operations").LinkedinRelationship[]>;
+    getOrganizationMemberRelationshipsCount(organizationId: number, linkedinAccountId: number): Promise<number>;
+    createOrganization(organizationData: {
+        name: string;
+        workspaceType: "INDIVIDUALS" | "BUSINESS";
+        subscriptionTier: "PRO_VERSION" | "WAITING_FOR_SUBSCRIPTION_SELECTION";
+        createdByUserId?: number | null;
+        imageUrl?: string | null;
+    }): Promise<import("../utils/organization-operations").Organization>;
+    findOrCreateOrganizationMember(membershipData: {
+        organizationId: number;
+        userId: number;
+        contributionRole: "VISITOR" | "CONTRIBUTOR";
+        permissionsRole: "ADMIN" | "REGULAR";
+    }): Promise<import("../utils/organization-operations").OrganizationMember>;
+    findPersonalWorkspaceForUser(userId: number): Promise<import("../utils/organization-operations").Organization | null>;
+    findOrCreateOrganizationMemberLegacy(params: {
+        organizationId: number;
+        userId: number;
+        contributionRole: "VISITOR" | "CONTRIBUTOR";
+        permissionsRole: "REGULAR" | "ADMIN";
+    }): Promise<any>;
+    createOrganizationUserRelationshipAssignment(params: {
+        organizationId: number;
+        linkedinRelationshipId: number;
+    }): Promise<any>;
+    /**
+     * Bulk create organization user relationship assignments
+     * This is more efficient and atomic than individual inserts
+     *
+     * @param params - Parameters for bulk creation
+     * @returns Object with counts of created and skipped assignments
+     */
+    bulkCreateOrganizationUserRelationshipAssignments(params: {
+        organizationId: number;
+        linkedinRelationshipIds: number[];
+    }): Promise<{
+        created: number;
+        skipped: number;
+    }>;
+    deleteOrganizationUserRelationshipAssignmentsByLinkedInAccount(params: {
+        organizationId: number;
+        linkedinAccountId: number;
+    }): Promise<number>;
+    /**
+     * Get organization relationship assignment by ID
+     * @param assignmentId - Organization relationship assignment ID
+     * @returns Assignment data or null if not found
+     */
+    getOrganizationRelationshipAssignmentById(assignmentId: number): Promise<{
+        id: number;
+        organizationId: number;
+        linkedinRelationshipId: number;
+        organizationMemberId: number | null;
+        createdAt: Date;
+    } | null>;
+    /**
+     * Find organization member for a relationship
+     * @param organizationId - Organization ID
+     * @param linkedinRelationshipId - LinkedIn relationship ID
+     * @returns Organization member ID or null if not found
+     */
+    findOrganizationMemberForRelationship(organizationId: number, linkedinRelationshipId: number): Promise<{
+        id: number;
+    } | null>;
+    /**
+     * Delete all relationship assignments for an organization member
+     * Uses organization_member_id for faster, more accurate lookups
+     * @param organizationMemberId - Organization member ID
+     * @param client - Optional transaction client (if provided, uses it instead of getting new connection)
+     */
+    deleteAssignmentsByOrganizationMember(organizationMemberId: number, client?: any): Promise<number>;
+    /**
+     * Bulk insert relationship assignments for an organization member
+     * Uses organization_member_id for faster, more accurate lookups
+     * @param params - Parameters for bulk insert
+     * @param client - Optional transaction client (if provided, uses it instead of getting new connection)
+     */
+    bulkInsertAssignmentsForOrganizationMember(params: {
+        organizationId: number;
+        organizationMemberId: number;
+        relationshipIds: number[];
+    }, client?: any): Promise<{
+        created: number;
+        skipped: number;
+        failed: number;
+        failedRelationshipIds: number[];
+        failedErrors: string[];
+    }>;
+    /**
+     * Verify relationship assignments for an organization member after commit
+     * Uses organization_member_id for faster, more accurate lookups
+     */
+    verifyAssignmentsForOrganizationMember(params: {
+        organizationId: number;
+        organizationMemberId: number;
+        mappingJobId: number;
+        userLinkedinAccountId: number;
+    }): Promise<number>;
+    findOrCreatePersonalWorkspace(params: {
+        userId: number;
+        workspaceName?: string;
+    }): Promise<any>;
+    /**
+     * Get user's personal workspace by finding the organization they are a member of with workspace_type INDIVIDUALS
+     * Every authenticated user should have exactly one personal workspace
+     * @param userId - The user's ID
+     * @returns The personal workspace organization or null if not found
+     */
+    getUserPersonalWorkspace(userId: number): Promise<any>;
+    getUserById(userId: number): Promise<import("./schema").User | null>;
+    getLatestCompletedMappingJobForUser(userId: number): Promise<import("./schema").MappingJob | null>;
+    getLatestCompletedMappingJobForLinkedInAccount(linkedinAccountId: number): Promise<import("./schema").MappingJob | null | undefined>;
+    getRelationshipsForMappingJob(jobId: number, maxCount?: number): Promise<import("./schema").LinkedinRelationship[]>;
+    getAllRelationshipsForMappingJob(jobId: number, maxCount?: number | null): Promise<import("./schema").LinkedinRelationship[]>;
+    getRelationshipCountForMappingJob(jobId: number): Promise<number>;
+    getLinkedInAccountByUserId(userId: number): Promise<import("./schema").LinkedinAccount | null>;
+    getUserByLinkedInAccountId(linkedinAccountId: number): Promise<import("./schema").User | null>;
+    getLinkedInAccountWithUserByForagerId(foragerId: number): Promise<import("../utils/forager-linkedin-operations").LinkedInAccountWithUser | null>;
+    getLlmInferenceJobStatusForContributor(params: {
+        userId: number;
+        organizationId: number;
+    }): Promise<{
+        status: "pending" | "completed" | "not_found";
+        llmInferenceJobId: number | null;
+        mappingJobId: number | null;
+        createdAt: Date | null;
+        startedAt: Date | null;
+        completedAt: Date | null;
+    } | null>;
+    getLlmInferenceJobStatusForMappingJob(mappingJobId: number): Promise<{
+        status: "pending" | "completed" | "not_found";
+        llmInferenceJobId: number | null;
+        mappingJobId: number | null;
+        createdAt: Date | null;
+        startedAt: Date | null;
+        completedAt: Date | null;
+    } | null>;
+    getAllLlmInferenceJobStatusesForOrganization(organizationId: number): Promise<Record<number, {
+        status: "pending" | "completed" | "not_found";
+        llmInferenceJobId: number | null;
+        mappingJobId: number | null;
+        createdAt: Date | null;
+        startedAt: Date | null;
+        completedAt: Date | null;
+    }>>;
+    getLinkedInAccountById(linkedinAccountId: number): Promise<import("./schema").LinkedinAccount | null>;
+    /**
+     * Get all industries for a user
+     * @param userId - User ID
+     * @returns Array of industry names (lowercase)
+     */
+    getUserIndustries(userId: number): Promise<string[]>;
+    /**
+     * Get industries for multiple users (batch query - optimized)
+     * @param userIds - Array of user IDs
+     * @returns Map of userId -> industry names array
+     */
+    getBatchUserIndustries(userIds: number[]): Promise<Map<number, string[]>>;
+    /**
+     * Find or create an industry by name (always lowercase)
+     * @param industryName - Industry name
+     * @returns Industry ID
+     */
+    findOrCreateIndustry(industryName: string): Promise<number>;
+    /**
+     * Set industries for a user (replaces existing)
+     * @param userId - User ID
+     * @param industryNames - Array of industry names
+     */
+    setUserIndustries(userId: number, industryNames: string[]): Promise<void>;
+    /**
+     * Add industries to a user (keeps existing)
+     * @param userId - User ID
+     * @param industryNames - Array of industry names to add
+     */
+    addUserIndustries(userId: number, industryNames: string[]): Promise<void>;
+    /**
+     * Remove specific industries from a user
+     * @param userId - User ID
+     * @param industryNames - Array of industry names to remove
+     */
+    removeUserIndustries(userId: number, industryNames: string[]): Promise<void>;
+    /**
+     * Remove all industries from a user
+     * @param userId - User ID
+     */
+    clearUserIndustries(userId: number): Promise<void>;
+    /**
+     * Check if a user has a specific industry
+     * @param userId - User ID
+     * @param industryName - Industry name to check
+     * @returns True if user has the industry
+     */
+    userHasIndustry(userId: number, industryName: string): Promise<boolean>;
+    /**
+     * Get all unique industries in the system
+     * @param limit - Optional limit (default: 1000)
+     * @returns Array of industry names
+     */
+    getAllIndustries(limit?: number): Promise<string[]>;
+    /**
+     * Search industries by partial name match
+     * @param searchTerm - Search term (case-insensitive)
+     * @param limit - Optional limit (default: 20)
+     * @returns Array of matching industry names
+     */
+    searchIndustries(searchTerm: string, limit?: number): Promise<string[]>;
+    createInvitation(email: string, invitedByUserId: number, shadowUserId: number, organizationId: number, invitationMessage?: string, invitedUserPermissionsRole?: "ADMIN" | "REGULAR", expiresInDays?: number): Promise<import("../utils/invitation-operations").InvitationDetails>;
+    validateInvitationToken(token: string): Promise<import("../utils/invitation-operations").ValidateTokenResult>;
+    validateInvitationEligibility(email: string): Promise<{
+        eligible: boolean;
+        reason?: "active_invitation" | "email_registered" | "email_reserved";
+    }>;
+    markInvitationAsUsed(token: string): Promise<import("../utils/invitation-operations").InvitationDetails | null>;
+    revokeInvitation(invitationId: number): Promise<import("../utils/invitation-operations").InvitationDetails | null>;
+    getInvitationById(invitationId: number): Promise<import("../utils/invitation-operations").InvitationWithDetails | null>;
+    getInvitationsSentByUser(invitedByUserId: number): Promise<import("../utils/invitation-operations").InvitationWithDetails[]>;
+    getPendingInvitationsByOrganization(organizationId: number): Promise<import("../utils/invitation-operations").InvitationWithDetails[]>;
+    getAllInvitationsByOrganization(organizationId: number): Promise<import("../utils/invitation-operations").InvitationWithDetails[]>;
+    hasPendingInvitation(email: string, organizationId: number): Promise<boolean>;
+    hasActiveInvitationByEmail(email: string): Promise<boolean>;
+    hasActiveInvitationByEmailForOrg(email: string, organizationId: number): Promise<boolean>;
+    isEmailUsedByAuthenticatedUser(email: string): Promise<boolean>;
+    isEmailReservedByContactInfo(email: string): Promise<boolean>;
+    cleanupExpiredInvitations(olderThanDays?: number): Promise<number>;
+    createIntroductionRequest(params: Parameters<typeof createIntroductionRequest>[1]): Promise<import("../utils/introduction-request-operations").IntroductionRequest>;
+    getIntroductionRequestsByUser(userId: number, limit?: number): Promise<import("../utils/introduction-request-operations").IntroductionRequest[]>;
+    getIntroductionRequestById(requestId: number): Promise<import("../utils/introduction-request-operations").IntroductionRequest | null>;
+    hasExistingIntroductionRequest(byUserId: number, toRelationshipId: number): Promise<boolean>;
+    updateIntroductionRequestStatus(requestId: number, status: "pending" | "approved" | "rejected"): Promise<import("../utils/introduction-request-operations").IntroductionRequest>;
+    markIntroductionRequestAsSeen(requestId: number): Promise<import("../utils/introduction-request-operations").IntroductionRequest>;
+    getReceivedIntroductionRequests(userId: number, organizationId: number): Promise<import("../utils/introduction-request-operations").DetailedIntroductionRequest[]>;
+    getSentIntroductionRequests(userId: number, organizationId: number): Promise<import("../utils/introduction-request-operations").DetailedIntroductionRequest[]>;
+    markReceivedIntroductionRequestsAsSeen(userId: number, organizationId: number): Promise<number>;
+    createUser(params: {
+        givenName: string;
+        familyName: string;
+    }): Promise<any>;
+    createAuthenticatedUser(params: {
+        userId?: number;
+        cognitoUserId: string;
+        contactInfoId?: number;
+        authProvider?: string;
+    }): Promise<import("./schema").AuthenticatedUser>;
+    createCompanySheetUpload(data: {
+        s3FilePath: string;
+        bucketName: string;
+        fileName?: string | null;
+        peopleCount?: number | null;
+        metadata?: Record<string, any>;
+    }): Promise<import("../utils/company-sheet-upload-operations").CompanySheetUpload>;
+    getCompanySheetUploadById(sheetUploadId: number): Promise<import("../utils/company-sheet-upload-operations").CompanySheetUpload | null>;
+    updateCompanySheetUploadJobId(sheetUploadId: number, companyMappingJobId: number): Promise<import("../utils/company-sheet-upload-operations").CompanySheetUpload | null>;
+}
+export declare const dbService: DatabaseService;
+export { DatabaseService };
+//# sourceMappingURL=database-service.d.ts.map