linkedapi 1.3.1__tar.gz → 1.3.2__tar.gz

{linkedapi-1.3.1 → linkedapi-1.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linkedapi
-Version: 1.3.1
+Version: 1.3.2
 Summary: Official synchronous Python SDK for Linked API.
 Project-URL: Homepage, https://linkedapi.io
 Project-URL: Repository, https://github.com/Linked-API/linkedapi-python

{linkedapi-1.3.1 → linkedapi-1.3.2}/linkedapi/__init__.py

@@ -29,7 +29,7 @@ from linkedapi.mappers import (
     VoidWorkflowMapper,
 )
 from linkedapi.operations import (
-    AcceptConnectionRequest,
+    AcceptInvitation,
     CheckConnectionStatus,
     CommentOnPost,
     CreatePost,
@@ -42,7 +42,7 @@ from linkedapi.operations import (
     FetchPersonMapper,
     FetchPost,
     FetchPostMapper,
-    IgnoreConnectionRequest,
+    IgnoreInvitation,
     ManageConversation,
     NvFetchCompany,
     NvFetchCompanyMapper,
@@ -56,8 +56,8 @@ from linkedapi.operations import (
     NvSyncInbox,
     ReactToPost,
     RemoveConnection,
-    RetrieveConnectionRequests,
     RetrieveConnections,
+    RetrieveInvitations,
     RetrievePendingRequests,
     RetrievePerformance,
     RetrieveSSI,
@@ -75,12 +75,12 @@ from linkedapi.types import *  # noqa: F403
 from linkedapi.types import __all__ as _types_all
 from linkedapi.webhooks import parse_webhook_event
 
-__version__ = "1.2.1"
+__version__ = "1.3.2"
 PredefinedOperation = Operation
 
 __all__ = [
     *_types_all,
-    "AcceptConnectionRequest",
+    "AcceptInvitation",
     "AdminAccounts",
     "AdminHttpClient",
     "AdminLimits",
@@ -102,7 +102,7 @@ __all__ = [
     "FetchPost",
     "FetchPostMapper",
     "HttpClient",
-    "IgnoreConnectionRequest",
+    "IgnoreInvitation",
     "LINKED_API_ACTION_ERROR_TYPES",
     "LINKED_API_ERROR_TYPES",
     "LinkedApi",
@@ -130,7 +130,7 @@ __all__ = [
     "ReactToPost",
     "RemoveConnection",
     "ResponseMapping",
-    "RetrieveConnectionRequests",
+    "RetrieveInvitations",
     "RetrieveConnections",
     "RetrievePendingRequests",
     "RetrievePerformance",

{linkedapi-1.3.1 → linkedapi-1.3.2}/linkedapi/client.py

@@ -8,7 +8,7 @@ from linkedapi.errors import LinkedApiError
 from linkedapi.http import HttpClient, LinkedApiHttpClient
 from linkedapi.mappers import MappedResponse
 from linkedapi.operations import (
-    AcceptConnectionRequest,
+    AcceptInvitation,
     CheckConnectionStatus,
     CommentOnPost,
     CreatePost,
@@ -17,7 +17,7 @@ from linkedapi.operations import (
     FetchJob,
     FetchPerson,
     FetchPost,
-    IgnoreConnectionRequest,
+    IgnoreInvitation,
     ManageConversation,
     NvFetchCompany,
     NvFetchPerson,
@@ -29,8 +29,8 @@ from linkedapi.operations import (
     NvSyncInbox,
     ReactToPost,
     RemoveConnection,
-    RetrieveConnectionRequests,
     RetrieveConnections,
+    RetrieveInvitations,
     RetrievePendingRequests,
     RetrievePerformance,
     RetrieveSSI,
@@ -74,10 +74,10 @@ class LinkedApi:
         self.check_connection_status = CheckConnectionStatus(self.http_client)
         self.send_connection_request = SendConnectionRequest(self.http_client)
         self.withdraw_connection_request = WithdrawConnectionRequest(self.http_client)
-        self.accept_connection_request = AcceptConnectionRequest(self.http_client)
-        self.ignore_connection_request = IgnoreConnectionRequest(self.http_client)
+        self.accept_invitation = AcceptInvitation(self.http_client)
+        self.ignore_invitation = IgnoreInvitation(self.http_client)
         self.retrieve_pending_requests = RetrievePendingRequests(self.http_client)
-        self.retrieve_connection_requests = RetrieveConnectionRequests(self.http_client)
+        self.retrieve_invitations = RetrieveInvitations(self.http_client)
         self.retrieve_connections = RetrieveConnections(self.http_client)
         self.remove_connection = RemoveConnection(self.http_client)
         self.search_companies = SearchCompanies(self.http_client)
@@ -111,10 +111,10 @@ class LinkedApi:
             self.check_connection_status,
             self.send_connection_request,
             self.withdraw_connection_request,
-            self.accept_connection_request,
-            self.ignore_connection_request,
+            self.accept_invitation,
+            self.ignore_invitation,
             self.retrieve_pending_requests,
-            self.retrieve_connection_requests,
+            self.retrieve_invitations,
             self.retrieve_connections,
             self.remove_connection,
             self.search_companies,

{linkedapi-1.3.1 → linkedapi-1.3.2}/linkedapi/operations/__init__.py

@@ -1,4 +1,4 @@
-from linkedapi.operations.accept_connection_request import AcceptConnectionRequest
+from linkedapi.operations.accept_invitation import AcceptInvitation
 from linkedapi.operations.check_connection_status import CheckConnectionStatus
 from linkedapi.operations.comment_on_post import CommentOnPost
 from linkedapi.operations.create_post import CreatePost
@@ -7,7 +7,7 @@ from linkedapi.operations.fetch_company import FetchCompany, FetchCompanyMapper
 from linkedapi.operations.fetch_job import FetchJob, FetchJobMapper
 from linkedapi.operations.fetch_person import FetchPerson, FetchPersonMapper
 from linkedapi.operations.fetch_post import FetchPost, FetchPostMapper
-from linkedapi.operations.ignore_connection_request import IgnoreConnectionRequest
+from linkedapi.operations.ignore_invitation import IgnoreInvitation
 from linkedapi.operations.manage_conversation import ManageConversation
 from linkedapi.operations.nv_fetch_company import NvFetchCompany, NvFetchCompanyMapper
 from linkedapi.operations.nv_fetch_person import NvFetchPerson, NvFetchPersonMapper
@@ -19,8 +19,8 @@ from linkedapi.operations.nv_sync_conversation import NvSyncConversation
 from linkedapi.operations.nv_sync_inbox import NvSyncInbox
 from linkedapi.operations.react_to_post import ReactToPost
 from linkedapi.operations.remove_connection import RemoveConnection
-from linkedapi.operations.retrieve_connection_requests import RetrieveConnectionRequests
 from linkedapi.operations.retrieve_connections import RetrieveConnections
+from linkedapi.operations.retrieve_invitations import RetrieveInvitations
 from linkedapi.operations.retrieve_pending_requests import RetrievePendingRequests
 from linkedapi.operations.retrieve_performance import RetrievePerformance
 from linkedapi.operations.retrieve_ssi import RetrieveSSI
@@ -35,7 +35,7 @@ from linkedapi.operations.sync_network import SyncNetwork
 from linkedapi.operations.withdraw_connection_request import WithdrawConnectionRequest
 
 __all__ = [
-    "AcceptConnectionRequest",
+    "AcceptInvitation",
     "CheckConnectionStatus",
     "CommentOnPost",
     "CreatePost",
@@ -48,7 +48,7 @@ __all__ = [
     "FetchPersonMapper",
     "FetchPost",
     "FetchPostMapper",
-    "IgnoreConnectionRequest",
+    "IgnoreInvitation",
     "ManageConversation",
     "NvFetchCompany",
     "NvFetchCompanyMapper",
@@ -62,8 +62,8 @@ __all__ = [
     "NvSyncInbox",
     "ReactToPost",
     "RemoveConnection",
-    "RetrieveConnectionRequests",
     "RetrieveConnections",
+    "RetrieveInvitations",
     "RetrievePendingRequests",
     "RetrievePerformance",
     "RetrieveSSI",

linkedapi-1.3.2/linkedapi/operations/accept_invitation.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import AcceptInvitationParams
+
+
+class AcceptInvitation(Operation[AcceptInvitationParams, None]):
+    """Accept an incoming standard LinkedIn invitation."""
+
+    operation_name = "acceptInvitation"
+    mapper = VoidWorkflowMapper[AcceptInvitationParams]("st.acceptInvitation")

linkedapi-1.3.2/linkedapi/operations/ignore_invitation.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import IgnoreInvitationParams
+
+
+class IgnoreInvitation(Operation[IgnoreInvitationParams, None]):
+    """Ignore an incoming standard LinkedIn invitation."""
+
+    operation_name = "ignoreInvitation"
+    mapper = VoidWorkflowMapper[IgnoreInvitationParams]("st.ignoreInvitation")

linkedapi-1.3.2/linkedapi/operations/retrieve_invitations.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ArrayWorkflowMapper
+from linkedapi.types import Invitation
+
+
+class RetrieveInvitations(Operation[None, list[Invitation]]):
+    """Retrieve incoming LinkedIn invitations."""
+
+    operation_name = "retrieveInvitations"
+    mapper = ArrayWorkflowMapper[None, Invitation](
+        "st.retrieveInvitations",
+        Invitation,
+    )

{linkedapi-1.3.1 → linkedapi-1.3.2}/linkedapi/types/__init__.py

@@ -68,16 +68,18 @@ from linkedapi.types.company import (
     StCompanyEmployeesRetrievalConfig,
 )
 from linkedapi.types.connection import (
-    AcceptConnectionRequestParams,
+    AcceptInvitationParams,
     CheckConnectionStatusParams,
     CheckConnectionStatusResult,
     ConnectionPerson,
     ConnectionStatus,
-    IgnoreConnectionRequestParams,
+    IgnoreInvitationParams,
+    Invitation,
+    InvitationTargetParams,
+    InvitationType,
     NvOpenPersonPageParams,
     NvOpenPersonPageResult,
     RemoveConnectionParams,
-    RetrieveConnectionRequestsResult,
     RetrieveConnectionsFilter,
     RetrieveConnectionsParams,
     RetrieveConnectionsResult,
@@ -233,7 +235,7 @@ from linkedapi.types.workflow import (
 )
 
 __all__ = [
-    "AcceptConnectionRequestParams",
+    "AcceptInvitationParams",
     "AccountInfo",
     "AccountWebhookEvent",
     "AccountWebhookEventData",
@@ -290,9 +292,12 @@ __all__ = [
     "GetConnectionSessionParams",
     "GetLimitsParams",
     "GetLimitsUsageParams",
-    "IgnoreConnectionRequestParams",
+    "IgnoreInvitationParams",
     "InboxMessage",
     "InboxPollRequest",
+    "Invitation",
+    "InvitationTargetParams",
+    "InvitationType",
     "Job",
     "JobCurrency",
     "JobDatePosted",
@@ -375,7 +380,6 @@ __all__ = [
     "ReparseAccountInfoResult",
     "ReplayWebhookDeliveryParams",
     "ResetLimitsParams",
-    "RetrieveConnectionRequestsResult",
     "RetrieveConnectionsFilter",
     "RetrieveConnectionsParams",
     "RetrieveConnectionsResult",

linkedapi-1.3.2/linkedapi/types/connection.py

@@ -0,0 +1,172 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import model_validator
+
+from linkedapi.types.base import LinkedApiModel
+from linkedapi.types.params import BaseActionParams, LimitParams
+
+ConnectionStatus = Literal["connected", "pending", "incoming", "notConnected"]
+InvitationType = Literal["connect", "companyFollow", "newsletterSubscribe"]
+
+
+class ConnectionPerson(LinkedApiModel):
+    name: str | None = None
+    public_url: str | None = None
+    headline: str | None = None
+    location: str | None = None
+    profile_image_url: str | None = None
+
+
+class SendConnectionRequestParams(BaseActionParams):
+    person_url: str
+    note: str | None = None
+    email: str | None = None
+
+
+class CheckConnectionStatusParams(BaseActionParams):
+    person_url: str
+
+
+class CheckConnectionStatusResult(LinkedApiModel):
+    connection_status: ConnectionStatus | None = None
+
+
+class WithdrawConnectionRequestParams(BaseActionParams):
+    person_url: str
+    unfollow: bool | None = None
+
+
+class RetrievePendingRequestsResult(LinkedApiModel):
+    name: str | None = None
+    public_url: str | None = None
+    headline: str | None = None
+    sent_time: str | None = None
+
+
+class InvitationTargetParams(BaseActionParams):
+    invitation_type: InvitationType
+    person_url: str | None = None
+    company_url: str | None = None
+    newsletter_url: str | None = None
+
+    @model_validator(mode="after")
+    def validate_target_url(self) -> InvitationTargetParams:
+        target_urls = {
+            "connect": self.person_url,
+            "companyFollow": self.company_url,
+            "newsletterSubscribe": self.newsletter_url,
+        }
+        if target_urls[self.invitation_type] is None:
+            msg = f"{self.invitation_type} invitation requires its matching target URL"
+            raise ValueError(msg)
+        if sum(url is not None for url in target_urls.values()) != 1:
+            msg = "Provide only the target URL that matches invitation_type"
+            raise ValueError(msg)
+        return self
+
+
+class AcceptInvitationParams(InvitationTargetParams):
+    pass
+
+
+class IgnoreInvitationParams(InvitationTargetParams):
+    pass
+
+
+class Invitation(LinkedApiModel):
+    invitation_type: InvitationType
+    name: str
+    public_url: str
+    headline: str | None = None
+    note: str | None = None
+    company_url: str | None = None
+    company_name: str | None = None
+    newsletter_url: str | None = None
+    newsletter_name: str | None = None
+
+    @model_validator(mode="after")
+    def validate_type_fields(self) -> Invitation:
+        type_fields = {
+            "headline",
+            "note",
+            "company_url",
+            "company_name",
+            "newsletter_url",
+            "newsletter_name",
+        }
+        required_fields = {
+            "connect": {"headline", "note"},
+            "companyFollow": {"company_url", "company_name"},
+            "newsletterSubscribe": {"newsletter_url", "newsletter_name"},
+        }[self.invitation_type]
+        missing_fields = required_fields - self.model_fields_set
+        if missing_fields:
+            msg = (
+                f"{self.invitation_type} invitation is missing required fields: "
+                f"{', '.join(sorted(missing_fields))}"
+            )
+            raise ValueError(msg)
+
+        unexpected_fields = (self.model_fields_set & type_fields) - required_fields
+        if unexpected_fields:
+            msg = (
+                f"{self.invitation_type} invitation contains fields for another type: "
+                f"{', '.join(sorted(unexpected_fields))}"
+            )
+            raise ValueError(msg)
+
+        target_url = {
+            "connect": self.public_url,
+            "companyFollow": self.company_url,
+            "newsletterSubscribe": self.newsletter_url,
+        }[self.invitation_type]
+        if target_url is None:
+            msg = f"{self.invitation_type} invitation requires a non-null target URL"
+            raise ValueError(msg)
+        return self
+
+
+class RetrieveConnectionsFilter(LinkedApiModel):
+    first_name: str | None = None
+    last_name: str | None = None
+    position: str | None = None
+    locations: list[str] | None = None
+    industries: list[str] | None = None
+    current_companies: list[str] | None = None
+    previous_companies: list[str] | None = None
+    schools: list[str] | None = None
+
+
+class RetrieveConnectionsParams(LimitParams):
+    since: str | None = None
+    filter: RetrieveConnectionsFilter | None = None
+
+
+class RetrieveConnectionsResult(LinkedApiModel):
+    name: str | None = None
+    public_url: str | None = None
+    headline: str | None = None
+    location: str | None = None
+    connected_at: str | None = None
+
+
+class RemoveConnectionParams(BaseActionParams):
+    person_url: str
+
+
+class NvOpenPersonPageParams(BaseActionParams):
+    person_hashed_url: str
+
+
+class NvOpenPersonPageResult(LinkedApiModel):
+    name: str | None = None
+    public_url: str | None = None
+    hashed_url: str | None = None
+    headline: str | None = None
+    location: str | None = None
+    country_code: str | None = None
+    position: str | None = None
+    company_name: str | None = None
+    company_hashed_url: str | None = None

{linkedapi-1.3.1 → linkedapi-1.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "linkedapi"
-version = "1.3.1"
+version = "1.3.2"
 description = "Official synchronous Python SDK for Linked API."
 readme = "README.md"
 requires-python = ">=3.10"

{linkedapi-1.3.1 → linkedapi-1.3.2}/tests/test_operations.py

@@ -1,10 +1,14 @@
 from __future__ import annotations
 
+import pytest
 from conftest import FakeHttpClient
+from pydantic import ValidationError
 
 from linkedapi import (
+    AcceptInvitationParams,
     ArrayWorkflowMapper,
     FetchPersonParams,
+    Invitation,
     LinkedApi,
     LinkedApiConfig,
     VoidWorkflowMapper,
@@ -29,10 +33,10 @@ def test_linked_api_exposes_all_predefined_operations() -> None:
         "send_connection_request",
         "check_connection_status",
         "withdraw_connection_request",
-        "accept_connection_request",
-        "ignore_connection_request",
+        "accept_invitation",
+        "ignore_invitation",
         "retrieve_pending_requests",
-        "retrieve_connection_requests",
+        "retrieve_invitations",
         "retrieve_connections",
         "remove_connection",
         "send_message",
@@ -72,15 +76,12 @@ def test_operation_mappers_match_node_contract() -> None:
     assert linkedapi.fetch_job.mapper.default_params == {"basicInfo": True}
     assert isinstance(linkedapi.send_connection_request.mapper, VoidWorkflowMapper)
     assert linkedapi.send_connection_request.mapper.action_type == "st.sendConnectionRequest"
-    assert isinstance(linkedapi.accept_connection_request.mapper, VoidWorkflowMapper)
-    assert linkedapi.accept_connection_request.mapper.action_type == "st.acceptConnectionRequest"
-    assert isinstance(linkedapi.ignore_connection_request.mapper, VoidWorkflowMapper)
-    assert linkedapi.ignore_connection_request.mapper.action_type == "st.ignoreConnectionRequest"
-    assert isinstance(linkedapi.retrieve_connection_requests.mapper, ArrayWorkflowMapper)
-    assert (
-        linkedapi.retrieve_connection_requests.mapper.base_action_type
-        == "st.retrieveConnectionRequests"
-    )
+    assert isinstance(linkedapi.accept_invitation.mapper, VoidWorkflowMapper)
+    assert linkedapi.accept_invitation.mapper.action_type == "st.acceptInvitation"
+    assert isinstance(linkedapi.ignore_invitation.mapper, VoidWorkflowMapper)
+    assert linkedapi.ignore_invitation.mapper.action_type == "st.ignoreInvitation"
+    assert isinstance(linkedapi.retrieve_invitations.mapper, ArrayWorkflowMapper)
+    assert linkedapi.retrieve_invitations.mapper.base_action_type == "st.retrieveInvitations"
     assert isinstance(linkedapi.sync_inbox.mapper, VoidWorkflowMapper)
     assert linkedapi.sync_inbox.mapper.action_type == "st.syncInbox"
     assert isinstance(linkedapi.nv_sync_inbox.mapper, VoidWorkflowMapper)
@@ -91,6 +92,77 @@ def test_operation_mappers_match_node_contract() -> None:
     assert linkedapi.nv_manage_conversation.mapper.action_type == "nv.manageConversation"
 
 
+def test_invitation_params_require_the_matching_target_url() -> None:
+    params = AcceptInvitationParams(
+        invitation_type="companyFollow",
+        company_url="https://www.linkedin.com/company/example/",
+    )
+
+    assert params.model_dump(by_alias=True, exclude_none=True) == {
+        "invitationType": "companyFollow",
+        "companyUrl": "https://www.linkedin.com/company/example/",
+    }
+
+    with pytest.raises(ValidationError):
+        AcceptInvitationParams(
+            invitation_type="newsletterSubscribe",
+            person_url="https://www.linkedin.com/in/example/",
+        )
+
+    with pytest.raises(ValidationError):
+        AcceptInvitationParams(
+            invitation_type="connect",
+            person_url="https://www.linkedin.com/in/example/",
+            company_url="https://www.linkedin.com/company/example/",
+        )
+
+
+def test_invitation_result_fields_depend_on_type() -> None:
+    connect = Invitation.model_validate(
+        {
+            "invitationType": "connect",
+            "name": "Example Person",
+            "publicUrl": "https://www.linkedin.com/in/example/",
+            "headline": None,
+            "note": None,
+        }
+    )
+    assert connect.invitation_type == "connect"
+
+    company_follow = Invitation.model_validate(
+        {
+            "invitationType": "companyFollow",
+            "name": "Example Person",
+            "publicUrl": "https://www.linkedin.com/in/example/",
+            "companyUrl": "https://www.linkedin.com/company/example/",
+            "companyName": None,
+        }
+    )
+    assert company_follow.company_url == "https://www.linkedin.com/company/example/"
+
+    with pytest.raises(ValidationError):
+        Invitation.model_validate(
+            {
+                "invitationType": "connect",
+                "name": "Example Person",
+                "publicUrl": "https://www.linkedin.com/in/example/",
+                "headline": None,
+            }
+        )
+
+    with pytest.raises(ValidationError):
+        Invitation.model_validate(
+            {
+                "invitationType": "companyFollow",
+                "name": "Example Person",
+                "publicUrl": "https://www.linkedin.com/in/example/",
+                "companyUrl": "https://www.linkedin.com/company/example/",
+                "companyName": None,
+                "note": None,
+            }
+        )
+
+
 def test_execute_and_result_flow_returns_pydantic_data(
     fake_http_client: FakeHttpClient,
     person_data: dict[str, object],

linkedapi-1.3.1/linkedapi/operations/accept_connection_request.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from linkedapi.core import Operation
-from linkedapi.mappers import VoidWorkflowMapper
-from linkedapi.types import AcceptConnectionRequestParams
-
-
-class AcceptConnectionRequest(Operation[AcceptConnectionRequestParams, None]):
-    """Accept an incoming standard LinkedIn connection request."""
-
-    operation_name = "acceptConnectionRequest"
-    mapper = VoidWorkflowMapper[AcceptConnectionRequestParams]("st.acceptConnectionRequest")

linkedapi-1.3.1/linkedapi/operations/ignore_connection_request.py

@@ -1,12 +0,0 @@
-from __future__ import annotations
-
-from linkedapi.core import Operation
-from linkedapi.mappers import VoidWorkflowMapper
-from linkedapi.types import IgnoreConnectionRequestParams
-
-
-class IgnoreConnectionRequest(Operation[IgnoreConnectionRequestParams, None]):
-    """Ignore an incoming standard LinkedIn connection request."""
-
-    operation_name = "ignoreConnectionRequest"
-    mapper = VoidWorkflowMapper[IgnoreConnectionRequestParams]("st.ignoreConnectionRequest")

linkedapi-1.3.1/linkedapi/operations/retrieve_connection_requests.py

@@ -1,15 +0,0 @@
-from __future__ import annotations
-
-from linkedapi.core import Operation
-from linkedapi.mappers import ArrayWorkflowMapper
-from linkedapi.types import RetrieveConnectionRequestsResult
-
-
-class RetrieveConnectionRequests(Operation[None, list[RetrieveConnectionRequestsResult]]):
-    """Retrieve incoming standard LinkedIn connection requests."""
-
-    operation_name = "retrieveConnectionRequests"
-    mapper = ArrayWorkflowMapper[None, RetrieveConnectionRequestsResult](
-        "st.retrieveConnectionRequests",
-        RetrieveConnectionRequestsResult,
-    )

linkedapi-1.3.1/linkedapi/types/connection.py

@@ -1,100 +0,0 @@
-from __future__ import annotations
-
-from typing import Literal
-
-from linkedapi.types.base import LinkedApiModel
-from linkedapi.types.params import BaseActionParams, LimitParams
-
-ConnectionStatus = Literal["connected", "pending", "incoming", "notConnected"]
-
-
-class ConnectionPerson(LinkedApiModel):
-    name: str | None = None
-    public_url: str | None = None
-    headline: str | None = None
-    location: str | None = None
-    profile_image_url: str | None = None
-
-
-class SendConnectionRequestParams(BaseActionParams):
-    person_url: str
-    note: str | None = None
-    email: str | None = None
-
-
-class CheckConnectionStatusParams(BaseActionParams):
-    person_url: str
-
-
-class CheckConnectionStatusResult(LinkedApiModel):
-    connection_status: ConnectionStatus | None = None
-
-
-class WithdrawConnectionRequestParams(BaseActionParams):
-    person_url: str
-    unfollow: bool | None = None
-
-
-class RetrievePendingRequestsResult(LinkedApiModel):
-    name: str | None = None
-    public_url: str | None = None
-    headline: str | None = None
-    sent_time: str | None = None
-
-
-class AcceptConnectionRequestParams(BaseActionParams):
-    person_url: str
-
-
-class IgnoreConnectionRequestParams(BaseActionParams):
-    person_url: str
-
-
-class RetrieveConnectionRequestsResult(LinkedApiModel):
-    name: str | None = None
-    public_url: str | None = None
-    headline: str | None = None
-
-
-class RetrieveConnectionsFilter(LinkedApiModel):
-    first_name: str | None = None
-    last_name: str | None = None
-    position: str | None = None
-    locations: list[str] | None = None
-    industries: list[str] | None = None
-    current_companies: list[str] | None = None
-    previous_companies: list[str] | None = None
-    schools: list[str] | None = None
-
-
-class RetrieveConnectionsParams(LimitParams):
-    since: str | None = None
-    filter: RetrieveConnectionsFilter | None = None
-
-
-class RetrieveConnectionsResult(LinkedApiModel):
-    name: str | None = None
-    public_url: str | None = None
-    headline: str | None = None
-    location: str | None = None
-    connected_at: str | None = None
-
-
-class RemoveConnectionParams(BaseActionParams):
-    person_url: str
-
-
-class NvOpenPersonPageParams(BaseActionParams):
-    person_hashed_url: str
-
-
-class NvOpenPersonPageResult(LinkedApiModel):
-    name: str | None = None
-    public_url: str | None = None
-    hashed_url: str | None = None
-    headline: str | None = None
-    location: str | None = None
-    country_code: str | None = None
-    position: str | None = None
-    company_name: str | None = None
-    company_hashed_url: str | None = None