linkedapi 1.0.0__py3-none-any.whl

linkedapi/mappers/then.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar, cast
+
+from pydantic import BaseModel
+
+from linkedapi.errors import LinkedApiError
+from linkedapi.mappers.base import (
+    BaseMapper,
+    MappedResponse,
+    as_action_dict,
+    collect_action_errors,
+    parse_action_error,
+    parse_result,
+)
+from linkedapi.types import (
+    WorkflowCompletion,
+    WorkflowDefinition,
+    dump_model_by_name,
+    serialize_model,
+)
+from linkedapi.types.base import to_camel
+
+TParams = TypeVar("TParams")
+TResult = TypeVar("TResult")
+
+
+@dataclass(frozen=True)
+class ActionConfig:
+    param_name: str
+    action_type: str
+    config_source: str | None = None
+
+
+@dataclass(frozen=True)
+class ResponseMapping:
+    action_type: str
+    target_property: str
+
+
+class ThenWorkflowMapper(BaseMapper[TParams, TResult], Generic[TParams, TResult]):
+    def __init__(
+        self,
+        action_configs: list[ActionConfig],
+        response_mappings: list[ResponseMapping],
+        base_action_type: str,
+        default_params: dict[str, Any] | None = None,
+        result_model: type[BaseModel] | None = None,
+    ) -> None:
+        self.action_configs = action_configs
+        self.response_mappings = response_mappings
+        self.base_action_type = base_action_type
+        self.default_params = default_params or {}
+        self.result_model = result_model
+
+    def map_request(self, params: TParams | None = None) -> WorkflowDefinition:
+        alias_params = serialize_model(params)
+        name_params = dump_model_by_name(params)
+        resolve_alias = _make_alias_resolver(params)
+        then = self._build_then_for_request(alias_params, name_params, resolve_alias)
+        clear_params = self._clear_params(alias_params, resolve_alias)
+        return {
+            "actionType": self.base_action_type,
+            **self.default_params,
+            **clear_params,
+            "then": then,
+        }
+
+    def map_response(self, completion: WorkflowCompletion) -> MappedResponse[TResult]:
+        if isinstance(completion, list):
+            data = [
+                as_action_dict(action).get("data")
+                for action in completion
+                if as_action_dict(action).get("data")
+            ]
+            errors = collect_action_errors(
+                [as_action_dict(action).get("error") for action in completion]
+            )
+            return MappedResponse(
+                data=cast(TResult, parse_result(data, self.result_model)), errors=errors
+            )
+
+        action = as_action_dict(completion)
+        error = parse_action_error(action.get("error"))
+        if error is not None:
+            return MappedResponse(data=None, errors=[error])
+        single_data = action.get("data")
+        if single_data is not None:
+            return self._map_then_from_response(as_action_dict(single_data))
+        raise LinkedApiError.unknown_error()
+
+    def _map_then_from_response(self, data: dict[str, Any]) -> MappedResponse[TResult]:
+        result = {**data}
+        then_actions = data.get("then")
+        errors: list[Any] = []
+
+        if not then_actions:
+            result.pop("then", None)
+            return MappedResponse(
+                data=cast(TResult, parse_result(result, self.result_model)),
+                errors=[],
+            )
+
+        for mapping in self.response_mappings:
+            if isinstance(then_actions, list) and then_actions:
+                then_action = self._find_then_action(then_actions, mapping.action_type)
+                if then_action is not None:
+                    result[mapping.target_property] = then_action.get("data")
+                    errors.append(then_action.get("error"))
+                continue
+
+            then_action = as_action_dict(then_actions)
+            if then_action.get("actionType") == mapping.action_type:
+                result[mapping.target_property] = then_action.get("data")
+                errors.append(then_action.get("error"))
+
+        result.pop("then", None)
+        return MappedResponse(
+            data=cast(TResult, parse_result(result, self.result_model)),
+            errors=collect_action_errors(errors),
+        )
+
+    def _build_then_for_request(
+        self,
+        alias_params: dict[str, Any],
+        name_params: dict[str, Any],
+        resolve_alias: AliasResolver,
+    ) -> list[dict[str, Any]]:
+        actions: list[dict[str, Any]] = []
+        for config in self.action_configs:
+            if name_params.get(config.param_name) is True:
+                action = {"actionType": config.action_type}
+                if config.config_source:
+                    action.update(alias_params.get(resolve_alias(config.config_source), {}))
+                actions.append(action)
+        return actions
+
+    def _clear_params(
+        self,
+        params: dict[str, Any],
+        resolve_alias: AliasResolver,
+    ) -> dict[str, Any]:
+        cleaned_params = {**params}
+        for config in self.action_configs:
+            cleaned_params.pop(resolve_alias(config.param_name), None)
+            if config.config_source:
+                cleaned_params.pop(resolve_alias(config.config_source), None)
+        return cleaned_params
+
+    def _find_then_action(self, actions: list[Any], action_type: str) -> dict[str, Any] | None:
+        for action in actions:
+            action_dict = as_action_dict(action)
+            if action_dict.get("actionType") == action_type:
+                return action_dict
+        return None
+
+
+AliasResolver = Callable[[str], str]
+
+
+def _make_alias_resolver(params: Any) -> AliasResolver:
+    """Resolve a field's serialized key from the params model, mirroring its
+    explicit pydantic alias (e.g. ``retrieve_dms`` -> ``retrieveDMs``) and
+    falling back to ``to_camel`` for fields without one."""
+    fields = type(params).model_fields if isinstance(params, BaseModel) else {}
+
+    def resolve(name: str) -> str:
+        field = fields.get(name)
+        if field is not None and field.alias:
+            return field.alias
+        return to_camel(name)
+
+    return resolve

linkedapi/mappers/void.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from typing import Generic, TypeVar
+
+from linkedapi.mappers.base import (
+    BaseMapper,
+    MappedResponse,
+    as_action_dict,
+    collect_action_errors,
+    parse_action_error,
+)
+from linkedapi.types import WorkflowCompletion, WorkflowDefinition, serialize_model
+
+TParams = TypeVar("TParams")
+
+
+class VoidWorkflowMapper(BaseMapper[TParams, None], Generic[TParams]):
+    def __init__(self, action_type: str) -> None:
+        self.action_type = action_type
+
+    def map_request(self, params: TParams | None = None) -> WorkflowDefinition:
+        return {"actionType": self.action_type, **serialize_model(params)}
+
+    def map_response(self, completion: WorkflowCompletion) -> MappedResponse[None]:
+        if isinstance(completion, list):
+            errors = collect_action_errors(
+                [as_action_dict(action).get("error") for action in completion]
+            )
+            return MappedResponse(data=None, errors=errors)
+
+        action = as_action_dict(completion)
+        error = parse_action_error(action.get("error"))
+        return MappedResponse(data=None, errors=[] if error is None else [error])

linkedapi/operations/__init__.py

@@ -0,0 +1,58 @@
+from linkedapi.operations.check_connection_status import CheckConnectionStatus
+from linkedapi.operations.comment_on_post import CommentOnPost
+from linkedapi.operations.create_post import CreatePost
+from linkedapi.operations.custom_workflow import CustomWorkflow
+from linkedapi.operations.fetch_company import FetchCompany, FetchCompanyMapper
+from linkedapi.operations.fetch_person import FetchPerson, FetchPersonMapper
+from linkedapi.operations.fetch_post import FetchPost, FetchPostMapper
+from linkedapi.operations.nv_fetch_company import NvFetchCompany, NvFetchCompanyMapper
+from linkedapi.operations.nv_fetch_person import NvFetchPerson, NvFetchPersonMapper
+from linkedapi.operations.nv_search_companies import NvSearchCompanies
+from linkedapi.operations.nv_search_people import NvSearchPeople
+from linkedapi.operations.nv_send_message import NvSendMessage
+from linkedapi.operations.nv_sync_conversation import NvSyncConversation
+from linkedapi.operations.react_to_post import ReactToPost
+from linkedapi.operations.remove_connection import RemoveConnection
+from linkedapi.operations.retrieve_connections import RetrieveConnections
+from linkedapi.operations.retrieve_pending_requests import RetrievePendingRequests
+from linkedapi.operations.retrieve_performance import RetrievePerformance
+from linkedapi.operations.retrieve_ssi import RetrieveSSI
+from linkedapi.operations.search_companies import SearchCompanies
+from linkedapi.operations.search_people import SearchPeople
+from linkedapi.operations.send_connection_request import SendConnectionRequest
+from linkedapi.operations.send_message import SendMessage
+from linkedapi.operations.sync_conversation import SyncConversation
+from linkedapi.operations.withdraw_connection_request import WithdrawConnectionRequest
+
+__all__ = [
+    "CheckConnectionStatus",
+    "CommentOnPost",
+    "CreatePost",
+    "CustomWorkflow",
+    "FetchCompany",
+    "FetchCompanyMapper",
+    "FetchPerson",
+    "FetchPersonMapper",
+    "FetchPost",
+    "FetchPostMapper",
+    "NvFetchCompany",
+    "NvFetchCompanyMapper",
+    "NvFetchPerson",
+    "NvFetchPersonMapper",
+    "NvSearchCompanies",
+    "NvSearchPeople",
+    "NvSendMessage",
+    "NvSyncConversation",
+    "ReactToPost",
+    "RemoveConnection",
+    "RetrieveConnections",
+    "RetrievePendingRequests",
+    "RetrievePerformance",
+    "RetrieveSSI",
+    "SearchCompanies",
+    "SearchPeople",
+    "SendConnectionRequest",
+    "SendMessage",
+    "SyncConversation",
+    "WithdrawConnectionRequest",
+]

linkedapi/operations/check_connection_status.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import SimpleWorkflowMapper
+from linkedapi.types import CheckConnectionStatusParams, CheckConnectionStatusResult
+
+
+class CheckConnectionStatus(Operation[CheckConnectionStatusParams, CheckConnectionStatusResult]):
+    """Check a standard LinkedIn connection status."""
+
+    operation_name = "checkConnectionStatus"
+    mapper = SimpleWorkflowMapper[CheckConnectionStatusParams, CheckConnectionStatusResult](
+        "st.checkConnectionStatus",
+        result_model=CheckConnectionStatusResult,
+    )

linkedapi/operations/comment_on_post.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import CommentOnPostParams
+
+
+class CommentOnPost(Operation[CommentOnPostParams, None]):
+    """Comment on a LinkedIn post."""
+
+    operation_name = "commentOnPost"
+    mapper = VoidWorkflowMapper[CommentOnPostParams]("st.commentOnPost")

linkedapi/operations/create_post.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import SimpleWorkflowMapper
+from linkedapi.types import CreatePostParams, CreatePostResult
+
+
+class CreatePost(Operation[CreatePostParams, CreatePostResult]):
+    """Create a LinkedIn post."""
+
+    operation_name = "createPost"
+    mapper = SimpleWorkflowMapper[CreatePostParams, CreatePostResult](
+        "st.createPost",
+        result_model=CreatePostResult,
+    )

linkedapi/operations/custom_workflow.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import BaseMapper, MappedResponse
+from linkedapi.types import WorkflowCompletion, WorkflowDefinition
+
+
+class _CustomWorkflowMapper(BaseMapper[WorkflowDefinition, WorkflowCompletion]):
+    def map_request(self, params: WorkflowDefinition | None = None) -> WorkflowDefinition:
+        if params is None:
+            return {}
+        return params
+
+    def map_response(self, completion: WorkflowCompletion) -> MappedResponse[WorkflowCompletion]:
+        return MappedResponse(data=completion, errors=[])
+
+
+class CustomWorkflow(Operation[WorkflowDefinition, WorkflowCompletion]):
+    """Execute raw Linked API workflow definitions."""
+
+    operation_name = "customWorkflow"
+    mapper = _CustomWorkflowMapper()

linkedapi/operations/fetch_company.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ActionConfig, ResponseMapping, ThenWorkflowMapper
+from linkedapi.types import Company, FetchCompanyParams
+
+
+class FetchCompanyMapper(ThenWorkflowMapper[FetchCompanyParams, Company]):
+    def __init__(self) -> None:
+        super().__init__(
+            action_configs=[
+                ActionConfig(
+                    "retrieve_employees",
+                    "st.retrieveCompanyEmployees",
+                    "employees_retrieval_config",
+                ),
+                ActionConfig("retrieve_dms", "st.retrieveCompanyDMs", "dms_retrieval_config"),
+                ActionConfig("retrieve_posts", "st.retrieveCompanyPosts", "posts_retrieval_config"),
+            ],
+            response_mappings=[
+                ResponseMapping("st.retrieveCompanyEmployees", "employees"),
+                ResponseMapping("st.retrieveCompanyDMs", "dms"),
+                ResponseMapping("st.retrieveCompanyPosts", "posts"),
+            ],
+            base_action_type="st.openCompanyPage",
+            default_params={"basicInfo": True},
+            result_model=Company,
+        )
+
+
+class FetchCompany(Operation[FetchCompanyParams, Company]):
+    """Fetch a standard LinkedIn company page."""
+
+    operation_name = "fetchCompany"
+    mapper = FetchCompanyMapper()

linkedapi/operations/fetch_person.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ActionConfig, ResponseMapping, ThenWorkflowMapper
+from linkedapi.types import FetchPersonParams, Person
+
+
+class FetchPersonMapper(ThenWorkflowMapper[FetchPersonParams, Person]):
+    def __init__(self) -> None:
+        super().__init__(
+            action_configs=[
+                ActionConfig("retrieve_experience", "st.retrievePersonExperience"),
+                ActionConfig("retrieve_education", "st.retrievePersonEducation"),
+                ActionConfig("retrieve_skills", "st.retrievePersonSkills"),
+                ActionConfig("retrieve_languages", "st.retrievePersonLanguages"),
+                ActionConfig("retrieve_posts", "st.retrievePersonPosts", "posts_retrieval_config"),
+                ActionConfig(
+                    "retrieve_comments", "st.retrievePersonComments", "comments_retrieval_config"
+                ),
+                ActionConfig(
+                    "retrieve_reactions", "st.retrievePersonReactions", "reactions_retrieval_config"
+                ),
+            ],
+            response_mappings=[
+                ResponseMapping("st.retrievePersonExperience", "experiences"),
+                ResponseMapping("st.retrievePersonEducation", "education"),
+                ResponseMapping("st.retrievePersonSkills", "skills"),
+                ResponseMapping("st.retrievePersonLanguages", "languages"),
+                ResponseMapping("st.retrievePersonPosts", "posts"),
+                ResponseMapping("st.retrievePersonComments", "comments"),
+                ResponseMapping("st.retrievePersonReactions", "reactions"),
+            ],
+            base_action_type="st.openPersonPage",
+            default_params={"basicInfo": True},
+            result_model=Person,
+        )
+
+
+class FetchPerson(Operation[FetchPersonParams, Person]):
+    """Fetch a standard LinkedIn person profile."""
+
+    operation_name = "fetchPerson"
+    mapper = FetchPersonMapper()

linkedapi/operations/fetch_post.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ActionConfig, ResponseMapping, ThenWorkflowMapper
+from linkedapi.types import FetchPostParams, Post
+
+
+class FetchPostMapper(ThenWorkflowMapper[FetchPostParams, Post]):
+    def __init__(self) -> None:
+        super().__init__(
+            action_configs=[
+                ActionConfig(
+                    "retrieve_comments", "st.retrievePostComments", "comments_retrieval_config"
+                ),
+                ActionConfig(
+                    "retrieve_reactions", "st.retrievePostReactions", "reactions_retrieval_config"
+                ),
+            ],
+            response_mappings=[
+                ResponseMapping("st.retrievePostComments", "comments"),
+                ResponseMapping("st.retrievePostReactions", "reactions"),
+            ],
+            base_action_type="st.openPost",
+            default_params={"basicInfo": True},
+            result_model=Post,
+        )
+
+
+class FetchPost(Operation[FetchPostParams, Post]):
+    """Fetch a LinkedIn post."""
+
+    operation_name = "fetchPost"
+    mapper = FetchPostMapper()

linkedapi/operations/nv_fetch_company.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ActionConfig, ResponseMapping, ThenWorkflowMapper
+from linkedapi.types import NvCompany, NvFetchCompanyParams
+
+
+class NvFetchCompanyMapper(ThenWorkflowMapper[NvFetchCompanyParams, NvCompany]):
+    def __init__(self) -> None:
+        super().__init__(
+            action_configs=[
+                ActionConfig(
+                    "retrieve_employees",
+                    "nv.retrieveCompanyEmployees",
+                    "employees_retrieval_config",
+                ),
+                ActionConfig("retrieve_dms", "nv.retrieveCompanyDMs", "dms_retrieval_config"),
+            ],
+            response_mappings=[
+                ResponseMapping("nv.retrieveCompanyEmployees", "employees"),
+                ResponseMapping("nv.retrieveCompanyDMs", "dms"),
+            ],
+            base_action_type="nv.openCompanyPage",
+            default_params={"basicInfo": True},
+            result_model=NvCompany,
+        )
+
+
+class NvFetchCompany(Operation[NvFetchCompanyParams, NvCompany]):
+    """Fetch a Sales Navigator company page."""
+
+    operation_name = "nvFetchCompany"
+    mapper = NvFetchCompanyMapper()

linkedapi/operations/nv_fetch_person.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ThenWorkflowMapper
+from linkedapi.types import NvOpenPersonPageParams, NvOpenPersonPageResult
+
+
+class NvFetchPersonMapper(ThenWorkflowMapper[NvOpenPersonPageParams, NvOpenPersonPageResult]):
+    def __init__(self) -> None:
+        super().__init__(
+            action_configs=[],
+            response_mappings=[],
+            base_action_type="nv.openPersonPage",
+            default_params={"basicInfo": True},
+            result_model=NvOpenPersonPageResult,
+        )
+
+
+class NvFetchPerson(Operation[NvOpenPersonPageParams, NvOpenPersonPageResult]):
+    """Fetch a Sales Navigator person profile."""
+
+    operation_name = "nvFetchPerson"
+    mapper = NvFetchPersonMapper()

linkedapi/operations/nv_search_companies.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ArrayWorkflowMapper
+from linkedapi.types import NvSearchCompaniesParams, NvSearchCompanyResult
+
+
+class NvSearchCompanies(Operation[NvSearchCompaniesParams, list[NvSearchCompanyResult]]):
+    """Search companies on Sales Navigator."""
+
+    operation_name = "nvSearchCompanies"
+    mapper = ArrayWorkflowMapper[NvSearchCompaniesParams, NvSearchCompanyResult](
+        "nv.searchCompanies",
+        NvSearchCompanyResult,
+    )

linkedapi/operations/nv_search_people.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ArrayWorkflowMapper
+from linkedapi.types import NvSearchPeopleParams, NvSearchPeopleResult
+
+
+class NvSearchPeople(Operation[NvSearchPeopleParams, list[NvSearchPeopleResult]]):
+    """Search people on Sales Navigator."""
+
+    operation_name = "nvSearchPeople"
+    mapper = ArrayWorkflowMapper[NvSearchPeopleParams, NvSearchPeopleResult](
+        "nv.searchPeople",
+        NvSearchPeopleResult,
+    )

linkedapi/operations/nv_send_message.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import NvSendMessageParams
+
+
+class NvSendMessage(Operation[NvSendMessageParams, None]):
+    """Send a Sales Navigator message."""
+
+    operation_name = "nvSendMessage"
+    mapper = VoidWorkflowMapper[NvSendMessageParams]("nv.sendMessage")

linkedapi/operations/nv_sync_conversation.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import NvSyncConversationParams
+
+
+class NvSyncConversation(Operation[NvSyncConversationParams, None]):
+    """Sync a Sales Navigator conversation."""
+
+    operation_name = "nvSyncConversation"
+    mapper = VoidWorkflowMapper[NvSyncConversationParams]("nv.syncConversation")

linkedapi/operations/react_to_post.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import ReactToPostParams
+
+
+class ReactToPost(Operation[ReactToPostParams, None]):
+    """React to a LinkedIn post."""
+
+    operation_name = "reactToPost"
+    mapper = VoidWorkflowMapper[ReactToPostParams]("st.reactToPost")

linkedapi/operations/remove_connection.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import VoidWorkflowMapper
+from linkedapi.types import RemoveConnectionParams
+
+
+class RemoveConnection(Operation[RemoveConnectionParams, None]):
+    """Remove a standard LinkedIn connection."""
+
+    operation_name = "removeConnection"
+    mapper = VoidWorkflowMapper[RemoveConnectionParams]("st.removeConnection")

linkedapi/operations/retrieve_connections.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import ArrayWorkflowMapper
+from linkedapi.types import RetrieveConnectionsParams, RetrieveConnectionsResult
+
+
+class RetrieveConnections(Operation[RetrieveConnectionsParams, list[RetrieveConnectionsResult]]):
+    """Retrieve standard LinkedIn connections."""
+
+    operation_name = "retrieveConnections"
+    mapper = ArrayWorkflowMapper[RetrieveConnectionsParams, RetrieveConnectionsResult](
+        "st.retrieveConnections",
+        RetrieveConnectionsResult,
+    )

linkedapi/operations/retrieve_pending_requests.py

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

linkedapi/operations/retrieve_performance.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import SimpleWorkflowMapper
+from linkedapi.types import RetrievePerformanceResult
+
+
+class RetrievePerformance(Operation[None, RetrievePerformanceResult]):
+    """Retrieve LinkedIn performance metrics."""
+
+    operation_name = "retrievePerformance"
+    mapper = SimpleWorkflowMapper[None, RetrievePerformanceResult](
+        "st.retrievePerformance",
+        result_model=RetrievePerformanceResult,
+    )

linkedapi/operations/retrieve_ssi.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from linkedapi.core import Operation
+from linkedapi.mappers import SimpleWorkflowMapper
+from linkedapi.types import RetrieveSSIResult
+
+
+class RetrieveSSI(Operation[None, RetrieveSSIResult]):
+    """Retrieve LinkedIn SSI metrics."""
+
+    operation_name = "retrieveSSI"
+    mapper = SimpleWorkflowMapper[None, RetrieveSSIResult](
+        "st.retrieveSSI",
+        result_model=RetrieveSSIResult,
+    )