Add network sync:

  syncNetwork, pollNetwork, network.* webhooks

Author: LordOfTheVillage

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@linkedapi/node",
-  "version": "2.2.1",
+  "version": "2.3.0",
   "description": "Control your LinkedIn accounts and retrieve real-time data, all through this Node.js SDK.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/core/operation.ts

@@ -18,6 +18,7 @@ export const OPERATION_NAME = {
   sendMessage: 'sendMessage',
   syncConversation: 'syncConversation',
   syncInbox: 'syncInbox',
+  syncNetwork: 'syncNetwork',
   manageConversation: 'manageConversation',
   checkConnectionStatus: 'checkConnectionStatus',
   sendConnectionRequest: 'sendConnectionRequest',

src/index.ts

@@ -35,6 +35,7 @@ import {
   SendMessage,
   SyncConversation,
   SyncInbox,
+  SyncNetwork,
   WithdrawConnectionRequest,
 } from './operations';
 import {
@@ -49,6 +50,8 @@ import {
   TInboxPollResult,
   TLinkedApiActionErrorType,
   TLinkedApiErrorType,
+  TNetworkPollRequest,
+  TNetworkPollResult,
 } from './types';
 import type { TLinkedApiConfig } from './types/config';
 import type { TLinkedApiResponse } from './types/responses';
@@ -102,6 +105,7 @@ class LinkedApi {
     this.sendMessage = new SendMessage(this.httpClient);
     this.syncConversation = new SyncConversation(this.httpClient);
     this.syncInbox = new SyncInbox(this.httpClient);
+    this.syncNetwork = new SyncNetwork(this.httpClient);
     this.manageConversation = new ManageConversation(this.httpClient);
     this.checkConnectionStatus = new CheckConnectionStatus(this.httpClient);
     this.sendConnectionRequest = new SendConnectionRequest(this.httpClient);
@@ -138,6 +142,7 @@ class LinkedApi {
       this.sendMessage,
       this.syncConversation,
       this.syncInbox,
+      this.syncNetwork,
       this.manageConversation,
       this.checkConnectionStatus,
       this.sendConnectionRequest,
@@ -288,6 +293,27 @@ class LinkedApi {
    */
   public syncInbox: SyncInbox;
 
+  /**
+   * Enable whole-network monitoring for standard LinkedIn.
+   *
+   * This method enables background monitoring of your LinkedIn network, preparing it for future
+   * polling with {@link pollNetwork}. Once enabled, connection activity across your network is
+   * monitored: accepted connections, newly added connections, and received connection requests.
+   * This action takes no parameters and returns no data.
+   *
+   * @param params - No parameters are required
+   * @returns Promise resolving to the sync action
+   *
+   * @example
+   * ```typescript
+   * const workflow = await linkedapi.syncNetwork.execute({});
+   *
+   * await linkedapi.syncNetwork.result(workflow.workflowId);
+   * console.log("Network monitoring enabled and ready for polling");
+   * ```
+   */
+  public syncNetwork: SyncNetwork;
+
   /**
    * Manage a standard LinkedIn conversation thread.
    *
@@ -547,6 +573,53 @@ class LinkedApi {
     };
   }
 
+  /**
+   * Poll the monitored network to retrieve connection activity events.
+   *
+   * This method reads network events from the network previously enabled for monitoring via
+   * {@link syncNetwork}, using a direct HTTP request. It returns events across the whole monitored
+   * network, newest-first. You can optionally filter by `since` timestamp and event `type`.
+   *
+   * @param request - Optional filters: `since` timestamp and `type`
+   * @returns Promise resolving to a response containing the network events
+   *
+   * @example
+   * ```typescript
+   * const pollResponse = await linkedapi.pollNetwork({
+   *   type: "connectionAccepted",
+   *   since: "2025-01-01T00:00:00Z",
+   * });
+   *
+   * if (pollResponse.data) {
+   *   pollResponse.data.events.forEach((event) => {
+   *     console.log(`${event.type} ${event.personUrl} at ${event.detectedAt}`);
+   *   });
+   * } else {
+   *   console.error("Polling failed:", pollResponse.errors);
+   * }
+   * ```
+   */
+  public async pollNetwork(
+    request: TNetworkPollRequest = {},
+  ): Promise<TMappedResponse<TNetworkPollResult>> {
+    const response = await this.httpClient.post<TNetworkPollResult>('/network/poll', request);
+    if (response.success && response.result) {
+      return {
+        data: response.result,
+        errors: [],
+      };
+    }
+    return {
+      data: undefined,
+      errors: [
+        {
+          type: response.error?.type as TLinkedApiActionErrorType,
+          message: response.error?.message ?? '',
+        },
+      ],
+    };
+  }
+
   /**
    * Retrieve detailed information about a LinkedIn person profile.
    *

src/operations/index.ts

@@ -9,6 +9,7 @@ export * from './sync-conversation';
 export * from './nv-sync-conversation';
 export * from './sync-inbox';
 export * from './nv-sync-inbox';
+export * from './sync-network';
 export * from './manage-conversation';
 export * from './nv-manage-conversation';
 export * from './nv-fetch-person';

src/operations/sync-network.ts

@@ -0,0 +1,8 @@
+import { Operation, TOperationName } from '../core';
+import { VoidWorkflowMapper } from '../mappers';
+import { TSyncNetworkParams } from '../types';
+
+export class SyncNetwork extends Operation<TSyncNetworkParams, void> {
+  public override readonly operationName: TOperationName = 'syncNetwork';
+  protected override readonly mapper = new VoidWorkflowMapper<TSyncNetworkParams>('st.syncNetwork');
+}

src/types/actions/index.ts

@@ -3,6 +3,7 @@ export * from './company';
 export * from './connection';
 export * from './job';
 export * from './message';
+export * from './network';
 export * from './person';
 export * from './post';
 export * from './search-companies';

src/types/actions/network.ts

@@ -0,0 +1,26 @@
+import { TBaseActionParams } from '../params';
+
+export interface TSyncNetworkParams extends TBaseActionParams {}
+
+export interface TNetworkPollRequest {
+  since?: string;
+  type?: TNetworkEventType;
+}
+
+export interface TNetworkEvent {
+  id: string;
+  type: TNetworkEventType;
+  personUrl: string;
+  detectedAt: string;
+}
+
+export interface TNetworkPollResult {
+  events: TNetworkEvent[];
+}
+
+export const NETWORK_EVENT_TYPE = {
+  connectionAccepted: 'connectionAccepted',
+  connectionAdded: 'connectionAdded',
+  connectionRequestReceived: 'connectionRequestReceived',
+} as const;
+export type TNetworkEventType = (typeof NETWORK_EVENT_TYPE)[keyof typeof NETWORK_EVENT_TYPE];

src/types/webhooks.ts

@@ -12,6 +12,9 @@ export type TWebhookEventType =
   | 'account.deleted'
   | 'inbox.messageReceived'
   | 'inbox.messageSent'
+  | 'network.connectionAccepted'
+  | 'network.connectionAdded'
+  | 'network.connectionRequestReceived'
   | 'webhook.test';
 
 export type TWebhookDeliveryStatus = 'pending' | 'delivering' | 'success' | 'failed';
@@ -97,6 +100,18 @@ export interface TInboxMessageWebhookEvent extends TWebhookEventBase {
   };
 }
 
+export interface TNetworkWebhookEvent extends TWebhookEventBase {
+  type:
+    | 'network.connectionAccepted'
+    | 'network.connectionAdded'
+    | 'network.connectionRequestReceived';
+  data: {
+    accountId: string;
+    personUrl: string;
+    detectedAt: string;
+  };
+}
+
 export interface TWebhookTestEvent extends TWebhookEventBase {
   type: 'webhook.test';
   data: {
@@ -108,4 +123,5 @@ export type TWebhookEvent =
   | TWorkflowWebhookEvent
   | TAccountWebhookEvent
   | TInboxMessageWebhookEvent
+  | TNetworkWebhookEvent
   | TWebhookTestEvent;