linkedin-secret-sauce 0.12.4 → 0.13.0

package/dist/enrichment/providers/hunter.js

@@ -148,7 +148,8 @@ function createHunterProvider(config) {
             }
             return null;
         }
-        catch {
+        catch (err) {
+            console.error("[Hunter] Email lookup failed:", err instanceof Error ? err.message : err);
             return null;
         }
     }

package/dist/enrichment/providers/ldd.js

@@ -52,7 +52,8 @@ function createLddProvider(config) {
             const response = await (0, http_retry_1.getWithRetry)(endpoint, { Authorization: `Bearer ${apiToken}` }, { retries: 1, backoffMs: 100 });
             return parseResponse(response);
         }
-        catch {
+        catch (err) {
+            console.error("[LDD] Lookup by numeric ID failed:", err instanceof Error ? err.message : err);
             return null;
         }
     }
@@ -62,7 +63,8 @@ function createLddProvider(config) {
             const response = await (0, http_retry_1.getWithRetry)(endpoint, { Authorization: `Bearer ${apiToken}` }, { retries: 1, backoffMs: 100 });
             return parseResponse(response);
         }
-        catch {
+        catch (err) {
+            console.error("[LDD] Lookup by username failed:", err instanceof Error ? err.message : err);
             return null;
         }
     }

package/dist/enrichment/providers/smartprospect.d.ts

@@ -27,8 +27,11 @@ export interface SmartProspectLocationOptions {
 export interface SmartProspectClient {
     /** Search for contacts (FREE - no credits used) */
     search: (filters: SmartProspectSearchFilters) => Promise<SmartProspectSearchResponse>;
-    /** Fetch/enrich emails for specific contact IDs (COSTS CREDITS) */
-    fetch: (contactIds: string[]) => Promise<SmartProspectFetchResponse>;
+    /** Fetch/enrich emails for specific contact IDs (COSTS CREDITS)
+     * @param contactIds - Array of contact IDs to fetch
+     * @param searchFilterId - Filter ID from the search response (required by API)
+     */
+    fetch: (contactIds: string[], searchFilterId?: number) => Promise<SmartProspectFetchResponse>;
     /** Search and immediately fetch all results (COSTS CREDITS for fetched contacts) */
     searchAndFetch: (filters: SmartProspectSearchFilters) => Promise<{
         searchResponse: SmartProspectSearchResponse;

package/dist/enrichment/providers/smartprospect.js

@@ -22,10 +22,10 @@ const candidate_parser_1 = require("../utils/candidate-parser");
 const noop_provider_1 = require("../utils/noop-provider");
 const DEFAULT_API_URL = "https://prospect-api.smartlead.ai/api/search-email-leads";
 const DEFAULT_POLLING_CONFIG = {
-    initialDelay: 500,
-    pollInterval: 1000,
-    maxAttempts: 10,
-    maxWaitTime: 15000,
+    initialDelay: 1000,
+    pollInterval: 2000,
+    maxAttempts: 45,
+    maxWaitTime: 90000,
 };
 /**
  * HTTP request with retry on 429 rate limit
@@ -37,12 +37,15 @@ async function requestWithRetry(url, options, retries = 2, backoffMs = 300) {
             const res = await fetch(url, options);
             // Retry on rate limit
             if (res.status === 429 && i < retries) {
+                console.error("[SmartProspect] Rate limited, retrying...");
                 await (0, http_retry_1.delay)(backoffMs * Math.pow(2, i));
                 continue;
             }
             if (!res.ok) {
                 const errorText = await res.text().catch(() => "");
-                throw new Error(`SmartProspect API error: ${res.status} - ${errorText}`);
+                const error = new Error(`SmartProspect API error: ${res.status} - ${errorText}`);
+                console.error("[SmartProspect] API error:", error.message);
+                throw error;
             }
             return (await res.json());
         }
@@ -54,6 +57,7 @@ async function requestWithRetry(url, options, retries = 2, backoffMs = 300) {
             }
         }
     }
+    console.error("[SmartProspect] Request failed after retries:", lastErr instanceof Error ? lastErr.message : lastErr);
     throw lastErr ?? new Error("smartprospect_http_error");
 }
 /**
@@ -155,7 +159,7 @@ function createSmartProspectProvider(config) {
                 },
                 body: JSON.stringify({
                     ...filters,
-                    dontDisplayOwnedContact: filters.dontDisplayOwnedContact ?? true,
+                    dontDisplayOwnedContact: filters.dontDisplayOwnedContact ?? false,
                     limit: filters.limit ?? 10,
                     titleExactMatch: filters.titleExactMatch ?? false,
                 }),
@@ -264,9 +268,20 @@ function createSmartProspectProvider(config) {
      * 1. Call fetch-contacts (returns immediately with status: "pending")
      * 2. Poll get-contacts until completed
      * 3. Return enriched contacts with emails
+     *
+     * @param contactIds - Array of contact IDs to fetch
+     * @param searchFilterId - Filter ID from the search response (required by API)
      */
-    async function fetchContacts(contactIds) {
+    async function fetchContacts(contactIds, searchFilterId) {
         const makeFetchRequest = async (token) => {
+            // API expects: { filter_id, limit, visual_limit, id: [...] }
+            // filter_id comes from search response and is required for polling
+            const fetchPayload = {
+                filter_id: searchFilterId,
+                limit: contactIds.length,
+                visual_limit: contactIds.length,
+                id: contactIds,
+            };
             return requestWithRetry(`${apiUrl}/fetch-contacts`, {
                 method: "POST",
                 headers: {
@@ -274,17 +289,17 @@ function createSmartProspectProvider(config) {
                     "Content-Type": "application/json",
                     Accept: "application/json",
                 },
-                body: JSON.stringify({ contactIds }),
+                body: JSON.stringify(fetchPayload),
             });
         };
         try {
             const token = await getAuthToken();
             const fetchResult = await makeFetchRequest(token);
-            // If fetch-contacts returns pending status with filter_id, poll for results
-            const filterId = fetchResult.data?.filter_id;
+            // If fetch-contacts returns pending status, poll for results using the filter_id we sent
             const status = fetchResult.data?.status;
-            if (filterId && status === "pending") {
-                const pollResult = await pollForContactResults(filterId, contactIds.length);
+            // Use the searchFilterId we passed in (from search response), not from fetch response
+            if (searchFilterId && status === "pending") {
+                const pollResult = await pollForContactResults(searchFilterId, contactIds.length);
                 if (pollResult.success && pollResult.data.list.length > 0) {
                     return {
                         success: true,
@@ -296,7 +311,7 @@ function createSmartProspectProvider(config) {
                             leads_found: pollResult.data.metrics.totalContacts,
                             email_fetched: pollResult.data.metrics.totalEmails,
                             verification_status_list: [],
-                            filter_id: filterId,
+                            filter_id: String(searchFilterId),
                             status: "completed",
                         },
                     };
@@ -394,7 +409,8 @@ function createSmartProspectProvider(config) {
         // Step 2: Fetch emails for ALL matching contacts (COSTS CREDITS)
         // Note: This costs more credits but gives us all available emails
         const contactIds = scoredMatches.map((m) => m.contact.id);
-        const fetchResult = await fetchContacts(contactIds);
+        const searchFilterId = searchResult.data.filter_id;
+        const fetchResult = await fetchContacts(contactIds, searchFilterId);
         if (!fetchResult.success || fetchResult.data.list.length === 0) {
             return null;
         }
@@ -549,7 +565,7 @@ function createSmartProspectClient(config) {
         if (filters.city?.length)
             payload.city = filters.city;
         // Workflow options
-        payload.dontDisplayOwnedContact = filters.dontDisplayOwnedContact ?? true;
+        payload.dontDisplayOwnedContact = filters.dontDisplayOwnedContact ?? false;
         // Pagination
         payload.limit = filters.limit ?? 25;
         if (filters.scroll_id)
@@ -628,11 +644,18 @@ function createSmartProspectClient(config) {
                 const token = await getAuthToken();
                 const result = await makeRequest(token);
                 if (result.success && result.data.metrics) {
-                    const { completed, totalContacts } = result.data.metrics;
-                    // Check if all contacts have been processed
-                    if (completed >= totalContacts || completed >= expectedCount) {
+                    const { completed, totalContacts, totalEmails } = result.data.metrics;
+                    const contact = result.data.list[0];
+                    const email = contact?.email;
+                    console.log(`[SmartProspect] poll ${attempt + 1}/${maxAttempts}: completed=${completed}/${totalContacts}, emails=${totalEmails}, email=${email || "(none)"}`);
+                    // Check if all contacts have been processed AND we have an email
+                    if ((completed >= totalContacts || completed >= expectedCount) &&
+                        email) {
                         return result;
                     }
+                    // NOTE: Don't exit early on noEmailFound - it may be a temporary state
+                    // The API sometimes reports noEmailFound before the email is ready
+                    // Keep polling until we get an email or hit the timeout
                 }
                 // Wait before next poll
                 await (0, http_retry_1.delay)(pollInterval);
@@ -680,8 +703,11 @@ function createSmartProspectClient(config) {
      * 1. Call fetch-contacts to initiate lookup (returns immediately with status: "pending")
      * 2. Poll get-contacts until metrics.completed >= expected count
      * 3. Return the final enriched contacts with emails
+     *
+     * @param contactIds - Array of contact IDs to fetch
+     * @param searchFilterId - Filter ID from the search response (required by API)
      */
-    async function fetch(contactIds) {
+    async function fetch(contactIds, searchFilterId) {
         if (!contactIds.length) {
             return {
                 success: true,
@@ -705,6 +731,13 @@ function createSmartProspectClient(config) {
             };
         }
         const makeFetchRequest = async (token) => {
+            // API expects: { filter_id, limit, visual_limit, id: [...] }
+            const fetchPayload = {
+                filter_id: searchFilterId,
+                limit: contactIds.length,
+                visual_limit: contactIds.length,
+                id: contactIds,
+            };
             return requestWithRetry(`${apiUrl}/fetch-contacts`, {
                 method: "POST",
                 headers: {
@@ -712,18 +745,21 @@ function createSmartProspectClient(config) {
                     "Content-Type": "application/json",
                     Accept: "application/json",
                 },
-                body: JSON.stringify({ contactIds }),
+                body: JSON.stringify(fetchPayload),
             });
         };
         try {
             const token = await getAuthToken();
             const fetchResult = await makeFetchRequest(token);
-            // If fetch-contacts returns a filter_id with pending status, we need to poll
-            const filterId = fetchResult.data?.filter_id;
-            const status = fetchResult.data?.status;
-            if (filterId && status === "pending") {
+            // If fetch-contacts returns pending status OR no email found, poll for results
+            // Note: status can be in data.status OR data.list[0].status depending on API response
+            const status = fetchResult.data?.status || fetchResult.data?.list?.[0]?.status;
+            const hasEmail = fetchResult.data?.list?.[0]?.email;
+            // Use the searchFilterId we passed in (from search response), not from fetch response
+            // Poll if: status is pending, OR we have a filter_id but no email yet
+            if (searchFilterId && (status === "pending" || !hasEmail)) {
                 // Poll get-contacts for final results
-                const pollResult = await pollForResults(filterId, contactIds.length);
+                const pollResult = await pollForResults(searchFilterId, contactIds.length);
                 if (pollResult.success && pollResult.data.list.length > 0) {
                     // Convert poll result to fetch response format
                     return {
@@ -736,7 +772,7 @@ function createSmartProspectClient(config) {
                             leads_found: pollResult.data.metrics.totalContacts,
                             email_fetched: pollResult.data.metrics.totalEmails,
                             verification_status_list: [],
-                            filter_id: filterId,
+                            filter_id: String(searchFilterId),
                             status: "completed",
                         },
                     };
@@ -793,7 +829,8 @@ function createSmartProspectClient(config) {
             };
         }
         const contactIds = searchResponse.data.list.map((c) => c.id);
-        const fetchResponse = await fetch(contactIds);
+        const searchFilterId = searchResponse.data.filter_id;
+        const fetchResponse = await fetch(contactIds, searchFilterId);
         return {
             searchResponse,
             fetchResponse,

package/dist/enrichment/providers/snovio.js

@@ -97,7 +97,8 @@ async function getAccessToken(clientId, clientSecret, apiUrl, timeoutMs) {
         tokenExpiresAt = Date.now() + (data.expires_in - 300) * 1000;
         return data.access_token;
     }
-    catch {
+    catch (err) {
+        console.error("[Snov.io] Failed to get access token:", err instanceof Error ? err.message : err);
         return null;
     }
     finally {
@@ -136,8 +137,10 @@ async function findEmailsByName(firstName, lastName, domain, accessToken, apiUrl
     }
     catch (error) {
         if (error instanceof Error && error.name === "AbortError") {
-            return null; // Timeout
+            console.error("[Snov.io] Request timed out");
+            return null;
         }
+        console.error("[Snov.io] Email lookup failed:", error instanceof Error ? error.message : error);
         throw error;
     }
     finally {
@@ -268,7 +271,8 @@ async function verifyEmailWithSnovio(email, config) {
             status: result.result,
         };
     }
-    catch {
+    catch (err) {
+        console.error("[Snov.io] Email verification failed:", err instanceof Error ? err.message : err);
         return null;
     }
     finally {

package/dist/enrichment/providers/trykitt.d.ts

@@ -11,8 +11,8 @@
  * - 2-5x faster than traditional SMTP verification
  *
  * API Endpoints:
- * - POST /job/find-email - Find email by name + domain
- * - POST /job/verify-email - Verify existing email
+ * - POST /job/find_email - Find email by name + domain
+ * - POST /job/verify_email - Verify existing email
  *
  * Rate Limits (Free tier):
  * - 2 requests/second

package/dist/enrichment/providers/trykitt.js

@@ -12,8 +12,8 @@
  * - 2-5x faster than traditional SMTP verification
  *
  * API Endpoints:
- * - POST /job/find-email - Find email by name + domain
- * - POST /job/verify-email - Verify existing email
+ * - POST /job/find_email - Find email by name + domain
+ * - POST /job/verify_email - Verify existing email
  *
  * Rate Limits (Free tier):
  * - 2 requests/second
@@ -31,6 +31,58 @@ const candidate_parser_1 = require("../utils/candidate-parser");
 const noop_provider_1 = require("../utils/noop-provider");
 const DEFAULT_API_URL = "https://api.trykitt.ai";
 const DEFAULT_TIMEOUT_MS = 30000;
+const JOB_POLL_INTERVAL_MS = 1000;
+const JOB_MAX_POLLS = 30; // Max 30 seconds waiting
+/**
+ * Poll for job completion
+ */
+async function pollJobResult(apiUrl, apiKey, jobId, timeoutMs) {
+    for (let i = 0; i < JOB_MAX_POLLS; i++) {
+        try {
+            const response = await (0, http_retry_1.getWithRetry)(`${apiUrl}/job?id=${jobId}`, {
+                "x-api-key": apiKey,
+            }, {
+                retries: 1,
+                backoffMs: 500,
+                timeoutMs,
+            });
+            // API returns an array - get first element
+            const jobData = Array.isArray(response)
+                ? response[0]
+                : response;
+            if (!jobData) {
+                return null;
+            }
+            const jobObj = jobData;
+            const results = jobObj.results;
+            if (jobObj.status === "completed") {
+                // Return in expected format, mapping 'results' to 'result'
+                return {
+                    status: jobObj.status,
+                    result: results
+                        ? {
+                            email: results.email !== "no-results-found"
+                                ? results.email
+                                : null,
+                            confidence: results.confidence,
+                            confidence_score: results.confidence_score,
+                        }
+                        : null,
+                };
+            }
+            if (jobObj.status === "failed" || jobObj.status === "error") {
+                return null;
+            }
+            // Wait before next poll
+            await new Promise((resolve) => setTimeout(resolve, JOB_POLL_INTERVAL_MS));
+        }
+        catch (err) {
+            console.error("[TryKitt] Poll error:", err instanceof Error ? err.message : err);
+            return null;
+        }
+    }
+    return null;
+}
 /**
  * Extract TryKitt-specific inputs from candidate using shared parser
  */
@@ -82,25 +134,32 @@ function createTryKittProvider(config) {
             return null;
         }
         try {
-            // Build request body
+            // Build request body - API expects camelCase parameters
+            // callbackType: "here" forces synchronous/realtime processing
             const body = {
-                full_name: fullName,
-                domain: domain,
+                fullName: fullName,
+                domainOrWebsite: domain,
+                callbackType: "here",
+                callbackURL: "",
             };
             // Add LinkedIn URL if available (improves accuracy)
             if (linkedinUrl) {
-                body.linkedin_url = linkedinUrl;
+                body.linkedinStandardProfileURL = linkedinUrl;
             }
-            const response = await (0, http_retry_1.postWithRetry)(`${apiUrl}/job/find-email`, body, {
-                Authorization: `Bearer ${apiKey}`,
+            const submitResponse = await (0, http_retry_1.postWithRetry)(`${apiUrl}/job/find_email`, body, {
+                "x-api-key": apiKey,
             }, {
                 retries: 2,
                 backoffMs: 500,
                 timeoutMs,
                 retryOnStatus: [429, 500, 502, 503, 504],
             });
-            // Check if job completed successfully
-            if (response.status !== "completed") {
+            if (!submitResponse.job_id) {
+                return null;
+            }
+            // Poll for job completion
+            const response = await pollJobResult(apiUrl, apiKey, submitResponse.job_id, timeoutMs);
+            if (!response) {
                 return null;
             }
             // Check if email was found
@@ -121,8 +180,8 @@ function createTryKittProvider(config) {
                 score: confidence,
             };
         }
-        catch {
-            // Silently fail - let other providers try
+        catch (err) {
+            console.error("[TryKitt] Email lookup failed:", err instanceof Error ? err.message : err);
             return null;
         }
     }
@@ -147,15 +206,19 @@ async function findEmailWithTryKitt(fullName, domain, config, linkedinUrl) {
         return null;
     }
     try {
+        // API expects camelCase parameters
+        // callbackType: "here" forces synchronous/realtime processing
         const body = {
-            full_name: fullName,
-            domain: domain,
+            fullName: fullName,
+            domainOrWebsite: domain,
+            callbackType: "here",
+            callbackURL: "",
         };
         if (linkedinUrl) {
-            body.linkedin_url = linkedinUrl;
+            body.linkedinStandardProfileURL = linkedinUrl;
         }
-        const response = await (0, http_retry_1.postWithRetry)(`${apiUrl}/job/find-email`, body, {
-            Authorization: `Bearer ${apiKey}`,
+        const response = await (0, http_retry_1.postWithRetry)(`${apiUrl}/job/find_email`, body, {
+            "x-api-key": apiKey,
         }, {
             retries: 2,
             backoffMs: 500,
@@ -163,7 +226,8 @@ async function findEmailWithTryKitt(fullName, domain, config, linkedinUrl) {
         });
         return response;
     }
-    catch {
+    catch (err) {
+        console.error("[TryKitt] findEmailWithTryKitt failed:", err instanceof Error ? err.message : err);
         return null;
     }
 }
@@ -185,8 +249,8 @@ async function verifyEmailWithTryKitt(email, config) {
         return null;
     }
     try {
-        const response = await (0, http_retry_1.postWithRetry)(`${apiUrl}/job/verify-email`, { email }, {
-            Authorization: `Bearer ${apiKey}`,
+        const response = await (0, http_retry_1.postWithRetry)(`${apiUrl}/job/verify_email`, { email }, {
+            "x-api-key": apiKey,
         }, {
             retries: 2,
             backoffMs: 500,
@@ -204,7 +268,8 @@ async function verifyEmailWithTryKitt(email, config) {
             isRoleAccount: response.result.is_role_account ?? false,
         };
     }
-    catch {
+    catch (err) {
+        console.error("[TryKitt] Email verification failed:", err instanceof Error ? err.message : err);
         return null;
     }
 }

package/dist/index.d.ts

@@ -48,7 +48,7 @@ export { initializeLinkedInClient, getConfig } from "./config";
 export type { LinkedInClientConfig } from "./config";
 export * from "./linkedin-api";
 export * from "./types";
-export type { LinkedInTenure, LinkedInPosition, LinkedInSpotlightBadge, SalesLeadSearchResult, } from "./types";
+export type { LinkedInTenure, LinkedInPosition, LinkedInSpotlightBadge, SalesLeadSearchResult, LinkedInReactionType, ReactionActor, PostReaction, PostReactionsResult, CommentAuthor, PostComment, PostCommentsResult, ProfilePost, PostHistoryResult, PostAnalytics, AnalyzedPost, ProfileAnalysisOptions, ProfileAnalysisResult, } from "./types";
 export { LinkedInClientError } from "./utils/errors";
 export * from "./cosiall-client";
 export * from "./cookie-pool";

package/dist/linkedin-api.d.ts

@@ -1,4 +1,4 @@
-import type { SalesSearchFilters, LinkedInProfile, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, SalesNavigatorProfileFull, Company } from "./types";
+import type { SalesSearchFilters, LinkedInProfile, SearchSalesResult, TypeaheadResult, SalesNavigatorProfile, SalesNavigatorProfileFull, Company, PostReactionsResult, PostCommentsResult, PostHistoryResult, ProfileAnalysisOptions, ProfileAnalysisResult } from "./types";
 /**
  * Fetches a LinkedIn profile by vanity URL (public identifier).
  * Results are cached for the configured TTL (default: 15 minutes).
@@ -81,6 +81,44 @@ export declare function searchSalesLeads(keywords: string, options?: {
     rawQuery?: string;
     sessionId?: string;
 }): Promise<SearchSalesResult>;
+/**
+ * Analyzes a LinkedIn profile's posts with engagement data (reactions and comments).
+ * This is a high-level convenience function that orchestrates multiple API calls:
+ * 1. Fetches the profile by vanity URL or URN
+ * 2. Retrieves the profile's post history
+ * 3. Fetches reactions and comments for each post
+ *
+ * @param profileIdentifier - LinkedIn vanity URL, full profile URL, or FSD profile URN
+ * @param options - Analysis options for controlling fetch behavior
+ * @returns Complete analysis result with profile, posts, engagement data, and summary statistics
+ *
+ * @example
+ * ```typescript
+ * // Analyze by vanity URL
+ * const analysis = await analyzeProfilePosts('john-doe');
+ * console.log(analysis.summary.totalReactions);
+ * console.log(analysis.summary.avgCommentsPerPost);
+ *
+ * // Analyze by full LinkedIn URL
+ * const analysis = await analyzeProfilePosts('https://www.linkedin.com/in/john-doe');
+ *
+ * // Analyze with options
+ * const analysis = await analyzeProfilePosts('john-doe', {
+ *   postsCount: 20,
+ *   reactionsPerPost: 50,
+ *   commentsPerPost: 25,
+ *   concurrency: 5,
+ * });
+ *
+ * // Access individual post engagement
+ * for (const analyzed of analysis.analyzedPosts) {
+ *   console.log(`Post: ${analyzed.post.text?.substring(0, 50)}...`);
+ *   console.log(`  Reactions: ${analyzed.reactions.totalCount}`);
+ *   console.log(`  Comments: ${analyzed.comments.totalCount}`);
+ * }
+ * ```
+ */
+export declare function analyzeProfilePosts(profileIdentifier: string, options?: ProfileAnalysisOptions): Promise<ProfileAnalysisResult>;
 export declare function getProfilesBatch(vanities: string[], concurrency?: number): Promise<(LinkedInProfile | null)[]>;
 export declare function resolveCompanyUniversalName(universalName: string): Promise<{
     companyId?: string;
@@ -167,3 +205,77 @@ export declare function getSalesNavigatorProfileFull(profileUrnOrId: string): Pr
  * ```
  */
 export declare function extractLinkedInHandle(flagshipProfileUrl: string | null | undefined): string | null;
+/**
+ * Fetches reactions (likes, celebrates, etc.) for a LinkedIn post.
+ * Uses the Voyager GraphQL API with pagination support.
+ *
+ * @param activityUrn - The activity URN (e.g., "urn:li:activity:7419061111293083648") or bare ID
+ * @param options - Pagination options
+ * @param options.start - Pagination offset (default: 0)
+ * @param options.count - Number of reactions to fetch (default: 10, max: 100)
+ * @returns PostReactionsResult with reactions array and pagination info
+ * @throws LinkedInClientError with code NOT_FOUND if post doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 reactions
+ * const reactions = await getPostReactions('urn:li:activity:7419061111293083648');
+ * console.log(reactions.totalCount); // 37
+ * console.log(reactions.reactions[0].reactionType); // "LIKE"
+ *
+ * // Paginate through all reactions
+ * const page2 = await getPostReactions('7419061111293083648', { start: 10, count: 10 });
+ * ```
+ */
+export declare function getPostReactions(activityUrn: string, options?: {
+    start?: number;
+    count?: number;
+}): Promise<PostReactionsResult>;
+/**
+ * Fetches comments for a LinkedIn post.
+ * Uses the voyagerFeedDashUpdates GraphQL API.
+ *
+ * @param activityUrn - The activity URN (e.g., "urn:li:activity:7419061111293083648") or bare ID
+ * @param options - Fetch options
+ * @param options.commentsCount - Number of comments to fetch (default: 10, max: 100)
+ * @returns PostCommentsResult with comments array
+ * @throws LinkedInClientError with code NOT_FOUND if post doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Get comments for a post
+ * const comments = await getPostComments('urn:li:activity:7419061111293083648');
+ * console.log(comments.totalCount);
+ *
+ * // Get more comments
+ * const moreComments = await getPostComments('7419061111293083648', { commentsCount: 50 });
+ * ```
+ */
+export declare function getPostComments(activityUrn: string, options?: {
+    commentsCount?: number;
+}): Promise<PostCommentsResult>;
+/**
+ * Fetches a user's post history (their published posts).
+ * Uses the Voyager profileUpdatesV2 API with pagination support.
+ *
+ * @param profileUrn - The FSD profile URN (e.g., "urn:li:fsd_profile:ABC123xyz") or bare key
+ * @param options - Pagination options
+ * @param options.start - Pagination offset (default: 0)
+ * @param options.count - Number of posts to fetch (default: 10, max: 100)
+ * @returns PostHistoryResult with posts array and pagination info
+ * @throws LinkedInClientError with code NOT_FOUND if profile doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 posts
+ * const posts = await getPostHistory('ABC123xyz');
+ * console.log(posts.posts.length);
+ *
+ * // Paginate
+ * const page2 = await getPostHistory('ABC123xyz', { start: 10, count: 10 });
+ * ```
+ */
+export declare function getPostHistory(profileUrn: string, options?: {
+    start?: number;
+    count?: number;
+}): Promise<PostHistoryResult>;