diff --git a/RELEASENOTES.md b/RELEASENOTES.md index 89e8833..cbb6d60 100644 --- a/RELEASENOTES.md +++ b/RELEASENOTES.md @@ -1,5 +1,56 @@ # Release Notes +## 2.0.0 + +### ⚠️ Breaking Change + +`ExecutionContext.fetch()` now returns a `FetchResponse` object instead of the raw parsed body. + +**Before (1.x):** +```python +data = await context.fetch("https://api.example.com/items") +# data was the parsed JSON dict/list or text string directly +items = data["results"] +``` + +**After (2.0):** +```python +response = await context.fetch("https://api.example.com/items") +# response is a FetchResponse with .status, .headers, and .data +items = response.data["results"] +``` + +`FetchResponse` attributes: +- `status` — HTTP status code (e.g. `200`, `201`) +- `headers` — response headers as a plain `dict` +- `data` — parsed JSON (`dict`/`list`) for `application/json` responses, raw text otherwise, `None` for empty 200/201/204 responses + +### Migration Guide + +1. **Find all `context.fetch()` calls** in your integration code +2. **Access the response body via `.data`** — the return value is now a `FetchResponse` object, not the raw body: + ```python + # Before + result = await context.fetch(url) + return ActionResult(data=result) + + # After + result = await context.fetch(url) + return ActionResult(data=result.data) + ``` +3. **Optional: use `.status` and `.headers`** for richer error handling or response inspection: + ```python + response = await context.fetch(url) + if response.status == 201: + log.info(f"Created, location: {response.headers.get('Location')}") + ``` + +### Other Changes +- Add `FetchResponse` class, exported from the package +- Add pytest test suite (72 tests, 99% coverage) with `pytest-asyncio` and `aioresponses` +- Add GitHub Actions CI workflow with coverage reporting on PRs +- Add coverage badge and CI status badges to READMEs + ## 1.1.1 - Export HTTPError and RateLimitError from package for direct import - Added PyPI-optimised README with absolute links and best practices diff --git a/docs/apidocs/autohive_integrations_sdk.html b/docs/apidocs/autohive_integrations_sdk.html index 5391b78..629c4e1 100644 --- a/docs/apidocs/autohive_integrations_sdk.html +++ b/docs/apidocs/autohive_integrations_sdk.html @@ -51,7 +51,7 @@ 

1# Version
-2__version__ = "1.1.1"
+2__version__ = "2.0.0"
 3
 4# Re-export classes from integration module
 5from autohive_integrations_sdk.integration import (
diff --git a/docs/apidocs/autohive_integrations_sdk/integration.html b/docs/apidocs/autohive_integrations_sdk/integration.html
index ff41eb0..bec263d 100644
--- a/docs/apidocs/autohive_integrations_sdk/integration.html
+++ b/docs/apidocs/autohive_integrations_sdk/integration.html
@@ -431,7 +431,10 @@ 

 
  • ActionHandler — base class for action implementations (return ActionResult)
    • 
 
  • ConnectedAccountHandler — base class for connected-account lookups (return ConnectedAccountInfo)
    • 
 
  • ActionResult — standard return type wrapping action output data and optional billing cost
    • 
+
  • ActionError — return type for expected application-level errors (bypasses output schema validation)
    • 
+
  • FetchResponse — response object from context.fetch() with .status, .headers, and .data
    • 
 
  • ConnectedAccountInfo — structured account info returned by connected-account handlers
    • 
+
  • HTTPError / RateLimitError — exceptions raised by context.fetch() for non-2xx responses
    • 
 
 
 
    Typical usage::
    
@@ -461,919 +464,922 @@ 
    
   7- `ActionHandler` — base class for action implementations (return `ActionResult`)
   8- `ConnectedAccountHandler` — base class for connected-account lookups (return `ConnectedAccountInfo`)
   9- `ActionResult` — standard return type wrapping action output data and optional billing cost
- 10- `ConnectedAccountInfo` — structured account info returned by connected-account handlers
- 11
- 12Typical usage::
- 13
- 14    from autohive_integrations_sdk import Integration, ActionHandler, ActionResult, ExecutionContext
- 15
- 16    integration = Integration.load()
- 17
- 18    @integration.action("my_action")
- 19    class MyAction(ActionHandler):
- 20        async def execute(self, inputs, context):
- 21            response = await context.fetch("https://api.example.com/resource")
- 22            return ActionResult(data=response.data)
- 23"""
- 24
- 25# Standard Library Imports
- 26from abc import ABC, abstractmethod
- 27import asyncio
- 28from dataclasses import dataclass, field, asdict
- 29from datetime import timedelta
- 30from enum import Enum
- 31import json
- 32import json as jsonX  # Keep alias to avoid conflict with 'json' parameter in fetch
- 33import logging
- 34import os
- 35import sys
- 36from pathlib import Path
- 37from typing import Dict, Any, List, Optional, Union, Type, TypeVar, Generic, ClassVar
- 38from urllib.parse import urlencode
- 39
- 40# Third-Party Imports
- 41import aiohttp
- 42from jsonschema import validate, Draft7Validator
- 43
- 44
- 45# Local Imports
- 46from autohive_integrations_sdk import __version__
+ 10- `ActionError` — return type for expected application-level errors (bypasses output schema validation)
+ 11- `FetchResponse` — response object from ``context.fetch()`` with ``.status``, ``.headers``, and ``.data``
+ 12- `ConnectedAccountInfo` — structured account info returned by connected-account handlers
+ 13- `HTTPError` / `RateLimitError` — exceptions raised by ``context.fetch()`` for non-2xx responses
+ 14
+ 15Typical usage::
+ 16
+ 17    from autohive_integrations_sdk import Integration, ActionHandler, ActionResult, ExecutionContext
+ 18
+ 19    integration = Integration.load()
+ 20
+ 21    @integration.action("my_action")
+ 22    class MyAction(ActionHandler):
+ 23        async def execute(self, inputs, context):
+ 24            response = await context.fetch("https://api.example.com/resource")
+ 25            return ActionResult(data=response.data)
+ 26"""
+ 27
+ 28# Standard Library Imports
+ 29from abc import ABC, abstractmethod
+ 30import asyncio
+ 31from dataclasses import dataclass, field, asdict
+ 32from datetime import timedelta
+ 33from enum import Enum
+ 34import json
+ 35import json as jsonX  # Keep alias to avoid conflict with 'json' parameter in fetch
+ 36import logging
+ 37import os
+ 38import sys
+ 39from pathlib import Path
+ 40from typing import Dict, Any, List, Optional, Union, Type, TypeVar, Generic, ClassVar
+ 41from urllib.parse import urlencode
+ 42
+ 43# Third-Party Imports
+ 44import aiohttp
+ 45from jsonschema import validate, Draft7Validator
+ 46
  47
- 48
- 49# ---- Type Definitions ----
- 50T = TypeVar('T')
+ 48# Local Imports
+ 49from autohive_integrations_sdk import __version__
+ 50
  51
- 52# ---- Auth Types ----
- 53class AuthType(Enum):
- 54    """Authentication strategy used by an integration.
- 55
- 56    The platform stores the auth type alongside credentials and passes both
- 57    to ``ExecutionContext``.  ``context.fetch()`` uses the type to decide
- 58    whether to auto-inject an ``Authorization`` header.
- 59
- 60    Members:
- 61        PlatformOauth2: Platform-managed OAuth 2.0 — the platform handles the
- 62            token lifecycle and injects ``Bearer <access_token>`` automatically.
- 63        PlatformTeams: Platform-managed Microsoft Teams auth.
- 64        ApiKey: A single API key provided by the user.
- 65        Basic: Username/password (HTTP Basic) credentials.
- 66        Custom: Free-form credential fields defined by the integration's
- 67            ``config.json`` auth schema.  The integration is responsible for
- 68            reading individual fields from ``context.auth``.
- 69    """
- 70    PlatformOauth2 = "PlatformOauth2"
- 71    PlatformTeams = "PlatformTeams"
- 72    ApiKey = "ApiKey"
- 73    Basic = "Basic"
- 74    Custom = "Custom"
- 75
- 76class ResultType(Enum):
- 77    """Type of result being returned"""
- 78    ACTION = "action"
- 79    ACTION_ERROR = "action_error"
- 80    CONNECTED_ACCOUNT = "connected_account"
- 81    ERROR = "error"
- 82    VALIDATION_ERROR = "validation_error"
- 83
- 84# ---- Exceptions ----
- 85class ValidationError(Exception):
- 86    """Raised when SDK validation fails.
- 87
- 88    This covers several cases:
- 89
- 90    - Action inputs don't match the ``input_schema`` in ``config.json``
- 91    - Action outputs don't match the ``output_schema``
- 92    - Auth credentials don't match the ``auth.fields`` schema
- 93    - An action handler returns something other than ``ActionResult``
- 94    - A handler name isn't registered
- 95    """
- 96    def __init__(self, message: str, schema: str = None, inputs: str = None, source: str = "legacy"):
- 97        self.schema = schema
- 98        """The schema that failed validation"""
- 99        self.inputs = inputs
-100        """The data that failed validation"""
-101        self.message = message
-102        """The error message"""
-103        self.source = source
-104        """Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)"""
-105        super().__init__(message)
-106
-107class ConfigurationError(Exception):
-108    """Raised when integration configuration is invalid"""
-109    pass
-110
-111class HTTPError(Exception):
-112    """Raised by ``ExecutionContext.fetch()`` for non-2xx HTTP responses (except 429)."""
-113    def __init__(self, status: int, message: str, response_data: Any = None):
-114        self.status = status
-115        """Status code"""
-116        self.message = message
-117        """Error message"""
-118        self.response_data = response_data
-119        """Response data"""
-120        super().__init__(f"HTTP {status}: {message}")
-121
-122class RateLimitError(HTTPError):
-123    """Raised by ``ExecutionContext.fetch()`` on HTTP 429 (Too Many Requests).
+ 52# ---- Type Definitions ----
+ 53T = TypeVar('T')
+ 54
+ 55# ---- Auth Types ----
+ 56class AuthType(Enum):
+ 57    """Authentication strategy used by an integration.
+ 58
+ 59    The platform stores the auth type alongside credentials and passes both
+ 60    to ``ExecutionContext``.  ``context.fetch()`` uses the type to decide
+ 61    whether to auto-inject an ``Authorization`` header.
+ 62
+ 63    Members:
+ 64        PlatformOauth2: Platform-managed OAuth 2.0 — the platform handles the
+ 65            token lifecycle and injects ``Bearer <access_token>`` automatically.
+ 66        PlatformTeams: Platform-managed Microsoft Teams auth.
+ 67        ApiKey: A single API key provided by the user.
+ 68        Basic: Username/password (HTTP Basic) credentials.
+ 69        Custom: Free-form credential fields defined by the integration's
+ 70            ``config.json`` auth schema.  The integration is responsible for
+ 71            reading individual fields from ``context.auth``.
+ 72    """
+ 73    PlatformOauth2 = "PlatformOauth2"
+ 74    PlatformTeams = "PlatformTeams"
+ 75    ApiKey = "ApiKey"
+ 76    Basic = "Basic"
+ 77    Custom = "Custom"
+ 78
+ 79class ResultType(Enum):
+ 80    """Type of result being returned"""
+ 81    ACTION = "action"
+ 82    ACTION_ERROR = "action_error"
+ 83    CONNECTED_ACCOUNT = "connected_account"
+ 84    ERROR = "error"
+ 85    VALIDATION_ERROR = "validation_error"
+ 86
+ 87# ---- Exceptions ----
+ 88class ValidationError(Exception):
+ 89    """Raised when SDK validation fails.
+ 90
+ 91    This covers several cases:
+ 92
+ 93    - Action inputs don't match the ``input_schema`` in ``config.json``
+ 94    - Action outputs don't match the ``output_schema``
+ 95    - Auth credentials don't match the ``auth.fields`` schema
+ 96    - An action handler returns something other than ``ActionResult``
+ 97    - A handler name isn't registered
+ 98    """
+ 99    def __init__(self, message: str, schema: str = None, inputs: str = None, source: str = "legacy"):
+100        self.schema = schema
+101        """The schema that failed validation"""
+102        self.inputs = inputs
+103        """The data that failed validation"""
+104        self.message = message
+105        """The error message"""
+106        self.source = source
+107        """Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)"""
+108        super().__init__(message)
+109
+110class ConfigurationError(Exception):
+111    """Raised when integration configuration is invalid"""
+112    pass
+113
+114class HTTPError(Exception):
+115    """Raised by ``ExecutionContext.fetch()`` for non-2xx HTTP responses (except 429)."""
+116    def __init__(self, status: int, message: str, response_data: Any = None):
+117        self.status = status
+118        """Status code"""
+119        self.message = message
+120        """Error message"""
+121        self.response_data = response_data
+122        """Response data"""
+123        super().__init__(f"HTTP {status}: {message}")
 124
-125    Attributes:
-126        retry_after: Seconds to wait before retrying, taken from the
-127            ``Retry-After`` response header (defaults to 60 if absent).
-128    """
-129    def __init__(self, retry_after: int, *args, **kwargs):
-130        self.retry_after = retry_after
-131        """Seconds to wait before retrying."""
-132        super().__init__(*args, **kwargs)
-133
-134# ---- Result Classes ----
-135@dataclass
-136class FetchResponse:
-137    """Response object returned by ``ExecutionContext.fetch()``.
-138
-139    Wraps the full HTTP response so callers can inspect status codes and
-140    headers in addition to the parsed body.
+125class RateLimitError(HTTPError):
+126    """Raised by ``ExecutionContext.fetch()`` on HTTP 429 (Too Many Requests).
+127
+128    Attributes:
+129        retry_after: Seconds to wait before retrying, taken from the
+130            ``Retry-After`` response header (defaults to 60 if absent).
+131    """
+132    def __init__(self, retry_after: int, *args, **kwargs):
+133        self.retry_after = retry_after
+134        """Seconds to wait before retrying."""
+135        super().__init__(*args, **kwargs)
+136
+137# ---- Result Classes ----
+138@dataclass
+139class FetchResponse:
+140    """Response object returned by ``ExecutionContext.fetch()``.
 141
-142    Attributes:
-143        status: HTTP status code (e.g. ``200``, ``201``).
-144        headers: Response headers as a plain ``dict``.
-145        data: Parsed JSON (``dict``/``list``) when the response is
-146            ``application/json``, otherwise the raw response text.
-147            ``None`` for empty 200/201/204 responses.
-148    """
-149    status: int
-150    headers: Dict[str, str]
-151    data: Any
-152
-153@dataclass
-154class ActionResult:
-155    """Result returned by action handlers.
-156
-157    This class encapsulates the data returned by an action along with optional
-158    billing information for cost tracking.
+142    Wraps the full HTTP response so callers can inspect status codes and
+143    headers in addition to the parsed body.
+144
+145    Attributes:
+146        status: HTTP status code (e.g. ``200``, ``201``).
+147        headers: Response headers as a plain ``dict``.
+148        data: Parsed JSON (``dict``/``list``) when the response is
+149            ``application/json``, otherwise the raw response text.
+150            ``None`` for empty 200/201/204 responses.
+151    """
+152    status: int
+153    headers: Dict[str, str]
+154    data: Any
+155
+156@dataclass
+157class ActionResult:
+158    """Result returned by action handlers.
 159
-160    Args:
-161        data: The actual result data from the action
-162        cost_usd: Optional USD cost for billing purposes
-163
-164    Example:
-165        ```python
-166        return ActionResult(
-167            data={"message": "Success", "result": 42},
-168            cost_usd=0.05
-169        )
-170        ```
-171    """
-172    data: Any
-173    cost_usd: Optional[float] = None
-174
-175@dataclass
-176class ActionError:
-177    """Error result returned by action handlers for expected/application-level errors.
-178
-179    When returned from an action handler, output schema validation is skipped
-180    and the error is returned to the caller as a ResultType.ERROR result.
+160    This class encapsulates the data returned by an action along with optional
+161    billing information for cost tracking.
+162
+163    Args:
+164        data: The actual result data from the action
+165        cost_usd: Optional USD cost for billing purposes
+166
+167    Example:
+168        ```python
+169        return ActionResult(
+170            data={"message": "Success", "result": 42},
+171            cost_usd=0.05
+172        )
+173        ```
+174    """
+175    data: Any
+176    cost_usd: Optional[float] = None
+177
+178@dataclass
+179class ActionError:
+180    """Error result returned by action handlers for expected/application-level errors.
 181
-182    Args:
-183        message: Human-readable error message
-184        cost_usd: Optional USD cost incurred before the error occurred
-185
-186    Example:
-187        ```python
-188        return ActionError(
-189            message="User not found",
-190            cost_usd=0.01
-191        )
-192        ```
-193    """
-194    message: str
-195    cost_usd: Optional[float] = None
-196
-197@dataclass
-198class ConnectedAccountInfo:
-199    """Account metadata returned by a ``ConnectedAccountHandler``.
-200
-201    The platform calls the connected-account handler after a user links
-202    their external account.  The returned info is displayed in the
-203    Autohive UI (avatar, name, email, etc.).
-204
-205    All fields are optional — populate whichever ones the external API provides.
-206    """
-207    email: Optional[str] = None
-208    first_name: Optional[str] = None
-209    last_name: Optional[str] = None
-210    username: Optional[str] = None
-211    user_id: Optional[str] = None
-212    avatar_url: Optional[str] = None
-213    organization: Optional[str] = None
-214
-215@dataclass
-216class IntegrationResult:
-217    """Result format sent from lambda wrapper to backend.
-218
-219    This class represents the standardized format that the lambda wrapper
-220    sends to the Autohive backend, including SDK version and type-specific data.
+182    When returned from an action handler, output schema validation is skipped
+183    and the error is returned to the caller as a ResultType.ERROR result.
+184
+185    Args:
+186        message: Human-readable error message
+187        cost_usd: Optional USD cost incurred before the error occurred
+188
+189    Example:
+190        ```python
+191        return ActionError(
+192            message="User not found",
+193            cost_usd=0.01
+194        )
+195        ```
+196    """
+197    message: str
+198    cost_usd: Optional[float] = None
+199
+200@dataclass
+201class ConnectedAccountInfo:
+202    """Account metadata returned by a ``ConnectedAccountHandler``.
+203
+204    The platform calls the connected-account handler after a user links
+205    their external account.  The returned info is displayed in the
+206    Autohive UI (avatar, name, email, etc.).
+207
+208    All fields are optional — populate whichever ones the external API provides.
+209    """
+210    email: Optional[str] = None
+211    first_name: Optional[str] = None
+212    last_name: Optional[str] = None
+213    username: Optional[str] = None
+214    user_id: Optional[str] = None
+215    avatar_url: Optional[str] = None
+216    organization: Optional[str] = None
+217
+218@dataclass
+219class IntegrationResult:
+220    """Result format sent from lambda wrapper to backend.
 221
-222    Args:
-223        version: SDK version (auto-populated)
-224        type: Type of result payload (ResultType enum: ACTION, CONNECTED_ACCOUNT, ERROR)
-225        result: The result object - ActionResult for actions, ActionError for
-226                application-level action errors, or ConnectedAccountInfo for
-227                connected accounts.
-228                The lambda wrapper serializes these to dicts using asdict().
-229
-230    Note:
-231        This type is returned by Integration methods and serialized by the lambda wrapper.
-232        Integration developers should use ActionResult for action handlers and
-233        ActionError for expected error conditions.
-234    """
-235    version: str
-236    type: ResultType
-237    result: Union[ActionResult, ActionError, ConnectedAccountInfo]
-238
-239# ---- Configuration Classes ----
-240
-241@dataclass
-242class Parameter:
-243    """Definition of a parameter"""
-244    name: str
-245    type: str
-246    description: str
-247    enum: Optional[List[str]] = None
-248    required: bool = True
-249    default: Any = None
-250
-251@dataclass
-252class SchemaDefinition:
-253    """Base class for components that have input/output schemas"""
-254    name: str
-255    description: str
-256    input_schema: List[Parameter]
-257    output_schema: Optional[Dict[str, Any]] = None
-258
-259@dataclass
-260class Action(SchemaDefinition):
-261    """Empty dataclass that inherits from SchemaDefinition"""
-262    pass
-263
-264@dataclass
-265class PollingTrigger(SchemaDefinition):
-266    """Definition of a polling trigger"""
-267    polling_interval: timedelta = field(default_factory=timedelta)
-268
-269@dataclass
-270class IntegrationConfig:
-271    """Configuration for an integration"""
-272    name: str
-273    version: str
-274    description: str
-275    auth: Dict[str, Any]
-276    actions: Dict[str, Action]
-277    polling_triggers: Dict[str, PollingTrigger]
-278
-279# ---- Base Handler Classes ----
-280class ActionHandler(ABC):
-281    """Base class for action handlers.
-282
-283    Subclass this and implement ``execute()`` to handle a specific action.
-284    Register it with the ``@integration.action("action_name")`` decorator.
+222    This class represents the standardized format that the lambda wrapper
+223    sends to the Autohive backend, including SDK version and type-specific data.
+224
+225    Args:
+226        version: SDK version (auto-populated)
+227        type: Type of result payload (ResultType enum: ACTION, CONNECTED_ACCOUNT, ERROR)
+228        result: The result object - ActionResult for actions, ActionError for
+229                application-level action errors, or ConnectedAccountInfo for
+230                connected accounts.
+231                The lambda wrapper serializes these to dicts using asdict().
+232
+233    Note:
+234        This type is returned by Integration methods and serialized by the lambda wrapper.
+235        Integration developers should use ActionResult for action handlers and
+236        ActionError for expected error conditions.
+237    """
+238    version: str
+239    type: ResultType
+240    result: Union[ActionResult, ActionError, ConnectedAccountInfo]
+241
+242# ---- Configuration Classes ----
+243
+244@dataclass
+245class Parameter:
+246    """Definition of a parameter"""
+247    name: str
+248    type: str
+249    description: str
+250    enum: Optional[List[str]] = None
+251    required: bool = True
+252    default: Any = None
+253
+254@dataclass
+255class SchemaDefinition:
+256    """Base class for components that have input/output schemas"""
+257    name: str
+258    description: str
+259    input_schema: List[Parameter]
+260    output_schema: Optional[Dict[str, Any]] = None
+261
+262@dataclass
+263class Action(SchemaDefinition):
+264    """Empty dataclass that inherits from SchemaDefinition"""
+265    pass
+266
+267@dataclass
+268class PollingTrigger(SchemaDefinition):
+269    """Definition of a polling trigger"""
+270    polling_interval: timedelta = field(default_factory=timedelta)
+271
+272@dataclass
+273class IntegrationConfig:
+274    """Configuration for an integration"""
+275    name: str
+276    version: str
+277    description: str
+278    auth: Dict[str, Any]
+279    actions: Dict[str, Action]
+280    polling_triggers: Dict[str, PollingTrigger]
+281
+282# ---- Base Handler Classes ----
+283class ActionHandler(ABC):
+284    """Base class for action handlers.
 285
-286    Example::
-287
-288        @integration.action("get_user")
-289        class GetUser(ActionHandler):
-290            async def execute(self, inputs, context):
-291                user = (await context.fetch(f"https://api.example.com/users/{inputs['id']}")).data
-292                return ActionResult(data=user)
-293    """
-294    @abstractmethod
-295    async def execute(self, inputs: Dict[str, Any], context: 'ExecutionContext') -> Any:
-296        """Run the action logic.
-297
-298        Args:
-299            inputs: Validated action inputs matching the ``input_schema`` from ``config.json``.
-300            context: Execution context providing ``fetch()``, ``auth``, and logging.
-301
-302        Returns:
-303            An ``ActionResult`` containing the output data and optional ``cost_usd``.
-304        """
-305        pass
-306
-307class PollingTriggerHandler(ABC):
-308    """Base class for polling trigger handlers"""
-309    @abstractmethod
-310    async def poll(self, inputs: Dict[str, Any], last_poll_ts: Optional[str], context: 'ExecutionContext') -> List[Dict[str, Any]]:
-311        """Execute the polling trigger"""
-312        pass
-313
-314class ConnectedAccountHandler(ABC):
-315    """Base class for connected-account handlers.
+286    Subclass this and implement ``execute()`` to handle a specific action.
+287    Register it with the ``@integration.action("action_name")`` decorator.
+288
+289    Example::
+290
+291        @integration.action("get_user")
+292        class GetUser(ActionHandler):
+293            async def execute(self, inputs, context):
+294                user = (await context.fetch(f"https://api.example.com/users/{inputs['id']}")).data
+295                return ActionResult(data=user)
+296    """
+297    @abstractmethod
+298    async def execute(self, inputs: Dict[str, Any], context: 'ExecutionContext') -> Any:
+299        """Run the action logic.
+300
+301        Args:
+302            inputs: Validated action inputs matching the ``input_schema`` from ``config.json``.
+303            context: Execution context providing ``fetch()``, ``auth``, and logging.
+304
+305        Returns:
+306            An ``ActionResult`` containing the output data and optional ``cost_usd``.
+307        """
+308        pass
+309
+310class PollingTriggerHandler(ABC):
+311    """Base class for polling trigger handlers"""
+312    @abstractmethod
+313    async def poll(self, inputs: Dict[str, Any], last_poll_ts: Optional[str], context: 'ExecutionContext') -> List[Dict[str, Any]]:
+314        """Execute the polling trigger"""
+315        pass
 316
-317    The platform calls this after a user links their external account.
-318    The returned ``ConnectedAccountInfo`` is shown in the Autohive UI.
+317class ConnectedAccountHandler(ABC):
+318    """Base class for connected-account handlers.
 319
-320    Register with the ``@integration.connected_account()`` decorator.
-321
-322    Example::
-323
-324        @integration.connected_account()
-325        class MyAccountHandler(ConnectedAccountHandler):
-326            async def get_account_info(self, context):
-327                me = (await context.fetch("https://api.example.com/me")).data
-328                return ConnectedAccountInfo(
-329                    email=me["email"],
-330                    first_name=me["first_name"],
-331                    last_name=me["last_name"],
-332                )
-333    """
-334    @abstractmethod
-335    async def get_account_info(self, context: 'ExecutionContext') -> ConnectedAccountInfo:
-336        """Fetch account metadata from the external service.
-337
-338        For platform OAuth integrations, ``context.fetch()`` auto-injects
-339        the Bearer token — no manual auth handling needed.
+320    The platform calls this after a user links their external account.
+321    The returned ``ConnectedAccountInfo`` is shown in the Autohive UI.
+322
+323    Register with the ``@integration.connected_account()`` decorator.
+324
+325    Example::
+326
+327        @integration.connected_account()
+328        class MyAccountHandler(ConnectedAccountHandler):
+329            async def get_account_info(self, context):
+330                me = (await context.fetch("https://api.example.com/me")).data
+331                return ConnectedAccountInfo(
+332                    email=me["email"],
+333                    first_name=me["first_name"],
+334                    last_name=me["last_name"],
+335                )
+336    """
+337    @abstractmethod
+338    async def get_account_info(self, context: 'ExecutionContext') -> ConnectedAccountInfo:
+339        """Fetch account metadata from the external service.
 340
-341        Returns:
-342            A ``ConnectedAccountInfo`` with whichever fields the API provides.
-343        """
-344        pass
-345
-346# ---- Core SDK Classes ----
-347class ExecutionContext:
-348    """Context provided to integration handlers for making authenticated HTTP requests.
-349
-350    Manages an ``aiohttp`` session with automatic retries, error handling, and
-351    optional Bearer-token injection for platform OAuth integrations.
+341        For platform OAuth integrations, ``context.fetch()`` auto-injects
+342        the Bearer token — no manual auth handling needed.
+343
+344        Returns:
+345            A ``ConnectedAccountInfo`` with whichever fields the API provides.
+346        """
+347        pass
+348
+349# ---- Core SDK Classes ----
+350class ExecutionContext:
+351    """Context provided to integration handlers for making authenticated HTTP requests.
 352
-353    Use as an async context manager::
-354
-355        async with ExecutionContext(auth=auth) as context:
-356            result = await integration.execute_action("my_action", inputs, context)
+353    Manages an ``aiohttp`` session with automatic retries, error handling, and
+354    optional Bearer-token injection for platform OAuth integrations.
+355
+356    Use as an async context manager::
 357
-358    Args:
-359        auth: Authentication data.  In **local tests** this is a flat dict
-360            matching the ``auth.fields`` schema in ``config.json``
-361            (e.g. ``{"api_key": "..."}``).  In **production** the platform
-362            wraps credentials as ``{"auth_type": "...", "credentials": {...}}``.
-363        request_config: Override default ``max_retries`` (3) and ``timeout`` (30 s).
-364        metadata: Arbitrary metadata forwarded to handlers.
-365        logger: Custom logger; falls back to ``logging.getLogger(__name__)``.
-366    """
-367    def __init__(
-368        self,
-369        auth: Dict[str, Any] = {}, 
-370        request_config: Optional[Dict[str, Any]] = None,
-371        metadata: Optional[Dict[str, Any]] = None,
-372        logger: Optional[logging.Logger] = None
-373    ):
-374        self.auth = auth
-375        """Authentication configuration"""
-376        self.config = request_config or {"max_retries": 3, "timeout": 30}
-377        """Request configuration"""
-378        self.metadata = metadata or {}
-379        """Additional metadata"""
-380        self.logger = logger or logging.getLogger(__name__)
-381        """Logger instance"""
-382        self._session: Optional[aiohttp.ClientSession] = None
-383
-384    async def __aenter__(self):
-385        if not self._session:
-386            self._session = aiohttp.ClientSession()
-387        return self
-388
-389    async def __aexit__(self, exc_type, exc_val, exc_tb):
-390        if self._session:
-391            await self._session.close()
-392            self._session = None
-393
-394    async def fetch(
-395            self,
-396            url: str,
-397            method: str = "GET",
-398            params: Optional[Dict[str, Any]] = None,
-399            data: Any = None,
-400            json: Any = None,
-401            headers: Optional[Dict[str, str]] = None,
-402            content_type: Optional[str] = None,
-403            timeout: Optional[int] = None,
-404            retry_count: int = 0
-405    ) -> FetchResponse:
-406        """Make an HTTP request with automatic retries and error handling.
-407
-408        For **platform OAuth** integrations (``auth_type == "PlatformOauth2"``),
-409        a ``Bearer`` token is auto-injected from ``auth.credentials.access_token``
-410        unless an ``Authorization`` header is explicitly provided.
-411
-412        Retries up to ``max_retries`` (default 3) on transient network errors
-413        with exponential back-off.  HTTP 429 responses raise ``RateLimitError``
-414        immediately (no automatic retry).
-415
-416        Args:
-417            url: The URL to request.
-418            method: HTTP method (``"GET"``, ``"POST"``, ``"PUT"``, etc.).
-419            params: Query parameters appended to the URL.  Nested dicts/lists
-420                are JSON-serialized automatically.
-421            data: Raw request body.  Encoding depends on ``content_type``.
-422            json: JSON-serializable payload.  Sets ``content_type`` to
-423                ``application/json`` automatically.
-424            headers: Additional HTTP headers.  Merged *after* any auto-injected
-425                auth header, so an explicit ``Authorization`` takes precedence.
-426            content_type: ``Content-Type`` header value.
-427            timeout: Per-request timeout in seconds (overrides ``request_config``).
-428            retry_count: Internal — current retry attempt number.
-429
-430        Returns:
-431            A ``FetchResponse`` containing the HTTP status code, response
-432            headers, and parsed body data.
-433
-434        Raises:
-435            RateLimitError: On HTTP 429 with the ``Retry-After`` value.
-436            HTTPError: On any other non-2xx status.
-437        """
-438        if not self._session:
-439            self._session = aiohttp.ClientSession()
-440
-441        # Prepare request
-442        if json is not None:
-443            data = json
-444            content_type = "application/json"
-445
-446        final_headers = {}
-447        
-448        if self.auth and "Authorization" not in (headers or {}):
-449            auth_type = AuthType(self.auth.get("auth_type", "PlatformOauth2"))
-450            credentials = self.auth.get("credentials", {})
-451            
-452            if auth_type == AuthType.PlatformOauth2 and "access_token" in credentials:
-453                final_headers["Authorization"] = f"Bearer {credentials['access_token']}"
-454
-455        if content_type:
-456            final_headers["Content-Type"] = content_type
-457        if headers:
-458            final_headers.update(headers)
-459
-460        if params:
-461            # Handle nested dictionary parameters
-462            flat_params = {}
-463            for key, value in params.items():
-464                if isinstance(value, (dict, list)):
-465                    flat_params[key] = jsonX.dumps(value)
-466                elif value is not None:
-467                    flat_params[key] = str(value)
-468            query_string = urlencode(flat_params)
-469            url = f"{url}{'&' if '?' in url else '?'}{query_string}"
-470
-471        # Prepare body
-472        if data is not None:
-473            if content_type == "application/json":
-474                data = jsonX.dumps(data)
-475            elif content_type == "application/x-www-form-urlencoded":
-476                data = urlencode(data) if isinstance(data, dict) else data
-477
-478        # Store the original timeout numeric value
-479        original_timeout = timeout or self.config["timeout"]
+358        async with ExecutionContext(auth=auth) as context:
+359            result = await integration.execute_action("my_action", inputs, context)
+360
+361    Args:
+362        auth: Authentication data.  In **local tests** this is a flat dict
+363            matching the ``auth.fields`` schema in ``config.json``
+364            (e.g. ``{"api_key": "..."}``).  In **production** the platform
+365            wraps credentials as ``{"auth_type": "...", "credentials": {...}}``.
+366        request_config: Override default ``max_retries`` (3) and ``timeout`` (30 s).
+367        metadata: Arbitrary metadata forwarded to handlers.
+368        logger: Custom logger; falls back to ``logging.getLogger(__name__)``.
+369    """
+370    def __init__(
+371        self,
+372        auth: Dict[str, Any] = {}, 
+373        request_config: Optional[Dict[str, Any]] = None,
+374        metadata: Optional[Dict[str, Any]] = None,
+375        logger: Optional[logging.Logger] = None
+376    ):
+377        self.auth = auth
+378        """Authentication configuration"""
+379        self.config = request_config or {"max_retries": 3, "timeout": 30}
+380        """Request configuration"""
+381        self.metadata = metadata or {}
+382        """Additional metadata"""
+383        self.logger = logger or logging.getLogger(__name__)
+384        """Logger instance"""
+385        self._session: Optional[aiohttp.ClientSession] = None
+386
+387    async def __aenter__(self):
+388        if not self._session:
+389            self._session = aiohttp.ClientSession()
+390        return self
+391
+392    async def __aexit__(self, exc_type, exc_val, exc_tb):
+393        if self._session:
+394            await self._session.close()
+395            self._session = None
+396
+397    async def fetch(
+398            self,
+399            url: str,
+400            method: str = "GET",
+401            params: Optional[Dict[str, Any]] = None,
+402            data: Any = None,
+403            json: Any = None,
+404            headers: Optional[Dict[str, str]] = None,
+405            content_type: Optional[str] = None,
+406            timeout: Optional[int] = None,
+407            retry_count: int = 0
+408    ) -> FetchResponse:
+409        """Make an HTTP request with automatic retries and error handling.
+410
+411        For **platform OAuth** integrations (``auth_type == "PlatformOauth2"``),
+412        a ``Bearer`` token is auto-injected from ``auth.credentials.access_token``
+413        unless an ``Authorization`` header is explicitly provided.
+414
+415        Retries up to ``max_retries`` (default 3) on transient network errors
+416        with exponential back-off.  HTTP 429 responses raise ``RateLimitError``
+417        immediately (no automatic retry).
+418
+419        Args:
+420            url: The URL to request.
+421            method: HTTP method (``"GET"``, ``"POST"``, ``"PUT"``, etc.).
+422            params: Query parameters appended to the URL.  Nested dicts/lists
+423                are JSON-serialized automatically.
+424            data: Raw request body.  Encoding depends on ``content_type``.
+425            json: JSON-serializable payload.  Sets ``content_type`` to
+426                ``application/json`` automatically.
+427            headers: Additional HTTP headers.  Merged *after* any auto-injected
+428                auth header, so an explicit ``Authorization`` takes precedence.
+429            content_type: ``Content-Type`` header value.
+430            timeout: Per-request timeout in seconds (overrides ``request_config``).
+431            retry_count: Internal — current retry attempt number.
+432
+433        Returns:
+434            A ``FetchResponse`` containing the HTTP status code, response
+435            headers, and parsed body data.
+436
+437        Raises:
+438            RateLimitError: On HTTP 429 with the ``Retry-After`` value.
+439            HTTPError: On any other non-2xx status.
+440        """
+441        if not self._session:
+442            self._session = aiohttp.ClientSession()
+443
+444        # Prepare request
+445        if json is not None:
+446            data = json
+447            content_type = "application/json"
+448
+449        final_headers = {}
+450        
+451        if self.auth and "Authorization" not in (headers or {}):
+452            auth_type = AuthType(self.auth.get("auth_type", "PlatformOauth2"))
+453            credentials = self.auth.get("credentials", {})
+454            
+455            if auth_type == AuthType.PlatformOauth2 and "access_token" in credentials:
+456                final_headers["Authorization"] = f"Bearer {credentials['access_token']}"
+457
+458        if content_type:
+459            final_headers["Content-Type"] = content_type
+460        if headers:
+461            final_headers.update(headers)
+462
+463        if params:
+464            # Handle nested dictionary parameters
+465            flat_params = {}
+466            for key, value in params.items():
+467                if isinstance(value, (dict, list)):
+468                    flat_params[key] = jsonX.dumps(value)
+469                elif value is not None:
+470                    flat_params[key] = str(value)
+471            query_string = urlencode(flat_params)
+472            url = f"{url}{'&' if '?' in url else '?'}{query_string}"
+473
+474        # Prepare body
+475        if data is not None:
+476            if content_type == "application/json":
+477                data = jsonX.dumps(data)
+478            elif content_type == "application/x-www-form-urlencoded":
+479                data = urlencode(data) if isinstance(data, dict) else data
 480
-481        # Convert the numeric timeout to a ClientTimeout instance for this request
-482        client_timeout = aiohttp.ClientTimeout(total=original_timeout)
+481        # Store the original timeout numeric value
+482        original_timeout = timeout or self.config["timeout"]
 483
-484        try:
-485            async with self._session.request(
-486                method=method,
-487                url=url,
-488                data=data,
-489                headers=final_headers,
-490                timeout=client_timeout,
-491                ssl=True
-492            ) as response:
-493                content_type = response.headers.get("Content-Type", "")
-494
-495                if response.status == 429:  # Rate limit
-496                    retry_after = int(response.headers.get("Retry-After", 60))
-497                    raise RateLimitError(
-498                        retry_after,
-499                        response.status,
-500                        "Rate limit exceeded",
-501                        await response.text()
-502                    )
-503
-504                try:
-505                    if "application/json" in content_type:
-506                        result = await response.json()
-507                    else:
-508                        result = await response.text()
-509                        if not result and response.status in {200, 201, 204}:
-510                            result = None
-511                except Exception as e:
-512                    self.logger.error(f"Error parsing response: {e}")
-513                    result = await response.text()
-514
-515                response_headers = dict(response.headers)
-516
-517                if not response.ok:
-518                    print(f"HTTP error encountered. Status: {response.status}. Result: {result}")
-519                    raise HTTPError(response.status, str(result), result)
-520
-521                return FetchResponse(
-522                    status=response.status,
-523                    headers=response_headers,
-524                    data=result,
-525                )
-526
-527        except RateLimitError:
-528            raise
-529        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-530            # Don't want to send this to Raygun here because this will be retried.
-531            print(f"Error encountered: {e}. Retry count: {retry_count}. Backing off.")
-532            if retry_count < self.config["max_retries"]:
-533                await asyncio.sleep(2 ** retry_count)  # Exponential backoff
-534                print("Retrying request...")
-535                # Use original_timeout (numeric) for recursive calls
-536                return await self.fetch(
-537                    url, method, params, data, json,
-538                    headers, content_type, original_timeout, retry_count + 1
-539                )
-540            else:
-541                print("Max retries reached. Raising error.")
-542                raise
-543        except Exception as e:
-544            self.logger.error(f"Unexpected error during {method} {url}: {e}")
-545            print(f"Unexpected error encountered: {e}")
-546            raise
-547
-548
-549class Integration:
-550    """Base integration class with handler registration and execution.
-551    
-552    This class manages the integration configuration, handler registration,
-553    and provides methods to execute actions and triggers.
+484        # Convert the numeric timeout to a ClientTimeout instance for this request
+485        client_timeout = aiohttp.ClientTimeout(total=original_timeout)
+486
+487        try:
+488            async with self._session.request(
+489                method=method,
+490                url=url,
+491                data=data,
+492                headers=final_headers,
+493                timeout=client_timeout,
+494                ssl=True
+495            ) as response:
+496                content_type = response.headers.get("Content-Type", "")
+497
+498                if response.status == 429:  # Rate limit
+499                    retry_after = int(response.headers.get("Retry-After", 60))
+500                    raise RateLimitError(
+501                        retry_after,
+502                        response.status,
+503                        "Rate limit exceeded",
+504                        await response.text()
+505                    )
+506
+507                try:
+508                    if "application/json" in content_type:
+509                        result = await response.json()
+510                    else:
+511                        result = await response.text()
+512                        if not result and response.status in {200, 201, 204}:
+513                            result = None
+514                except Exception as e:
+515                    self.logger.error(f"Error parsing response: {e}")
+516                    result = await response.text()
+517
+518                response_headers = dict(response.headers)
+519
+520                if not response.ok:
+521                    print(f"HTTP error encountered. Status: {response.status}. Result: {result}")
+522                    raise HTTPError(response.status, str(result), result)
+523
+524                return FetchResponse(
+525                    status=response.status,
+526                    headers=response_headers,
+527                    data=result,
+528                )
+529
+530        except RateLimitError:
+531            raise
+532        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+533            # Don't want to send this to Raygun here because this will be retried.
+534            print(f"Error encountered: {e}. Retry count: {retry_count}. Backing off.")
+535            if retry_count < self.config["max_retries"]:
+536                await asyncio.sleep(2 ** retry_count)  # Exponential backoff
+537                print("Retrying request...")
+538                # Use original_timeout (numeric) for recursive calls
+539                return await self.fetch(
+540                    url, method, params, data, json,
+541                    headers, content_type, original_timeout, retry_count + 1
+542                )
+543            else:
+544                print("Max retries reached. Raising error.")
+545                raise
+546        except Exception as e:
+547            self.logger.error(f"Unexpected error during {method} {url}: {e}")
+548            print(f"Unexpected error encountered: {e}")
+549            raise
+550
+551
+552class Integration:
+553    """Base integration class with handler registration and execution.
 554    
-555    Args:
-556        config: Integration configuration
-557        
-558    Attributes:
+555    This class manages the integration configuration, handler registration,
+556    and provides methods to execute actions and triggers.
+557    
+558    Args:
 559        config: Integration configuration
-560    """
-561
-562    def __init__(self, config: IntegrationConfig):
-563        self.config = config
-564        """Integration configuration"""
-565        self._action_handlers: Dict[str, Type[ActionHandler]] = {}
-566        """Action handlers"""
-567        self._polling_handlers: Dict[str, Type[PollingTriggerHandler]] = {}
-568        """Polling handlers"""
-569        self._connected_account_handler: Optional[Type[ConnectedAccountHandler]] = None
-570        """Connected account handler"""
-571
-572    @classmethod
-573    def load(cls, config_path: Union[str, Path] = None) -> 'Integration':
-574        """Load an integration from its ``config.json``.
-575
-576        Args:
-577            config_path: Explicit path to ``config.json``.  When omitted the
-578                SDK resolves the path relative to its own package location,
-579                which works when the SDK is vendored via
-580                ``pip install --target dependencies``.  Multi-file integrations
-581                that use ``actions/`` sub-packages should pass an explicit path
-582                (e.g. ``Integration.load("config.json")``).
-583
-584        Returns:
-585            A fully initialised ``Integration`` ready for handler registration.
+560        
+561    Attributes:
+562        config: Integration configuration
+563    """
+564
+565    def __init__(self, config: IntegrationConfig):
+566        self.config = config
+567        """Integration configuration"""
+568        self._action_handlers: Dict[str, Type[ActionHandler]] = {}
+569        """Action handlers"""
+570        self._polling_handlers: Dict[str, Type[PollingTriggerHandler]] = {}
+571        """Polling handlers"""
+572        self._connected_account_handler: Optional[Type[ConnectedAccountHandler]] = None
+573        """Connected account handler"""
+574
+575    @classmethod
+576    def load(cls, config_path: Union[str, Path] = None) -> 'Integration':
+577        """Load an integration from its ``config.json``.
+578
+579        Args:
+580            config_path: Explicit path to ``config.json``.  When omitted the
+581                SDK resolves the path relative to its own package location,
+582                which works when the SDK is vendored via
+583                ``pip install --target dependencies``.  Multi-file integrations
+584                that use ``actions/`` sub-packages should pass an explicit path
+585                (e.g. ``Integration.load("config.json")``).
 586
-587        Raises:
-588            ConfigurationError: If the file is missing or contains invalid JSON.
-589        """
-590        if config_path is None:
-591            config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'config.json')
-592        
-593        config_path = Path(config_path)
-594
-595        if not config_path.exists():
-596            raise ConfigurationError(f"Configuration file not found: {config_path}")
+587        Returns:
+588            A fully initialised ``Integration`` ready for handler registration.
+589
+590        Raises:
+591            ConfigurationError: If the file is missing or contains invalid JSON.
+592        """
+593        if config_path is None:
+594            config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'config.json')
+595        
+596        config_path = Path(config_path)
 597
-598        try:
-599            with open(config_path, 'r') as f:
-600                config_data = json.load(f)
-601        except json.JSONDecodeError as e:
-602            raise ConfigurationError(f"Invalid JSON configuration: {e}")
-603        
-604        # Parse configuration sections
-605        actions = cls._parse_actions(config_data.get("actions", {}))
-606        polling_triggers = cls._parse_polling_triggers(config_data.get("polling_triggers", {}))
-607
-608        config = IntegrationConfig(
-609            name=config_data["name"],
-610            version=config_data["version"],
-611            description=config_data["description"],
-612            auth=config_data.get("auth", {}),
-613            actions=actions,
-614            polling_triggers=polling_triggers
-615        )
-616
-617        return cls(config)
-618
-619    @staticmethod
-620    def _parse_interval(interval_str: str) -> timedelta:
-621        """Parse interval string into timedelta"""
-622        unit = interval_str[-1].lower()
-623        value = int(interval_str[:-1])
-624
-625        if unit == 's':
-626            return timedelta(seconds=value)
-627        elif unit == 'm':
-628            return timedelta(minutes=value)
-629        elif unit == 'h':
-630            return timedelta(hours=value)
-631        elif unit == 'd':
-632            return timedelta(days=value)
-633        else:
-634            raise ConfigurationError(f"Invalid interval format: {interval_str}")
-635
-636    @classmethod
-637    def _parse_actions(cls, actions_config: Dict[str, Any]) -> Dict[str, Action]:
-638        """Parse action configurations"""
-639        actions = {}
-640        for name, data in actions_config.items():
-641            actions[name] = Action(
-642                name=name,
-643                description=data["description"],
-644                input_schema=data["input_schema"],
-645                output_schema=data["output_schema"]
-646            )
-647
-648        return actions
-649
-650    @classmethod
-651    def _parse_polling_triggers(cls, triggers_config: Dict[str, Any]) -> Dict[str, PollingTrigger]:
-652        """Parse polling trigger configurations"""
-653        triggers = {}
-654        for name, data in triggers_config.items():
-655            interval = cls._parse_interval(data["polling_interval"])
-656
-657            triggers[name] = PollingTrigger(
-658                name=name,
-659                description=data["description"],
-660                polling_interval=interval,
-661                input_schema=data["input_schema"],
-662                output_schema=data["output_schema"]
-663            )
-664
-665        return triggers
-666
-667    def action(self, name: str):
-668        """Decorator to register an action handler.
-669        
-670        Args:
-671            name: Name of the action to register
-672            
-673        Returns:
-674            Decorator function
+598        if not config_path.exists():
+599            raise ConfigurationError(f"Configuration file not found: {config_path}")
+600
+601        try:
+602            with open(config_path, 'r') as f:
+603                config_data = json.load(f)
+604        except json.JSONDecodeError as e:
+605            raise ConfigurationError(f"Invalid JSON configuration: {e}")
+606        
+607        # Parse configuration sections
+608        actions = cls._parse_actions(config_data.get("actions", {}))
+609        polling_triggers = cls._parse_polling_triggers(config_data.get("polling_triggers", {}))
+610
+611        config = IntegrationConfig(
+612            name=config_data["name"],
+613            version=config_data["version"],
+614            description=config_data["description"],
+615            auth=config_data.get("auth", {}),
+616            actions=actions,
+617            polling_triggers=polling_triggers
+618        )
+619
+620        return cls(config)
+621
+622    @staticmethod
+623    def _parse_interval(interval_str: str) -> timedelta:
+624        """Parse interval string into timedelta"""
+625        unit = interval_str[-1].lower()
+626        value = int(interval_str[:-1])
+627
+628        if unit == 's':
+629            return timedelta(seconds=value)
+630        elif unit == 'm':
+631            return timedelta(minutes=value)
+632        elif unit == 'h':
+633            return timedelta(hours=value)
+634        elif unit == 'd':
+635            return timedelta(days=value)
+636        else:
+637            raise ConfigurationError(f"Invalid interval format: {interval_str}")
+638
+639    @classmethod
+640    def _parse_actions(cls, actions_config: Dict[str, Any]) -> Dict[str, Action]:
+641        """Parse action configurations"""
+642        actions = {}
+643        for name, data in actions_config.items():
+644            actions[name] = Action(
+645                name=name,
+646                description=data["description"],
+647                input_schema=data["input_schema"],
+648                output_schema=data["output_schema"]
+649            )
+650
+651        return actions
+652
+653    @classmethod
+654    def _parse_polling_triggers(cls, triggers_config: Dict[str, Any]) -> Dict[str, PollingTrigger]:
+655        """Parse polling trigger configurations"""
+656        triggers = {}
+657        for name, data in triggers_config.items():
+658            interval = cls._parse_interval(data["polling_interval"])
+659
+660            triggers[name] = PollingTrigger(
+661                name=name,
+662                description=data["description"],
+663                polling_interval=interval,
+664                input_schema=data["input_schema"],
+665                output_schema=data["output_schema"]
+666            )
+667
+668        return triggers
+669
+670    def action(self, name: str):
+671        """Decorator to register an action handler.
+672        
+673        Args:
+674            name: Name of the action to register
 675            
-676        Raises:
-677            ConfigurationError: If action is not defined in config
+676        Returns:
+677            Decorator function
 678            
-679        Example:
-680            ```python
-681            @integration.action("my_action")
-682            class MyActionHandler(ActionHandler):
-683                async def execute(self, inputs, context):
-684                    # Implementation
-685                    return result
-686            ```
-687        """
-688        def decorator(handler_class: Type[ActionHandler]):
-689            if name not in self.config.actions:
-690                raise ConfigurationError(f"Action '{name}' not defined in config")
-691            self._action_handlers[name] = handler_class
-692            return handler_class
-693        return decorator
-694
-695    def polling_trigger(self, name: str):
-696        """Decorator to register a polling trigger handler
-697        
-698        Args:
-699            name: Name of the polling trigger to register
-700            
-701        Returns:
-702            Decorator function
-703        
-704        Raises:
-705            ConfigurationError: If polling trigger is not defined in config
-706
-707        Example:
-708            ```python
-709            @integration.polling_trigger("my_polling_trigger")
-710            class MyPollingTriggerHandler(PollingTriggerHandler):
-711                async def poll(self, inputs, last_poll_ts, context):
-712                    # Implementation
-713                    return result
-714            ```
-715        """
-716        def decorator(handler_class: Type[PollingTriggerHandler]):
-717            if name not in self.config.polling_triggers:
-718                raise ConfigurationError(f"Polling trigger '{name}' not defined in config")
-719            self._polling_handlers[name] = handler_class
-720            return handler_class
-721        return decorator
-722
-723    def connected_account(self):
-724        """Decorator to register a connected account handler
-725        
-726        Returns:
-727            Decorator function
-728
-729        Example:
-730            ```python
-731            @integration.connected_account()
-732            class MyConnectedAccountHandler(ConnectedAccountHandler):
-733                async def get_account_info(self, context):
-734                    # Implementation
-735                    return {"email": "user@example.com", "name": "John Doe"}
-736            ```
-737        """
-738        def decorator(handler_class: Type[ConnectedAccountHandler]):
-739            self._connected_account_handler = handler_class
-740            return handler_class
-741        return decorator
-742
-743    async def execute_action(self,
-744                           name: str,
-745                           inputs: Dict[str, Any],
-746                           context: ExecutionContext) -> IntegrationResult:
-747        """Execute a registered action.
-748
-749        Args:
-750            name: Name of the action to execute
-751            inputs: Action inputs
-752            context: Execution context
-753
-754        Returns:
-755            IntegrationResult with action data (ResultType.ACTION),
-756            action error (ResultType.ACTION_ERROR) if the handler returned ActionError,
-757            or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
-758        """
-759        try:
-760            if name not in self._action_handlers:
-761                raise ValidationError(f"Action '{name}' not registered")
-762
-763            # Validate inputs against action schema
-764            action_config = self.config.actions[name]
-765            validator = Draft7Validator(action_config.input_schema)
-766            errors = sorted(validator.iter_errors(inputs), key=lambda e: e.path)
-767            if errors:
-768                message = ""
-769                for error in errors:
-770                    message += f"{list(error.schema_path)}, {error.message},\n "
-771                raise ValidationError(message, action_config.input_schema, inputs, source="input")
-772
-773            if "fields" in self.config.auth:
-774                auth_config = self.config.auth["fields"]
-775                validator = Draft7Validator(auth_config)
-776                errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
-777                if errors:
-778                    message = ""
-779                    for error in errors:
-780                        message += f"{list(error.schema_path)}, {error.message},\n "
-781                    raise ValidationError(message, auth_config, context.auth, source="input")
-782
-783            # Create handler instance and execute
-784            handler = self._action_handlers[name]()
-785            result = await handler.execute(inputs, context)
-786
-787            # Handle ActionError - skip output schema validation
-788            if isinstance(result, ActionError):
-789                return IntegrationResult(
-790                    version=__version__,
-791                    type=ResultType.ACTION_ERROR,
-792                    result=result
-793                )
-794
-795            # Validate that result is ActionResult
-796            if not isinstance(result, ActionResult):
-797                raise ValidationError(
-798                    f"Action handler '{name}' must return ActionResult or ActionError, got {type(result).__name__}",
-799                    source="output"
-800                )
-801
-802            # Validate output schema against the data inside ActionResult
-803            validator = Draft7Validator(action_config.output_schema)
-804            errors = sorted(validator.iter_errors(result.data), key=lambda e: e.path)
-805            if errors:
-806                message = ""
-807                for error in errors:
-808                    message += f"{list(error.schema_path)}, {error.message},\n "
-809                raise ValidationError(message, action_config.output_schema, result.data, source="output")
-810
-811            # Return IntegrationResult with ActionResult directly
-812            return IntegrationResult(
-813                version=__version__,
-814                type=ResultType.ACTION,
-815                result=result
-816            )
-817        except ValidationError as e:
-818            return IntegrationResult(
-819                version=__version__,
-820                type=ResultType.VALIDATION_ERROR,
-821                result={
-822                    'message': str(e),
-823                    'property': None,
-824                    'value': None,
-825                    'source': getattr(e, 'source', 'legacy')
-826                }
-827            )
-828
-829    async def execute_polling_trigger(self,
-830                                    name: str,
-831                                    inputs: Dict[str, Any],
-832                                    last_poll_ts: Optional[str],
-833                                    context: ExecutionContext) -> List[Dict[str, Any]]:
-834        """Execute a registered polling trigger
-835        
-836        Args:
-837            name: Name of the polling trigger to execute
-838            inputs: Trigger inputs
-839            last_poll_ts: Last poll timestamp
-840            context: Execution context
-841            
-842        Returns:
-843            List of records
+679        Raises:
+680            ConfigurationError: If action is not defined in config
+681            
+682        Example:
+683            ```python
+684            @integration.action("my_action")
+685            class MyActionHandler(ActionHandler):
+686                async def execute(self, inputs, context):
+687                    # Implementation
+688                    return result
+689            ```
+690        """
+691        def decorator(handler_class: Type[ActionHandler]):
+692            if name not in self.config.actions:
+693                raise ConfigurationError(f"Action '{name}' not defined in config")
+694            self._action_handlers[name] = handler_class
+695            return handler_class
+696        return decorator
+697
+698    def polling_trigger(self, name: str):
+699        """Decorator to register a polling trigger handler
+700        
+701        Args:
+702            name: Name of the polling trigger to register
+703            
+704        Returns:
+705            Decorator function
+706        
+707        Raises:
+708            ConfigurationError: If polling trigger is not defined in config
+709
+710        Example:
+711            ```python
+712            @integration.polling_trigger("my_polling_trigger")
+713            class MyPollingTriggerHandler(PollingTriggerHandler):
+714                async def poll(self, inputs, last_poll_ts, context):
+715                    # Implementation
+716                    return result
+717            ```
+718        """
+719        def decorator(handler_class: Type[PollingTriggerHandler]):
+720            if name not in self.config.polling_triggers:
+721                raise ConfigurationError(f"Polling trigger '{name}' not defined in config")
+722            self._polling_handlers[name] = handler_class
+723            return handler_class
+724        return decorator
+725
+726    def connected_account(self):
+727        """Decorator to register a connected account handler
+728        
+729        Returns:
+730            Decorator function
+731
+732        Example:
+733            ```python
+734            @integration.connected_account()
+735            class MyConnectedAccountHandler(ConnectedAccountHandler):
+736                async def get_account_info(self, context):
+737                    # Implementation
+738                    return {"email": "user@example.com", "name": "John Doe"}
+739            ```
+740        """
+741        def decorator(handler_class: Type[ConnectedAccountHandler]):
+742            self._connected_account_handler = handler_class
+743            return handler_class
+744        return decorator
+745
+746    async def execute_action(self,
+747                           name: str,
+748                           inputs: Dict[str, Any],
+749                           context: ExecutionContext) -> IntegrationResult:
+750        """Execute a registered action.
+751
+752        Args:
+753            name: Name of the action to execute
+754            inputs: Action inputs
+755            context: Execution context
+756
+757        Returns:
+758            IntegrationResult with action data (ResultType.ACTION),
+759            action error (ResultType.ACTION_ERROR) if the handler returned ActionError,
+760            or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
+761        """
+762        try:
+763            if name not in self._action_handlers:
+764                raise ValidationError(f"Action '{name}' not registered")
+765
+766            # Validate inputs against action schema
+767            action_config = self.config.actions[name]
+768            validator = Draft7Validator(action_config.input_schema)
+769            errors = sorted(validator.iter_errors(inputs), key=lambda e: e.path)
+770            if errors:
+771                message = ""
+772                for error in errors:
+773                    message += f"{list(error.schema_path)}, {error.message},\n "
+774                raise ValidationError(message, action_config.input_schema, inputs, source="input")
+775
+776            if "fields" in self.config.auth:
+777                auth_config = self.config.auth["fields"]
+778                validator = Draft7Validator(auth_config)
+779                errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
+780                if errors:
+781                    message = ""
+782                    for error in errors:
+783                        message += f"{list(error.schema_path)}, {error.message},\n "
+784                    raise ValidationError(message, auth_config, context.auth, source="input")
+785
+786            # Create handler instance and execute
+787            handler = self._action_handlers[name]()
+788            result = await handler.execute(inputs, context)
+789
+790            # Handle ActionError - skip output schema validation
+791            if isinstance(result, ActionError):
+792                return IntegrationResult(
+793                    version=__version__,
+794                    type=ResultType.ACTION_ERROR,
+795                    result=result
+796                )
+797
+798            # Validate that result is ActionResult
+799            if not isinstance(result, ActionResult):
+800                raise ValidationError(
+801                    f"Action handler '{name}' must return ActionResult or ActionError, got {type(result).__name__}",
+802                    source="output"
+803                )
+804
+805            # Validate output schema against the data inside ActionResult
+806            validator = Draft7Validator(action_config.output_schema)
+807            errors = sorted(validator.iter_errors(result.data), key=lambda e: e.path)
+808            if errors:
+809                message = ""
+810                for error in errors:
+811                    message += f"{list(error.schema_path)}, {error.message},\n "
+812                raise ValidationError(message, action_config.output_schema, result.data, source="output")
+813
+814            # Return IntegrationResult with ActionResult directly
+815            return IntegrationResult(
+816                version=__version__,
+817                type=ResultType.ACTION,
+818                result=result
+819            )
+820        except ValidationError as e:
+821            return IntegrationResult(
+822                version=__version__,
+823                type=ResultType.VALIDATION_ERROR,
+824                result={
+825                    'message': str(e),
+826                    'property': None,
+827                    'value': None,
+828                    'source': getattr(e, 'source', 'legacy')
+829                }
+830            )
+831
+832    async def execute_polling_trigger(self,
+833                                    name: str,
+834                                    inputs: Dict[str, Any],
+835                                    last_poll_ts: Optional[str],
+836                                    context: ExecutionContext) -> List[Dict[str, Any]]:
+837        """Execute a registered polling trigger
+838        
+839        Args:
+840            name: Name of the polling trigger to execute
+841            inputs: Trigger inputs
+842            last_poll_ts: Last poll timestamp
+843            context: Execution context
 844            
-845        Raises:
-846            ValidationError: If inputs or outputs don't match schema
-847        """
-848        if name not in self._polling_handlers:
-849            raise ValidationError(f"Polling trigger '{name}' not registered")
-850
-851        # Validate trigger configuration
-852        trigger_config = self.config.polling_triggers[name]
-853        try:
-854            validate(inputs, trigger_config.input_schema)
-855        except Exception as e:
-856            raise ValidationError(e.message, e.schema, e.instance)
-857
-858        try:
-859            auth_config = self.config.auth["fields"]
-860            validate(context.auth, auth_config)
-861        except Exception as e:
-862            raise ValidationError(e.message, e.schema, e.instance)
-863        
-864        # Create handler instance and execute
-865        handler = self._polling_handlers[name]()
-866        records = await handler.poll(inputs, last_poll_ts, context)
-867        # Validate each record
-868        for record in records:
-869            if "id" not in record:
-870                raise ValidationError(
-871                    f"Polling trigger '{name}' returned record without required 'id' field")
-872            if "data" not in record:
+845        Returns:
+846            List of records
+847            
+848        Raises:
+849            ValidationError: If inputs or outputs don't match schema
+850        """
+851        if name not in self._polling_handlers:
+852            raise ValidationError(f"Polling trigger '{name}' not registered")
+853
+854        # Validate trigger configuration
+855        trigger_config = self.config.polling_triggers[name]
+856        try:
+857            validate(inputs, trigger_config.input_schema)
+858        except Exception as e:
+859            raise ValidationError(e.message, e.schema, e.instance)
+860
+861        try:
+862            auth_config = self.config.auth["fields"]
+863            validate(context.auth, auth_config)
+864        except Exception as e:
+865            raise ValidationError(e.message, e.schema, e.instance)
+866        
+867        # Create handler instance and execute
+868        handler = self._polling_handlers[name]()
+869        records = await handler.poll(inputs, last_poll_ts, context)
+870        # Validate each record
+871        for record in records:
+872            if "id" not in record:
 873                raise ValidationError(
-874                    f"Polling trigger '{name}' returned record without required 'data' field")
-875
-876            # Validate record data against output schema
-877            try:
-878                validate(record["data"], trigger_config.output_schema)
-879            except Exception as e:
-880                raise ValidationError(e.message, e.schema, e.instance)
-881            
-882        return records
-883
-884    async def get_connected_account(self, context: ExecutionContext) -> IntegrationResult:
-885        """Get connected account information
+874                    f"Polling trigger '{name}' returned record without required 'id' field")
+875            if "data" not in record:
+876                raise ValidationError(
+877                    f"Polling trigger '{name}' returned record without required 'data' field")
+878
+879            # Validate record data against output schema
+880            try:
+881                validate(record["data"], trigger_config.output_schema)
+882            except Exception as e:
+883                raise ValidationError(e.message, e.schema, e.instance)
+884            
+885        return records
 886
-887        Args:
-888            context: Execution context
+887    async def get_connected_account(self, context: ExecutionContext) -> IntegrationResult:
+888        """Get connected account information
 889
-890        Returns:
-891            IntegrationResult containing connected account data
+890        Args:
+891            context: Execution context
 892
-893        Raises:
-894            ValidationError: If no connected account handler is registered or auth is invalid
-895        """
-896        if not self._connected_account_handler:
-897            raise ValidationError("No connected account handler registered")
-898
-899        if "fields" in self.config.auth:
-900            auth_config = self.config.auth["fields"]
-901            validator = Draft7Validator(auth_config)
-902            errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
-903            if errors:
-904                message = ""
-905                for error in errors:
-906                    message += f"{list(error.schema_path)}, {error.message},\n "
-907                raise ValidationError(message, auth_config, context.auth)
-908
-909        handler = self._connected_account_handler()
-910        account_info = await handler.get_account_info(context)
+893        Returns:
+894            IntegrationResult containing connected account data
+895
+896        Raises:
+897            ValidationError: If no connected account handler is registered or auth is invalid
+898        """
+899        if not self._connected_account_handler:
+900            raise ValidationError("No connected account handler registered")
+901
+902        if "fields" in self.config.auth:
+903            auth_config = self.config.auth["fields"]
+904            validator = Draft7Validator(auth_config)
+905            errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
+906            if errors:
+907                message = ""
+908                for error in errors:
+909                    message += f"{list(error.schema_path)}, {error.message},\n "
+910                raise ValidationError(message, auth_config, context.auth)
 911
-912        if not isinstance(account_info, ConnectedAccountInfo):
-913            raise ValidationError(
-914                f"Connected account handler must return ConnectedAccountInfo, got {type(account_info).__name__}"
-915            )
-916
-917        # Return IntegrationResult with ConnectedAccountInfo object directly
-918        return IntegrationResult(
-919            version=__version__,
-920            type=ResultType.CONNECTED_ACCOUNT,
-921            result=account_info
-922        )
+912        handler = self._connected_account_handler()
+913        account_info = await handler.get_account_info(context)
+914
+915        if not isinstance(account_info, ConnectedAccountInfo):
+916            raise ValidationError(
+917                f"Connected account handler must return ConnectedAccountInfo, got {type(account_info).__name__}"
+918            )
+919
+920        # Return IntegrationResult with ConnectedAccountInfo object directly
+921        return IntegrationResult(
+922            version=__version__,
+923            type=ResultType.CONNECTED_ACCOUNT,
+924            result=account_info
+925        )
    @@ -1389,28 +1395,28 @@

    - 
    54class AuthType(Enum):
-55    """Authentication strategy used by an integration.
-56
-57    The platform stores the auth type alongside credentials and passes both
-58    to ``ExecutionContext``.  ``context.fetch()`` uses the type to decide
-59    whether to auto-inject an ``Authorization`` header.
-60
-61    Members:
-62        PlatformOauth2: Platform-managed OAuth 2.0 — the platform handles the
-63            token lifecycle and injects ``Bearer <access_token>`` automatically.
-64        PlatformTeams: Platform-managed Microsoft Teams auth.
-65        ApiKey: A single API key provided by the user.
-66        Basic: Username/password (HTTP Basic) credentials.
-67        Custom: Free-form credential fields defined by the integration's
-68            ``config.json`` auth schema.  The integration is responsible for
-69            reading individual fields from ``context.auth``.
-70    """
-71    PlatformOauth2 = "PlatformOauth2"
-72    PlatformTeams = "PlatformTeams"
-73    ApiKey = "ApiKey"
-74    Basic = "Basic"
-75    Custom = "Custom"
+            
    57class AuthType(Enum):
+58    """Authentication strategy used by an integration.
+59
+60    The platform stores the auth type alongside credentials and passes both
+61    to ``ExecutionContext``.  ``context.fetch()`` uses the type to decide
+62    whether to auto-inject an ``Authorization`` header.
+63
+64    Members:
+65        PlatformOauth2: Platform-managed OAuth 2.0 — the platform handles the
+66            token lifecycle and injects ``Bearer <access_token>`` automatically.
+67        PlatformTeams: Platform-managed Microsoft Teams auth.
+68        ApiKey: A single API key provided by the user.
+69        Basic: Username/password (HTTP Basic) credentials.
+70        Custom: Free-form credential fields defined by the integration's
+71            ``config.json`` auth schema.  The integration is responsible for
+72            reading individual fields from ``context.auth``.
+73    """
+74    PlatformOauth2 = "PlatformOauth2"
+75    PlatformTeams = "PlatformTeams"
+76    ApiKey = "ApiKey"
+77    Basic = "Basic"
+78    Custom = "Custom"
 
    
 
 
@@ -1504,13 +1510,13 @@
    - 
    77class ResultType(Enum):
-78    """Type of result being returned"""
-79    ACTION = "action"
-80    ACTION_ERROR = "action_error"
-81    CONNECTED_ACCOUNT = "connected_account"
-82    ERROR = "error"
-83    VALIDATION_ERROR = "validation_error"
+            
    80class ResultType(Enum):
+81    """Type of result being returned"""
+82    ACTION = "action"
+83    ACTION_ERROR = "action_error"
+84    CONNECTED_ACCOUNT = "connected_account"
+85    ERROR = "error"
+86    VALIDATION_ERROR = "validation_error"
 
    
 
 
@@ -1590,27 +1596,27 @@
    - 
     86class ValidationError(Exception):
- 87    """Raised when SDK validation fails.
- 88
- 89    This covers several cases:
- 90
- 91    - Action inputs don't match the ``input_schema`` in ``config.json``
- 92    - Action outputs don't match the ``output_schema``
- 93    - Auth credentials don't match the ``auth.fields`` schema
- 94    - An action handler returns something other than ``ActionResult``
- 95    - A handler name isn't registered
- 96    """
- 97    def __init__(self, message: str, schema: str = None, inputs: str = None, source: str = "legacy"):
- 98        self.schema = schema
- 99        """The schema that failed validation"""
-100        self.inputs = inputs
-101        """The data that failed validation"""
-102        self.message = message
-103        """The error message"""
-104        self.source = source
-105        """Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)"""
-106        super().__init__(message)
+            
     89class ValidationError(Exception):
+ 90    """Raised when SDK validation fails.
+ 91
+ 92    This covers several cases:
+ 93
+ 94    - Action inputs don't match the ``input_schema`` in ``config.json``
+ 95    - Action outputs don't match the ``output_schema``
+ 96    - Auth credentials don't match the ``auth.fields`` schema
+ 97    - An action handler returns something other than ``ActionResult``
+ 98    - A handler name isn't registered
+ 99    """
+100    def __init__(self, message: str, schema: str = None, inputs: str = None, source: str = "legacy"):
+101        self.schema = schema
+102        """The schema that failed validation"""
+103        self.inputs = inputs
+104        """The data that failed validation"""
+105        self.message = message
+106        """The error message"""
+107        self.source = source
+108        """Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)"""
+109        super().__init__(message)
 
    
 
 
@@ -1638,16 +1644,16 @@
    - 
     97    def __init__(self, message: str, schema: str = None, inputs: str = None, source: str = "legacy"):
- 98        self.schema = schema
- 99        """The schema that failed validation"""
-100        self.inputs = inputs
-101        """The data that failed validation"""
-102        self.message = message
-103        """The error message"""
-104        self.source = source
-105        """Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)"""
-106        super().__init__(message)
+            
    100    def __init__(self, message: str, schema: str = None, inputs: str = None, source: str = "legacy"):
+101        self.schema = schema
+102        """The schema that failed validation"""
+103        self.inputs = inputs
+104        """The data that failed validation"""
+105        self.message = message
+106        """The error message"""
+107        self.source = source
+108        """Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)"""
+109        super().__init__(message)
 
    
 
 
@@ -1718,9 +1724,9 @@
    - 
    108class ConfigurationError(Exception):
-109    """Raised when integration configuration is invalid"""
-110    pass
+            
    111class ConfigurationError(Exception):
+112    """Raised when integration configuration is invalid"""
+113    pass
 
    
 
 
@@ -1740,16 +1746,16 @@
    - 
    112class HTTPError(Exception):
-113    """Raised by ``ExecutionContext.fetch()`` for non-2xx HTTP responses (except 429)."""
-114    def __init__(self, status: int, message: str, response_data: Any = None):
-115        self.status = status
-116        """Status code"""
-117        self.message = message
-118        """Error message"""
-119        self.response_data = response_data
-120        """Response data"""
-121        super().__init__(f"HTTP {status}: {message}")
+            
    115class HTTPError(Exception):
+116    """Raised by ``ExecutionContext.fetch()`` for non-2xx HTTP responses (except 429)."""
+117    def __init__(self, status: int, message: str, response_data: Any = None):
+118        self.status = status
+119        """Status code"""
+120        self.message = message
+121        """Error message"""
+122        self.response_data = response_data
+123        """Response data"""
+124        super().__init__(f"HTTP {status}: {message}")
 
    
 
 
@@ -1767,14 +1773,14 @@
    - 
    114    def __init__(self, status: int, message: str, response_data: Any = None):
-115        self.status = status
-116        """Status code"""
-117        self.message = message
-118        """Error message"""
-119        self.response_data = response_data
-120        """Response data"""
-121        super().__init__(f"HTTP {status}: {message}")
+            
    117    def __init__(self, status: int, message: str, response_data: Any = None):
+118        self.status = status
+119        """Status code"""
+120        self.message = message
+121        """Error message"""
+122        self.response_data = response_data
+123        """Response data"""
+124        super().__init__(f"HTTP {status}: {message}")
 
    
 
 
@@ -1832,17 +1838,17 @@
    - 
    123class RateLimitError(HTTPError):
-124    """Raised by ``ExecutionContext.fetch()`` on HTTP 429 (Too Many Requests).
-125
-126    Attributes:
-127        retry_after: Seconds to wait before retrying, taken from the
-128            ``Retry-After`` response header (defaults to 60 if absent).
-129    """
-130    def __init__(self, retry_after: int, *args, **kwargs):
-131        self.retry_after = retry_after
-132        """Seconds to wait before retrying."""
-133        super().__init__(*args, **kwargs)
+            
    126class RateLimitError(HTTPError):
+127    """Raised by ``ExecutionContext.fetch()`` on HTTP 429 (Too Many Requests).
+128
+129    Attributes:
+130        retry_after: Seconds to wait before retrying, taken from the
+131            ``Retry-After`` response header (defaults to 60 if absent).
+132    """
+133    def __init__(self, retry_after: int, *args, **kwargs):
+134        self.retry_after = retry_after
+135        """Seconds to wait before retrying."""
+136        super().__init__(*args, **kwargs)
 
    
 
 
@@ -1864,10 +1870,10 @@
    - 
    130    def __init__(self, retry_after: int, *args, **kwargs):
-131        self.retry_after = retry_after
-132        """Seconds to wait before retrying."""
-133        super().__init__(*args, **kwargs)
+            
    133    def __init__(self, retry_after: int, *args, **kwargs):
+134        self.retry_after = retry_after
+135        """Seconds to wait before retrying."""
+136        super().__init__(*args, **kwargs)
 
    
 
 
@@ -1911,23 +1917,23 @@ 
    Inherited Members
    - 
    136@dataclass
-137class FetchResponse:
-138    """Response object returned by ``ExecutionContext.fetch()``.
-139
-140    Wraps the full HTTP response so callers can inspect status codes and
-141    headers in addition to the parsed body.
+            
    139@dataclass
+140class FetchResponse:
+141    """Response object returned by ``ExecutionContext.fetch()``.
 142
-143    Attributes:
-144        status: HTTP status code (e.g. ``200``, ``201``).
-145        headers: Response headers as a plain ``dict``.
-146        data: Parsed JSON (``dict``/``list``) when the response is
-147            ``application/json``, otherwise the raw response text.
-148            ``None`` for empty 200/201/204 responses.
-149    """
-150    status: int
-151    headers: Dict[str, str]
-152    data: Any
+143    Wraps the full HTTP response so callers can inspect status codes and
+144    headers in addition to the parsed body.
+145
+146    Attributes:
+147        status: HTTP status code (e.g. ``200``, ``201``).
+148        headers: Response headers as a plain ``dict``.
+149        data: Parsed JSON (``dict``/``list``) when the response is
+150            ``application/json``, otherwise the raw response text.
+151            ``None`` for empty 200/201/204 responses.
+152    """
+153    status: int
+154    headers: Dict[str, str]
+155    data: Any
 
    
 
 
@@ -2003,27 +2009,27 @@ 
    Inherited Members
    - 
    154@dataclass
-155class ActionResult:
-156    """Result returned by action handlers.
-157
-158    This class encapsulates the data returned by an action along with optional
-159    billing information for cost tracking.
+            
    157@dataclass
+158class ActionResult:
+159    """Result returned by action handlers.
 160
-161    Args:
-162        data: The actual result data from the action
-163        cost_usd: Optional USD cost for billing purposes
-164
-165    Example:
-166        ```python
-167        return ActionResult(
-168            data={"message": "Success", "result": 42},
-169            cost_usd=0.05
-170        )
-171        ```
-172    """
-173    data: Any
-174    cost_usd: Optional[float] = None
+161    This class encapsulates the data returned by an action along with optional
+162    billing information for cost tracking.
+163
+164    Args:
+165        data: The actual result data from the action
+166        cost_usd: Optional USD cost for billing purposes
+167
+168    Example:
+169        ```python
+170        return ActionResult(
+171            data={"message": "Success", "result": 42},
+172            cost_usd=0.05
+173        )
+174        ```
+175    """
+176    data: Any
+177    cost_usd: Optional[float] = None
 
    
 
 
@@ -2097,27 +2103,27 @@ 
    Inherited Members
    - 
    176@dataclass
-177class ActionError:
-178    """Error result returned by action handlers for expected/application-level errors.
-179
-180    When returned from an action handler, output schema validation is skipped
-181    and the error is returned to the caller as a ResultType.ERROR result.
+            
    179@dataclass
+180class ActionError:
+181    """Error result returned by action handlers for expected/application-level errors.
 182
-183    Args:
-184        message: Human-readable error message
-185        cost_usd: Optional USD cost incurred before the error occurred
-186
-187    Example:
-188        ```python
-189        return ActionError(
-190            message="User not found",
-191            cost_usd=0.01
-192        )
-193        ```
-194    """
-195    message: str
-196    cost_usd: Optional[float] = None
+183    When returned from an action handler, output schema validation is skipped
+184    and the error is returned to the caller as a ResultType.ERROR result.
+185
+186    Args:
+187        message: Human-readable error message
+188        cost_usd: Optional USD cost incurred before the error occurred
+189
+190    Example:
+191        ```python
+192        return ActionError(
+193            message="User not found",
+194            cost_usd=0.01
+195        )
+196        ```
+197    """
+198    message: str
+199    cost_usd: Optional[float] = None
 
    
 
 
@@ -2191,23 +2197,23 @@ 
    Inherited Members
    - 
    198@dataclass
-199class ConnectedAccountInfo:
-200    """Account metadata returned by a ``ConnectedAccountHandler``.
-201
-202    The platform calls the connected-account handler after a user links
-203    their external account.  The returned info is displayed in the
-204    Autohive UI (avatar, name, email, etc.).
-205
-206    All fields are optional — populate whichever ones the external API provides.
-207    """
-208    email: Optional[str] = None
-209    first_name: Optional[str] = None
-210    last_name: Optional[str] = None
-211    username: Optional[str] = None
-212    user_id: Optional[str] = None
-213    avatar_url: Optional[str] = None
-214    organization: Optional[str] = None
+            
    201@dataclass
+202class ConnectedAccountInfo:
+203    """Account metadata returned by a ``ConnectedAccountHandler``.
+204
+205    The platform calls the connected-account handler after a user links
+206    their external account.  The returned info is displayed in the
+207    Autohive UI (avatar, name, email, etc.).
+208
+209    All fields are optional — populate whichever ones the external API provides.
+210    """
+211    email: Optional[str] = None
+212    first_name: Optional[str] = None
+213    last_name: Optional[str] = None
+214    username: Optional[str] = None
+215    user_id: Optional[str] = None
+216    avatar_url: Optional[str] = None
+217    organization: Optional[str] = None
 
    
 
 
@@ -2330,29 +2336,29 @@ 
    Inherited Members
    - 
    216@dataclass
-217class IntegrationResult:
-218    """Result format sent from lambda wrapper to backend.
-219
-220    This class represents the standardized format that the lambda wrapper
-221    sends to the Autohive backend, including SDK version and type-specific data.
+            
    219@dataclass
+220class IntegrationResult:
+221    """Result format sent from lambda wrapper to backend.
 222
-223    Args:
-224        version: SDK version (auto-populated)
-225        type: Type of result payload (ResultType enum: ACTION, CONNECTED_ACCOUNT, ERROR)
-226        result: The result object - ActionResult for actions, ActionError for
-227                application-level action errors, or ConnectedAccountInfo for
-228                connected accounts.
-229                The lambda wrapper serializes these to dicts using asdict().
-230
-231    Note:
-232        This type is returned by Integration methods and serialized by the lambda wrapper.
-233        Integration developers should use ActionResult for action handlers and
-234        ActionError for expected error conditions.
-235    """
-236    version: str
-237    type: ResultType
-238    result: Union[ActionResult, ActionError, ConnectedAccountInfo]
+223    This class represents the standardized format that the lambda wrapper
+224    sends to the Autohive backend, including SDK version and type-specific data.
+225
+226    Args:
+227        version: SDK version (auto-populated)
+228        type: Type of result payload (ResultType enum: ACTION, CONNECTED_ACCOUNT, ERROR)
+229        result: The result object - ActionResult for actions, ActionError for
+230                application-level action errors, or ConnectedAccountInfo for
+231                connected accounts.
+232                The lambda wrapper serializes these to dicts using asdict().
+233
+234    Note:
+235        This type is returned by Integration methods and serialized by the lambda wrapper.
+236        Integration developers should use ActionResult for action handlers and
+237        ActionError for expected error conditions.
+238    """
+239    version: str
+240    type: ResultType
+241    result: Union[ActionResult, ActionError, ConnectedAccountInfo]
 
    
 
 
@@ -2434,15 +2440,15 @@ 
    Inherited Members
    - 
    242@dataclass
-243class Parameter:
-244    """Definition of a parameter"""
-245    name: str
-246    type: str
-247    description: str
-248    enum: Optional[List[str]] = None
-249    required: bool = True
-250    default: Any = None
+            
    245@dataclass
+246class Parameter:
+247    """Definition of a parameter"""
+248    name: str
+249    type: str
+250    description: str
+251    enum: Optional[List[str]] = None
+252    required: bool = True
+253    default: Any = None
 
    
 
 
@@ -2544,13 +2550,13 @@ 
    Inherited Members
    - 
    252@dataclass
-253class SchemaDefinition:
-254    """Base class for components that have input/output schemas"""
-255    name: str
-256    description: str
-257    input_schema: List[Parameter]
-258    output_schema: Optional[Dict[str, Any]] = None
+            
    255@dataclass
+256class SchemaDefinition:
+257    """Base class for components that have input/output schemas"""
+258    name: str
+259    description: str
+260    input_schema: List[Parameter]
+261    output_schema: Optional[Dict[str, Any]] = None
 
    
 
 
@@ -2628,10 +2634,10 @@ 
    Inherited Members
    - 
    260@dataclass
-261class Action(SchemaDefinition):
-262    """Empty dataclass that inherits from SchemaDefinition"""
-263    pass
+            
    263@dataclass
+264class Action(SchemaDefinition):
+265    """Empty dataclass that inherits from SchemaDefinition"""
+266    pass
 
    
 
 
@@ -2676,10 +2682,10 @@ 
    Inherited Members
    - 
    265@dataclass
-266class PollingTrigger(SchemaDefinition):
-267    """Definition of a polling trigger"""
-268    polling_interval: timedelta = field(default_factory=timedelta)
+            
    268@dataclass
+269class PollingTrigger(SchemaDefinition):
+270    """Definition of a polling trigger"""
+271    polling_interval: timedelta = field(default_factory=timedelta)
 
    
 
 
@@ -2735,15 +2741,15 @@ 
    Inherited Members
    - 
    270@dataclass
-271class IntegrationConfig:
-272    """Configuration for an integration"""
-273    name: str
-274    version: str
-275    description: str
-276    auth: Dict[str, Any]
-277    actions: Dict[str, Action]
-278    polling_triggers: Dict[str, PollingTrigger]
+            
    273@dataclass
+274class IntegrationConfig:
+275    """Configuration for an integration"""
+276    name: str
+277    version: str
+278    description: str
+279    auth: Dict[str, Any]
+280    actions: Dict[str, Action]
+281    polling_triggers: Dict[str, PollingTrigger]
 
    
 
 
@@ -2841,32 +2847,32 @@ 
    Inherited Members
    - 
    281class ActionHandler(ABC):
-282    """Base class for action handlers.
-283
-284    Subclass this and implement ``execute()`` to handle a specific action.
-285    Register it with the ``@integration.action("action_name")`` decorator.
+            
    284class ActionHandler(ABC):
+285    """Base class for action handlers.
 286
-287    Example::
-288
-289        @integration.action("get_user")
-290        class GetUser(ActionHandler):
-291            async def execute(self, inputs, context):
-292                user = (await context.fetch(f"https://api.example.com/users/{inputs['id']}")).data
-293                return ActionResult(data=user)
-294    """
-295    @abstractmethod
-296    async def execute(self, inputs: Dict[str, Any], context: 'ExecutionContext') -> Any:
-297        """Run the action logic.
-298
-299        Args:
-300            inputs: Validated action inputs matching the ``input_schema`` from ``config.json``.
-301            context: Execution context providing ``fetch()``, ``auth``, and logging.
-302
-303        Returns:
-304            An ``ActionResult`` containing the output data and optional ``cost_usd``.
-305        """
-306        pass
+287    Subclass this and implement ``execute()`` to handle a specific action.
+288    Register it with the ``@integration.action("action_name")`` decorator.
+289
+290    Example::
+291
+292        @integration.action("get_user")
+293        class GetUser(ActionHandler):
+294            async def execute(self, inputs, context):
+295                user = (await context.fetch(f"https://api.example.com/users/{inputs['id']}")).data
+296                return ActionResult(data=user)
+297    """
+298    @abstractmethod
+299    async def execute(self, inputs: Dict[str, Any], context: 'ExecutionContext') -> Any:
+300        """Run the action logic.
+301
+302        Args:
+303            inputs: Validated action inputs matching the ``input_schema`` from ``config.json``.
+304            context: Execution context providing ``fetch()``, ``auth``, and logging.
+305
+306        Returns:
+307            An ``ActionResult`` containing the output data and optional ``cost_usd``.
+308        """
+309        pass
 
    
 
 
@@ -2898,18 +2904,18 @@ 
    Inherited Members
    - 
    295    @abstractmethod
-296    async def execute(self, inputs: Dict[str, Any], context: 'ExecutionContext') -> Any:
-297        """Run the action logic.
-298
-299        Args:
-300            inputs: Validated action inputs matching the ``input_schema`` from ``config.json``.
-301            context: Execution context providing ``fetch()``, ``auth``, and logging.
-302
-303        Returns:
-304            An ``ActionResult`` containing the output data and optional ``cost_usd``.
-305        """
-306        pass
+            
    298    @abstractmethod
+299    async def execute(self, inputs: Dict[str, Any], context: 'ExecutionContext') -> Any:
+300        """Run the action logic.
+301
+302        Args:
+303            inputs: Validated action inputs matching the ``input_schema`` from ``config.json``.
+304            context: Execution context providing ``fetch()``, ``auth``, and logging.
+305
+306        Returns:
+307            An ``ActionResult`` containing the output data and optional ``cost_usd``.
+308        """
+309        pass
 
    
 
 
@@ -2937,12 +2943,12 @@ 
    Inherited Members
    - 
    308class PollingTriggerHandler(ABC):
-309    """Base class for polling trigger handlers"""
-310    @abstractmethod
-311    async def poll(self, inputs: Dict[str, Any], last_poll_ts: Optional[str], context: 'ExecutionContext') -> List[Dict[str, Any]]:
-312        """Execute the polling trigger"""
-313        pass
+            
    311class PollingTriggerHandler(ABC):
+312    """Base class for polling trigger handlers"""
+313    @abstractmethod
+314    async def poll(self, inputs: Dict[str, Any], last_poll_ts: Optional[str], context: 'ExecutionContext') -> List[Dict[str, Any]]:
+315        """Execute the polling trigger"""
+316        pass
 
    
 
 
@@ -2962,10 +2968,10 @@ 
    Inherited Members
    - 
    310    @abstractmethod
-311    async def poll(self, inputs: Dict[str, Any], last_poll_ts: Optional[str], context: 'ExecutionContext') -> List[Dict[str, Any]]:
-312        """Execute the polling trigger"""
-313        pass
+            
    313    @abstractmethod
+314    async def poll(self, inputs: Dict[str, Any], last_poll_ts: Optional[str], context: 'ExecutionContext') -> List[Dict[str, Any]]:
+315        """Execute the polling trigger"""
+316        pass
 
    
 
 
@@ -2986,37 +2992,37 @@ 
    Inherited Members
    - 
    315class ConnectedAccountHandler(ABC):
-316    """Base class for connected-account handlers.
-317
-318    The platform calls this after a user links their external account.
-319    The returned ``ConnectedAccountInfo`` is shown in the Autohive UI.
+            
    318class ConnectedAccountHandler(ABC):
+319    """Base class for connected-account handlers.
 320
-321    Register with the ``@integration.connected_account()`` decorator.
-322
-323    Example::
-324
-325        @integration.connected_account()
-326        class MyAccountHandler(ConnectedAccountHandler):
-327            async def get_account_info(self, context):
-328                me = (await context.fetch("https://api.example.com/me")).data
-329                return ConnectedAccountInfo(
-330                    email=me["email"],
-331                    first_name=me["first_name"],
-332                    last_name=me["last_name"],
-333                )
-334    """
-335    @abstractmethod
-336    async def get_account_info(self, context: 'ExecutionContext') -> ConnectedAccountInfo:
-337        """Fetch account metadata from the external service.
-338
-339        For platform OAuth integrations, ``context.fetch()`` auto-injects
-340        the Bearer token — no manual auth handling needed.
+321    The platform calls this after a user links their external account.
+322    The returned ``ConnectedAccountInfo`` is shown in the Autohive UI.
+323
+324    Register with the ``@integration.connected_account()`` decorator.
+325
+326    Example::
+327
+328        @integration.connected_account()
+329        class MyAccountHandler(ConnectedAccountHandler):
+330            async def get_account_info(self, context):
+331                me = (await context.fetch("https://api.example.com/me")).data
+332                return ConnectedAccountInfo(
+333                    email=me["email"],
+334                    first_name=me["first_name"],
+335                    last_name=me["last_name"],
+336                )
+337    """
+338    @abstractmethod
+339    async def get_account_info(self, context: 'ExecutionContext') -> ConnectedAccountInfo:
+340        """Fetch account metadata from the external service.
 341
-342        Returns:
-343            A ``ConnectedAccountInfo`` with whichever fields the API provides.
-344        """
-345        pass
+342        For platform OAuth integrations, ``context.fetch()`` auto-injects
+343        the Bearer token — no manual auth handling needed.
+344
+345        Returns:
+346            A ``ConnectedAccountInfo`` with whichever fields the API provides.
+347        """
+348        pass
 
    
 
 
@@ -3054,17 +3060,17 @@ 
    Inherited Members
    - 
    335    @abstractmethod
-336    async def get_account_info(self, context: 'ExecutionContext') -> ConnectedAccountInfo:
-337        """Fetch account metadata from the external service.
-338
-339        For platform OAuth integrations, ``context.fetch()`` auto-injects
-340        the Bearer token — no manual auth handling needed.
+            
    338    @abstractmethod
+339    async def get_account_info(self, context: 'ExecutionContext') -> ConnectedAccountInfo:
+340        """Fetch account metadata from the external service.
 341
-342        Returns:
-343            A ``ConnectedAccountInfo`` with whichever fields the API provides.
-344        """
-345        pass
+342        For platform OAuth integrations, ``context.fetch()`` auto-injects
+343        the Bearer token — no manual auth handling needed.
+344
+345        Returns:
+346            A ``ConnectedAccountInfo`` with whichever fields the API provides.
+347        """
+348        pass
 
    
 
 
@@ -3091,206 +3097,206 @@ 
    Inherited Members
    - 
    348class ExecutionContext:
-349    """Context provided to integration handlers for making authenticated HTTP requests.
-350
-351    Manages an ``aiohttp`` session with automatic retries, error handling, and
-352    optional Bearer-token injection for platform OAuth integrations.
+            
    351class ExecutionContext:
+352    """Context provided to integration handlers for making authenticated HTTP requests.
 353
-354    Use as an async context manager::
-355
-356        async with ExecutionContext(auth=auth) as context:
-357            result = await integration.execute_action("my_action", inputs, context)
+354    Manages an ``aiohttp`` session with automatic retries, error handling, and
+355    optional Bearer-token injection for platform OAuth integrations.
+356
+357    Use as an async context manager::
 358
-359    Args:
-360        auth: Authentication data.  In **local tests** this is a flat dict
-361            matching the ``auth.fields`` schema in ``config.json``
-362            (e.g. ``{"api_key": "..."}``).  In **production** the platform
-363            wraps credentials as ``{"auth_type": "...", "credentials": {...}}``.
-364        request_config: Override default ``max_retries`` (3) and ``timeout`` (30 s).
-365        metadata: Arbitrary metadata forwarded to handlers.
-366        logger: Custom logger; falls back to ``logging.getLogger(__name__)``.
-367    """
-368    def __init__(
-369        self,
-370        auth: Dict[str, Any] = {}, 
-371        request_config: Optional[Dict[str, Any]] = None,
-372        metadata: Optional[Dict[str, Any]] = None,
-373        logger: Optional[logging.Logger] = None
-374    ):
-375        self.auth = auth
-376        """Authentication configuration"""
-377        self.config = request_config or {"max_retries": 3, "timeout": 30}
-378        """Request configuration"""
-379        self.metadata = metadata or {}
-380        """Additional metadata"""
-381        self.logger = logger or logging.getLogger(__name__)
-382        """Logger instance"""
-383        self._session: Optional[aiohttp.ClientSession] = None
-384
-385    async def __aenter__(self):
-386        if not self._session:
-387            self._session = aiohttp.ClientSession()
-388        return self
-389
-390    async def __aexit__(self, exc_type, exc_val, exc_tb):
-391        if self._session:
-392            await self._session.close()
-393            self._session = None
-394
-395    async def fetch(
-396            self,
-397            url: str,
-398            method: str = "GET",
-399            params: Optional[Dict[str, Any]] = None,
-400            data: Any = None,
-401            json: Any = None,
-402            headers: Optional[Dict[str, str]] = None,
-403            content_type: Optional[str] = None,
-404            timeout: Optional[int] = None,
-405            retry_count: int = 0
-406    ) -> FetchResponse:
-407        """Make an HTTP request with automatic retries and error handling.
-408
-409        For **platform OAuth** integrations (``auth_type == "PlatformOauth2"``),
-410        a ``Bearer`` token is auto-injected from ``auth.credentials.access_token``
-411        unless an ``Authorization`` header is explicitly provided.
-412
-413        Retries up to ``max_retries`` (default 3) on transient network errors
-414        with exponential back-off.  HTTP 429 responses raise ``RateLimitError``
-415        immediately (no automatic retry).
-416
-417        Args:
-418            url: The URL to request.
-419            method: HTTP method (``"GET"``, ``"POST"``, ``"PUT"``, etc.).
-420            params: Query parameters appended to the URL.  Nested dicts/lists
-421                are JSON-serialized automatically.
-422            data: Raw request body.  Encoding depends on ``content_type``.
-423            json: JSON-serializable payload.  Sets ``content_type`` to
-424                ``application/json`` automatically.
-425            headers: Additional HTTP headers.  Merged *after* any auto-injected
-426                auth header, so an explicit ``Authorization`` takes precedence.
-427            content_type: ``Content-Type`` header value.
-428            timeout: Per-request timeout in seconds (overrides ``request_config``).
-429            retry_count: Internal — current retry attempt number.
-430
-431        Returns:
-432            A ``FetchResponse`` containing the HTTP status code, response
-433            headers, and parsed body data.
-434
-435        Raises:
-436            RateLimitError: On HTTP 429 with the ``Retry-After`` value.
-437            HTTPError: On any other non-2xx status.
-438        """
-439        if not self._session:
-440            self._session = aiohttp.ClientSession()
-441
-442        # Prepare request
-443        if json is not None:
-444            data = json
-445            content_type = "application/json"
-446
-447        final_headers = {}
-448        
-449        if self.auth and "Authorization" not in (headers or {}):
-450            auth_type = AuthType(self.auth.get("auth_type", "PlatformOauth2"))
-451            credentials = self.auth.get("credentials", {})
-452            
-453            if auth_type == AuthType.PlatformOauth2 and "access_token" in credentials:
-454                final_headers["Authorization"] = f"Bearer {credentials['access_token']}"
-455
-456        if content_type:
-457            final_headers["Content-Type"] = content_type
-458        if headers:
-459            final_headers.update(headers)
-460
-461        if params:
-462            # Handle nested dictionary parameters
-463            flat_params = {}
-464            for key, value in params.items():
-465                if isinstance(value, (dict, list)):
-466                    flat_params[key] = jsonX.dumps(value)
-467                elif value is not None:
-468                    flat_params[key] = str(value)
-469            query_string = urlencode(flat_params)
-470            url = f"{url}{'&' if '?' in url else '?'}{query_string}"
-471
-472        # Prepare body
-473        if data is not None:
-474            if content_type == "application/json":
-475                data = jsonX.dumps(data)
-476            elif content_type == "application/x-www-form-urlencoded":
-477                data = urlencode(data) if isinstance(data, dict) else data
-478
-479        # Store the original timeout numeric value
-480        original_timeout = timeout or self.config["timeout"]
+359        async with ExecutionContext(auth=auth) as context:
+360            result = await integration.execute_action("my_action", inputs, context)
+361
+362    Args:
+363        auth: Authentication data.  In **local tests** this is a flat dict
+364            matching the ``auth.fields`` schema in ``config.json``
+365            (e.g. ``{"api_key": "..."}``).  In **production** the platform
+366            wraps credentials as ``{"auth_type": "...", "credentials": {...}}``.
+367        request_config: Override default ``max_retries`` (3) and ``timeout`` (30 s).
+368        metadata: Arbitrary metadata forwarded to handlers.
+369        logger: Custom logger; falls back to ``logging.getLogger(__name__)``.
+370    """
+371    def __init__(
+372        self,
+373        auth: Dict[str, Any] = {}, 
+374        request_config: Optional[Dict[str, Any]] = None,
+375        metadata: Optional[Dict[str, Any]] = None,
+376        logger: Optional[logging.Logger] = None
+377    ):
+378        self.auth = auth
+379        """Authentication configuration"""
+380        self.config = request_config or {"max_retries": 3, "timeout": 30}
+381        """Request configuration"""
+382        self.metadata = metadata or {}
+383        """Additional metadata"""
+384        self.logger = logger or logging.getLogger(__name__)
+385        """Logger instance"""
+386        self._session: Optional[aiohttp.ClientSession] = None
+387
+388    async def __aenter__(self):
+389        if not self._session:
+390            self._session = aiohttp.ClientSession()
+391        return self
+392
+393    async def __aexit__(self, exc_type, exc_val, exc_tb):
+394        if self._session:
+395            await self._session.close()
+396            self._session = None
+397
+398    async def fetch(
+399            self,
+400            url: str,
+401            method: str = "GET",
+402            params: Optional[Dict[str, Any]] = None,
+403            data: Any = None,
+404            json: Any = None,
+405            headers: Optional[Dict[str, str]] = None,
+406            content_type: Optional[str] = None,
+407            timeout: Optional[int] = None,
+408            retry_count: int = 0
+409    ) -> FetchResponse:
+410        """Make an HTTP request with automatic retries and error handling.
+411
+412        For **platform OAuth** integrations (``auth_type == "PlatformOauth2"``),
+413        a ``Bearer`` token is auto-injected from ``auth.credentials.access_token``
+414        unless an ``Authorization`` header is explicitly provided.
+415
+416        Retries up to ``max_retries`` (default 3) on transient network errors
+417        with exponential back-off.  HTTP 429 responses raise ``RateLimitError``
+418        immediately (no automatic retry).
+419
+420        Args:
+421            url: The URL to request.
+422            method: HTTP method (``"GET"``, ``"POST"``, ``"PUT"``, etc.).
+423            params: Query parameters appended to the URL.  Nested dicts/lists
+424                are JSON-serialized automatically.
+425            data: Raw request body.  Encoding depends on ``content_type``.
+426            json: JSON-serializable payload.  Sets ``content_type`` to
+427                ``application/json`` automatically.
+428            headers: Additional HTTP headers.  Merged *after* any auto-injected
+429                auth header, so an explicit ``Authorization`` takes precedence.
+430            content_type: ``Content-Type`` header value.
+431            timeout: Per-request timeout in seconds (overrides ``request_config``).
+432            retry_count: Internal — current retry attempt number.
+433
+434        Returns:
+435            A ``FetchResponse`` containing the HTTP status code, response
+436            headers, and parsed body data.
+437
+438        Raises:
+439            RateLimitError: On HTTP 429 with the ``Retry-After`` value.
+440            HTTPError: On any other non-2xx status.
+441        """
+442        if not self._session:
+443            self._session = aiohttp.ClientSession()
+444
+445        # Prepare request
+446        if json is not None:
+447            data = json
+448            content_type = "application/json"
+449
+450        final_headers = {}
+451        
+452        if self.auth and "Authorization" not in (headers or {}):
+453            auth_type = AuthType(self.auth.get("auth_type", "PlatformOauth2"))
+454            credentials = self.auth.get("credentials", {})
+455            
+456            if auth_type == AuthType.PlatformOauth2 and "access_token" in credentials:
+457                final_headers["Authorization"] = f"Bearer {credentials['access_token']}"
+458
+459        if content_type:
+460            final_headers["Content-Type"] = content_type
+461        if headers:
+462            final_headers.update(headers)
+463
+464        if params:
+465            # Handle nested dictionary parameters
+466            flat_params = {}
+467            for key, value in params.items():
+468                if isinstance(value, (dict, list)):
+469                    flat_params[key] = jsonX.dumps(value)
+470                elif value is not None:
+471                    flat_params[key] = str(value)
+472            query_string = urlencode(flat_params)
+473            url = f"{url}{'&' if '?' in url else '?'}{query_string}"
+474
+475        # Prepare body
+476        if data is not None:
+477            if content_type == "application/json":
+478                data = jsonX.dumps(data)
+479            elif content_type == "application/x-www-form-urlencoded":
+480                data = urlencode(data) if isinstance(data, dict) else data
 481
-482        # Convert the numeric timeout to a ClientTimeout instance for this request
-483        client_timeout = aiohttp.ClientTimeout(total=original_timeout)
+482        # Store the original timeout numeric value
+483        original_timeout = timeout or self.config["timeout"]
 484
-485        try:
-486            async with self._session.request(
-487                method=method,
-488                url=url,
-489                data=data,
-490                headers=final_headers,
-491                timeout=client_timeout,
-492                ssl=True
-493            ) as response:
-494                content_type = response.headers.get("Content-Type", "")
-495
-496                if response.status == 429:  # Rate limit
-497                    retry_after = int(response.headers.get("Retry-After", 60))
-498                    raise RateLimitError(
-499                        retry_after,
-500                        response.status,
-501                        "Rate limit exceeded",
-502                        await response.text()
-503                    )
-504
-505                try:
-506                    if "application/json" in content_type:
-507                        result = await response.json()
-508                    else:
-509                        result = await response.text()
-510                        if not result and response.status in {200, 201, 204}:
-511                            result = None
-512                except Exception as e:
-513                    self.logger.error(f"Error parsing response: {e}")
-514                    result = await response.text()
-515
-516                response_headers = dict(response.headers)
-517
-518                if not response.ok:
-519                    print(f"HTTP error encountered. Status: {response.status}. Result: {result}")
-520                    raise HTTPError(response.status, str(result), result)
-521
-522                return FetchResponse(
-523                    status=response.status,
-524                    headers=response_headers,
-525                    data=result,
-526                )
-527
-528        except RateLimitError:
-529            raise
-530        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-531            # Don't want to send this to Raygun here because this will be retried.
-532            print(f"Error encountered: {e}. Retry count: {retry_count}. Backing off.")
-533            if retry_count < self.config["max_retries"]:
-534                await asyncio.sleep(2 ** retry_count)  # Exponential backoff
-535                print("Retrying request...")
-536                # Use original_timeout (numeric) for recursive calls
-537                return await self.fetch(
-538                    url, method, params, data, json,
-539                    headers, content_type, original_timeout, retry_count + 1
-540                )
-541            else:
-542                print("Max retries reached. Raising error.")
-543                raise
-544        except Exception as e:
-545            self.logger.error(f"Unexpected error during {method} {url}: {e}")
-546            print(f"Unexpected error encountered: {e}")
-547            raise
+485        # Convert the numeric timeout to a ClientTimeout instance for this request
+486        client_timeout = aiohttp.ClientTimeout(total=original_timeout)
+487
+488        try:
+489            async with self._session.request(
+490                method=method,
+491                url=url,
+492                data=data,
+493                headers=final_headers,
+494                timeout=client_timeout,
+495                ssl=True
+496            ) as response:
+497                content_type = response.headers.get("Content-Type", "")
+498
+499                if response.status == 429:  # Rate limit
+500                    retry_after = int(response.headers.get("Retry-After", 60))
+501                    raise RateLimitError(
+502                        retry_after,
+503                        response.status,
+504                        "Rate limit exceeded",
+505                        await response.text()
+506                    )
+507
+508                try:
+509                    if "application/json" in content_type:
+510                        result = await response.json()
+511                    else:
+512                        result = await response.text()
+513                        if not result and response.status in {200, 201, 204}:
+514                            result = None
+515                except Exception as e:
+516                    self.logger.error(f"Error parsing response: {e}")
+517                    result = await response.text()
+518
+519                response_headers = dict(response.headers)
+520
+521                if not response.ok:
+522                    print(f"HTTP error encountered. Status: {response.status}. Result: {result}")
+523                    raise HTTPError(response.status, str(result), result)
+524
+525                return FetchResponse(
+526                    status=response.status,
+527                    headers=response_headers,
+528                    data=result,
+529                )
+530
+531        except RateLimitError:
+532            raise
+533        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+534            # Don't want to send this to Raygun here because this will be retried.
+535            print(f"Error encountered: {e}. Retry count: {retry_count}. Backing off.")
+536            if retry_count < self.config["max_retries"]:
+537                await asyncio.sleep(2 ** retry_count)  # Exponential backoff
+538                print("Retrying request...")
+539                # Use original_timeout (numeric) for recursive calls
+540                return await self.fetch(
+541                    url, method, params, data, json,
+542                    headers, content_type, original_timeout, retry_count + 1
+543                )
+544            else:
+545                print("Max retries reached. Raising error.")
+546                raise
+547        except Exception as e:
+548            self.logger.error(f"Unexpected error during {method} {url}: {e}")
+549            print(f"Unexpected error encountered: {e}")
+550            raise
 
    
 
 
@@ -3326,22 +3332,22 @@ 
    Inherited Members
    - 
    368    def __init__(
-369        self,
-370        auth: Dict[str, Any] = {}, 
-371        request_config: Optional[Dict[str, Any]] = None,
-372        metadata: Optional[Dict[str, Any]] = None,
-373        logger: Optional[logging.Logger] = None
-374    ):
-375        self.auth = auth
-376        """Authentication configuration"""
-377        self.config = request_config or {"max_retries": 3, "timeout": 30}
-378        """Request configuration"""
-379        self.metadata = metadata or {}
-380        """Additional metadata"""
-381        self.logger = logger or logging.getLogger(__name__)
-382        """Logger instance"""
-383        self._session: Optional[aiohttp.ClientSession] = None
+            
    371    def __init__(
+372        self,
+373        auth: Dict[str, Any] = {}, 
+374        request_config: Optional[Dict[str, Any]] = None,
+375        metadata: Optional[Dict[str, Any]] = None,
+376        logger: Optional[logging.Logger] = None
+377    ):
+378        self.auth = auth
+379        """Authentication configuration"""
+380        self.config = request_config or {"max_retries": 3, "timeout": 30}
+381        """Request configuration"""
+382        self.metadata = metadata or {}
+383        """Additional metadata"""
+384        self.logger = logger or logging.getLogger(__name__)
+385        """Logger instance"""
+386        self._session: Optional[aiohttp.ClientSession] = None
 
    
 
 
@@ -3411,159 +3417,159 @@ 
    Inherited Members
    - 
    395    async def fetch(
-396            self,
-397            url: str,
-398            method: str = "GET",
-399            params: Optional[Dict[str, Any]] = None,
-400            data: Any = None,
-401            json: Any = None,
-402            headers: Optional[Dict[str, str]] = None,
-403            content_type: Optional[str] = None,
-404            timeout: Optional[int] = None,
-405            retry_count: int = 0
-406    ) -> FetchResponse:
-407        """Make an HTTP request with automatic retries and error handling.
-408
-409        For **platform OAuth** integrations (``auth_type == "PlatformOauth2"``),
-410        a ``Bearer`` token is auto-injected from ``auth.credentials.access_token``
-411        unless an ``Authorization`` header is explicitly provided.
-412
-413        Retries up to ``max_retries`` (default 3) on transient network errors
-414        with exponential back-off.  HTTP 429 responses raise ``RateLimitError``
-415        immediately (no automatic retry).
-416
-417        Args:
-418            url: The URL to request.
-419            method: HTTP method (``"GET"``, ``"POST"``, ``"PUT"``, etc.).
-420            params: Query parameters appended to the URL.  Nested dicts/lists
-421                are JSON-serialized automatically.
-422            data: Raw request body.  Encoding depends on ``content_type``.
-423            json: JSON-serializable payload.  Sets ``content_type`` to
-424                ``application/json`` automatically.
-425            headers: Additional HTTP headers.  Merged *after* any auto-injected
-426                auth header, so an explicit ``Authorization`` takes precedence.
-427            content_type: ``Content-Type`` header value.
-428            timeout: Per-request timeout in seconds (overrides ``request_config``).
-429            retry_count: Internal — current retry attempt number.
-430
-431        Returns:
-432            A ``FetchResponse`` containing the HTTP status code, response
-433            headers, and parsed body data.
-434
-435        Raises:
-436            RateLimitError: On HTTP 429 with the ``Retry-After`` value.
-437            HTTPError: On any other non-2xx status.
-438        """
-439        if not self._session:
-440            self._session = aiohttp.ClientSession()
-441
-442        # Prepare request
-443        if json is not None:
-444            data = json
-445            content_type = "application/json"
-446
-447        final_headers = {}
-448        
-449        if self.auth and "Authorization" not in (headers or {}):
-450            auth_type = AuthType(self.auth.get("auth_type", "PlatformOauth2"))
-451            credentials = self.auth.get("credentials", {})
-452            
-453            if auth_type == AuthType.PlatformOauth2 and "access_token" in credentials:
-454                final_headers["Authorization"] = f"Bearer {credentials['access_token']}"
-455
-456        if content_type:
-457            final_headers["Content-Type"] = content_type
-458        if headers:
-459            final_headers.update(headers)
-460
-461        if params:
-462            # Handle nested dictionary parameters
-463            flat_params = {}
-464            for key, value in params.items():
-465                if isinstance(value, (dict, list)):
-466                    flat_params[key] = jsonX.dumps(value)
-467                elif value is not None:
-468                    flat_params[key] = str(value)
-469            query_string = urlencode(flat_params)
-470            url = f"{url}{'&' if '?' in url else '?'}{query_string}"
-471
-472        # Prepare body
-473        if data is not None:
-474            if content_type == "application/json":
-475                data = jsonX.dumps(data)
-476            elif content_type == "application/x-www-form-urlencoded":
-477                data = urlencode(data) if isinstance(data, dict) else data
-478
-479        # Store the original timeout numeric value
-480        original_timeout = timeout or self.config["timeout"]
+            
    398    async def fetch(
+399            self,
+400            url: str,
+401            method: str = "GET",
+402            params: Optional[Dict[str, Any]] = None,
+403            data: Any = None,
+404            json: Any = None,
+405            headers: Optional[Dict[str, str]] = None,
+406            content_type: Optional[str] = None,
+407            timeout: Optional[int] = None,
+408            retry_count: int = 0
+409    ) -> FetchResponse:
+410        """Make an HTTP request with automatic retries and error handling.
+411
+412        For **platform OAuth** integrations (``auth_type == "PlatformOauth2"``),
+413        a ``Bearer`` token is auto-injected from ``auth.credentials.access_token``
+414        unless an ``Authorization`` header is explicitly provided.
+415
+416        Retries up to ``max_retries`` (default 3) on transient network errors
+417        with exponential back-off.  HTTP 429 responses raise ``RateLimitError``
+418        immediately (no automatic retry).
+419
+420        Args:
+421            url: The URL to request.
+422            method: HTTP method (``"GET"``, ``"POST"``, ``"PUT"``, etc.).
+423            params: Query parameters appended to the URL.  Nested dicts/lists
+424                are JSON-serialized automatically.
+425            data: Raw request body.  Encoding depends on ``content_type``.
+426            json: JSON-serializable payload.  Sets ``content_type`` to
+427                ``application/json`` automatically.
+428            headers: Additional HTTP headers.  Merged *after* any auto-injected
+429                auth header, so an explicit ``Authorization`` takes precedence.
+430            content_type: ``Content-Type`` header value.
+431            timeout: Per-request timeout in seconds (overrides ``request_config``).
+432            retry_count: Internal — current retry attempt number.
+433
+434        Returns:
+435            A ``FetchResponse`` containing the HTTP status code, response
+436            headers, and parsed body data.
+437
+438        Raises:
+439            RateLimitError: On HTTP 429 with the ``Retry-After`` value.
+440            HTTPError: On any other non-2xx status.
+441        """
+442        if not self._session:
+443            self._session = aiohttp.ClientSession()
+444
+445        # Prepare request
+446        if json is not None:
+447            data = json
+448            content_type = "application/json"
+449
+450        final_headers = {}
+451        
+452        if self.auth and "Authorization" not in (headers or {}):
+453            auth_type = AuthType(self.auth.get("auth_type", "PlatformOauth2"))
+454            credentials = self.auth.get("credentials", {})
+455            
+456            if auth_type == AuthType.PlatformOauth2 and "access_token" in credentials:
+457                final_headers["Authorization"] = f"Bearer {credentials['access_token']}"
+458
+459        if content_type:
+460            final_headers["Content-Type"] = content_type
+461        if headers:
+462            final_headers.update(headers)
+463
+464        if params:
+465            # Handle nested dictionary parameters
+466            flat_params = {}
+467            for key, value in params.items():
+468                if isinstance(value, (dict, list)):
+469                    flat_params[key] = jsonX.dumps(value)
+470                elif value is not None:
+471                    flat_params[key] = str(value)
+472            query_string = urlencode(flat_params)
+473            url = f"{url}{'&' if '?' in url else '?'}{query_string}"
+474
+475        # Prepare body
+476        if data is not None:
+477            if content_type == "application/json":
+478                data = jsonX.dumps(data)
+479            elif content_type == "application/x-www-form-urlencoded":
+480                data = urlencode(data) if isinstance(data, dict) else data
 481
-482        # Convert the numeric timeout to a ClientTimeout instance for this request
-483        client_timeout = aiohttp.ClientTimeout(total=original_timeout)
+482        # Store the original timeout numeric value
+483        original_timeout = timeout or self.config["timeout"]
 484
-485        try:
-486            async with self._session.request(
-487                method=method,
-488                url=url,
-489                data=data,
-490                headers=final_headers,
-491                timeout=client_timeout,
-492                ssl=True
-493            ) as response:
-494                content_type = response.headers.get("Content-Type", "")
-495
-496                if response.status == 429:  # Rate limit
-497                    retry_after = int(response.headers.get("Retry-After", 60))
-498                    raise RateLimitError(
-499                        retry_after,
-500                        response.status,
-501                        "Rate limit exceeded",
-502                        await response.text()
-503                    )
-504
-505                try:
-506                    if "application/json" in content_type:
-507                        result = await response.json()
-508                    else:
-509                        result = await response.text()
-510                        if not result and response.status in {200, 201, 204}:
-511                            result = None
-512                except Exception as e:
-513                    self.logger.error(f"Error parsing response: {e}")
-514                    result = await response.text()
-515
-516                response_headers = dict(response.headers)
-517
-518                if not response.ok:
-519                    print(f"HTTP error encountered. Status: {response.status}. Result: {result}")
-520                    raise HTTPError(response.status, str(result), result)
-521
-522                return FetchResponse(
-523                    status=response.status,
-524                    headers=response_headers,
-525                    data=result,
-526                )
-527
-528        except RateLimitError:
-529            raise
-530        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
-531            # Don't want to send this to Raygun here because this will be retried.
-532            print(f"Error encountered: {e}. Retry count: {retry_count}. Backing off.")
-533            if retry_count < self.config["max_retries"]:
-534                await asyncio.sleep(2 ** retry_count)  # Exponential backoff
-535                print("Retrying request...")
-536                # Use original_timeout (numeric) for recursive calls
-537                return await self.fetch(
-538                    url, method, params, data, json,
-539                    headers, content_type, original_timeout, retry_count + 1
-540                )
-541            else:
-542                print("Max retries reached. Raising error.")
-543                raise
-544        except Exception as e:
-545            self.logger.error(f"Unexpected error during {method} {url}: {e}")
-546            print(f"Unexpected error encountered: {e}")
-547            raise
+485        # Convert the numeric timeout to a ClientTimeout instance for this request
+486        client_timeout = aiohttp.ClientTimeout(total=original_timeout)
+487
+488        try:
+489            async with self._session.request(
+490                method=method,
+491                url=url,
+492                data=data,
+493                headers=final_headers,
+494                timeout=client_timeout,
+495                ssl=True
+496            ) as response:
+497                content_type = response.headers.get("Content-Type", "")
+498
+499                if response.status == 429:  # Rate limit
+500                    retry_after = int(response.headers.get("Retry-After", 60))
+501                    raise RateLimitError(
+502                        retry_after,
+503                        response.status,
+504                        "Rate limit exceeded",
+505                        await response.text()
+506                    )
+507
+508                try:
+509                    if "application/json" in content_type:
+510                        result = await response.json()
+511                    else:
+512                        result = await response.text()
+513                        if not result and response.status in {200, 201, 204}:
+514                            result = None
+515                except Exception as e:
+516                    self.logger.error(f"Error parsing response: {e}")
+517                    result = await response.text()
+518
+519                response_headers = dict(response.headers)
+520
+521                if not response.ok:
+522                    print(f"HTTP error encountered. Status: {response.status}. Result: {result}")
+523                    raise HTTPError(response.status, str(result), result)
+524
+525                return FetchResponse(
+526                    status=response.status,
+527                    headers=response_headers,
+528                    data=result,
+529                )
+530
+531        except RateLimitError:
+532            raise
+533        except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+534            # Don't want to send this to Raygun here because this will be retried.
+535            print(f"Error encountered: {e}. Retry count: {retry_count}. Backing off.")
+536            if retry_count < self.config["max_retries"]:
+537                await asyncio.sleep(2 ** retry_count)  # Exponential backoff
+538                print("Retrying request...")
+539                # Use original_timeout (numeric) for recursive calls
+540                return await self.fetch(
+541                    url, method, params, data, json,
+542                    headers, content_type, original_timeout, retry_count + 1
+543                )
+544            else:
+545                print("Max retries reached. Raising error.")
+546                raise
+547        except Exception as e:
+548            self.logger.error(f"Unexpected error during {method} {url}: {e}")
+549            print(f"Unexpected error encountered: {e}")
+550            raise
 
    
 
 
@@ -3614,380 +3620,380 @@ 
    Inherited Members
    - 
    550class Integration:
-551    """Base integration class with handler registration and execution.
-552    
-553    This class manages the integration configuration, handler registration,
-554    and provides methods to execute actions and triggers.
+            
    553class Integration:
+554    """Base integration class with handler registration and execution.
 555    
-556    Args:
-557        config: Integration configuration
-558        
-559    Attributes:
+556    This class manages the integration configuration, handler registration,
+557    and provides methods to execute actions and triggers.
+558    
+559    Args:
 560        config: Integration configuration
-561    """
-562
-563    def __init__(self, config: IntegrationConfig):
-564        self.config = config
-565        """Integration configuration"""
-566        self._action_handlers: Dict[str, Type[ActionHandler]] = {}
-567        """Action handlers"""
-568        self._polling_handlers: Dict[str, Type[PollingTriggerHandler]] = {}
-569        """Polling handlers"""
-570        self._connected_account_handler: Optional[Type[ConnectedAccountHandler]] = None
-571        """Connected account handler"""
-572
-573    @classmethod
-574    def load(cls, config_path: Union[str, Path] = None) -> 'Integration':
-575        """Load an integration from its ``config.json``.
-576
-577        Args:
-578            config_path: Explicit path to ``config.json``.  When omitted the
-579                SDK resolves the path relative to its own package location,
-580                which works when the SDK is vendored via
-581                ``pip install --target dependencies``.  Multi-file integrations
-582                that use ``actions/`` sub-packages should pass an explicit path
-583                (e.g. ``Integration.load("config.json")``).
-584
-585        Returns:
-586            A fully initialised ``Integration`` ready for handler registration.
+561        
+562    Attributes:
+563        config: Integration configuration
+564    """
+565
+566    def __init__(self, config: IntegrationConfig):
+567        self.config = config
+568        """Integration configuration"""
+569        self._action_handlers: Dict[str, Type[ActionHandler]] = {}
+570        """Action handlers"""
+571        self._polling_handlers: Dict[str, Type[PollingTriggerHandler]] = {}
+572        """Polling handlers"""
+573        self._connected_account_handler: Optional[Type[ConnectedAccountHandler]] = None
+574        """Connected account handler"""
+575
+576    @classmethod
+577    def load(cls, config_path: Union[str, Path] = None) -> 'Integration':
+578        """Load an integration from its ``config.json``.
+579
+580        Args:
+581            config_path: Explicit path to ``config.json``.  When omitted the
+582                SDK resolves the path relative to its own package location,
+583                which works when the SDK is vendored via
+584                ``pip install --target dependencies``.  Multi-file integrations
+585                that use ``actions/`` sub-packages should pass an explicit path
+586                (e.g. ``Integration.load("config.json")``).
 587
-588        Raises:
-589            ConfigurationError: If the file is missing or contains invalid JSON.
-590        """
-591        if config_path is None:
-592            config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'config.json')
-593        
-594        config_path = Path(config_path)
-595
-596        if not config_path.exists():
-597            raise ConfigurationError(f"Configuration file not found: {config_path}")
+588        Returns:
+589            A fully initialised ``Integration`` ready for handler registration.
+590
+591        Raises:
+592            ConfigurationError: If the file is missing or contains invalid JSON.
+593        """
+594        if config_path is None:
+595            config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'config.json')
+596        
+597        config_path = Path(config_path)
 598
-599        try:
-600            with open(config_path, 'r') as f:
-601                config_data = json.load(f)
-602        except json.JSONDecodeError as e:
-603            raise ConfigurationError(f"Invalid JSON configuration: {e}")
-604        
-605        # Parse configuration sections
-606        actions = cls._parse_actions(config_data.get("actions", {}))
-607        polling_triggers = cls._parse_polling_triggers(config_data.get("polling_triggers", {}))
-608
-609        config = IntegrationConfig(
-610            name=config_data["name"],
-611            version=config_data["version"],
-612            description=config_data["description"],
-613            auth=config_data.get("auth", {}),
-614            actions=actions,
-615            polling_triggers=polling_triggers
-616        )
-617
-618        return cls(config)
-619
-620    @staticmethod
-621    def _parse_interval(interval_str: str) -> timedelta:
-622        """Parse interval string into timedelta"""
-623        unit = interval_str[-1].lower()
-624        value = int(interval_str[:-1])
-625
-626        if unit == 's':
-627            return timedelta(seconds=value)
-628        elif unit == 'm':
-629            return timedelta(minutes=value)
-630        elif unit == 'h':
-631            return timedelta(hours=value)
-632        elif unit == 'd':
-633            return timedelta(days=value)
-634        else:
-635            raise ConfigurationError(f"Invalid interval format: {interval_str}")
-636
-637    @classmethod
-638    def _parse_actions(cls, actions_config: Dict[str, Any]) -> Dict[str, Action]:
-639        """Parse action configurations"""
-640        actions = {}
-641        for name, data in actions_config.items():
-642            actions[name] = Action(
-643                name=name,
-644                description=data["description"],
-645                input_schema=data["input_schema"],
-646                output_schema=data["output_schema"]
-647            )
-648
-649        return actions
-650
-651    @classmethod
-652    def _parse_polling_triggers(cls, triggers_config: Dict[str, Any]) -> Dict[str, PollingTrigger]:
-653        """Parse polling trigger configurations"""
-654        triggers = {}
-655        for name, data in triggers_config.items():
-656            interval = cls._parse_interval(data["polling_interval"])
-657
-658            triggers[name] = PollingTrigger(
-659                name=name,
-660                description=data["description"],
-661                polling_interval=interval,
-662                input_schema=data["input_schema"],
-663                output_schema=data["output_schema"]
-664            )
-665
-666        return triggers
-667
-668    def action(self, name: str):
-669        """Decorator to register an action handler.
-670        
-671        Args:
-672            name: Name of the action to register
-673            
-674        Returns:
-675            Decorator function
+599        if not config_path.exists():
+600            raise ConfigurationError(f"Configuration file not found: {config_path}")
+601
+602        try:
+603            with open(config_path, 'r') as f:
+604                config_data = json.load(f)
+605        except json.JSONDecodeError as e:
+606            raise ConfigurationError(f"Invalid JSON configuration: {e}")
+607        
+608        # Parse configuration sections
+609        actions = cls._parse_actions(config_data.get("actions", {}))
+610        polling_triggers = cls._parse_polling_triggers(config_data.get("polling_triggers", {}))
+611
+612        config = IntegrationConfig(
+613            name=config_data["name"],
+614            version=config_data["version"],
+615            description=config_data["description"],
+616            auth=config_data.get("auth", {}),
+617            actions=actions,
+618            polling_triggers=polling_triggers
+619        )
+620
+621        return cls(config)
+622
+623    @staticmethod
+624    def _parse_interval(interval_str: str) -> timedelta:
+625        """Parse interval string into timedelta"""
+626        unit = interval_str[-1].lower()
+627        value = int(interval_str[:-1])
+628
+629        if unit == 's':
+630            return timedelta(seconds=value)
+631        elif unit == 'm':
+632            return timedelta(minutes=value)
+633        elif unit == 'h':
+634            return timedelta(hours=value)
+635        elif unit == 'd':
+636            return timedelta(days=value)
+637        else:
+638            raise ConfigurationError(f"Invalid interval format: {interval_str}")
+639
+640    @classmethod
+641    def _parse_actions(cls, actions_config: Dict[str, Any]) -> Dict[str, Action]:
+642        """Parse action configurations"""
+643        actions = {}
+644        for name, data in actions_config.items():
+645            actions[name] = Action(
+646                name=name,
+647                description=data["description"],
+648                input_schema=data["input_schema"],
+649                output_schema=data["output_schema"]
+650            )
+651
+652        return actions
+653
+654    @classmethod
+655    def _parse_polling_triggers(cls, triggers_config: Dict[str, Any]) -> Dict[str, PollingTrigger]:
+656        """Parse polling trigger configurations"""
+657        triggers = {}
+658        for name, data in triggers_config.items():
+659            interval = cls._parse_interval(data["polling_interval"])
+660
+661            triggers[name] = PollingTrigger(
+662                name=name,
+663                description=data["description"],
+664                polling_interval=interval,
+665                input_schema=data["input_schema"],
+666                output_schema=data["output_schema"]
+667            )
+668
+669        return triggers
+670
+671    def action(self, name: str):
+672        """Decorator to register an action handler.
+673        
+674        Args:
+675            name: Name of the action to register
 676            
-677        Raises:
-678            ConfigurationError: If action is not defined in config
+677        Returns:
+678            Decorator function
 679            
-680        Example:
-681            ```python
-682            @integration.action("my_action")
-683            class MyActionHandler(ActionHandler):
-684                async def execute(self, inputs, context):
-685                    # Implementation
-686                    return result
-687            ```
-688        """
-689        def decorator(handler_class: Type[ActionHandler]):
-690            if name not in self.config.actions:
-691                raise ConfigurationError(f"Action '{name}' not defined in config")
-692            self._action_handlers[name] = handler_class
-693            return handler_class
-694        return decorator
-695
-696    def polling_trigger(self, name: str):
-697        """Decorator to register a polling trigger handler
-698        
-699        Args:
-700            name: Name of the polling trigger to register
-701            
-702        Returns:
-703            Decorator function
-704        
-705        Raises:
-706            ConfigurationError: If polling trigger is not defined in config
-707
-708        Example:
-709            ```python
-710            @integration.polling_trigger("my_polling_trigger")
-711            class MyPollingTriggerHandler(PollingTriggerHandler):
-712                async def poll(self, inputs, last_poll_ts, context):
-713                    # Implementation
-714                    return result
-715            ```
-716        """
-717        def decorator(handler_class: Type[PollingTriggerHandler]):
-718            if name not in self.config.polling_triggers:
-719                raise ConfigurationError(f"Polling trigger '{name}' not defined in config")
-720            self._polling_handlers[name] = handler_class
-721            return handler_class
-722        return decorator
-723
-724    def connected_account(self):
-725        """Decorator to register a connected account handler
-726        
-727        Returns:
-728            Decorator function
-729
-730        Example:
-731            ```python
-732            @integration.connected_account()
-733            class MyConnectedAccountHandler(ConnectedAccountHandler):
-734                async def get_account_info(self, context):
-735                    # Implementation
-736                    return {"email": "user@example.com", "name": "John Doe"}
-737            ```
-738        """
-739        def decorator(handler_class: Type[ConnectedAccountHandler]):
-740            self._connected_account_handler = handler_class
-741            return handler_class
-742        return decorator
-743
-744    async def execute_action(self,
-745                           name: str,
-746                           inputs: Dict[str, Any],
-747                           context: ExecutionContext) -> IntegrationResult:
-748        """Execute a registered action.
-749
-750        Args:
-751            name: Name of the action to execute
-752            inputs: Action inputs
-753            context: Execution context
-754
-755        Returns:
-756            IntegrationResult with action data (ResultType.ACTION),
-757            action error (ResultType.ACTION_ERROR) if the handler returned ActionError,
-758            or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
-759        """
-760        try:
-761            if name not in self._action_handlers:
-762                raise ValidationError(f"Action '{name}' not registered")
-763
-764            # Validate inputs against action schema
-765            action_config = self.config.actions[name]
-766            validator = Draft7Validator(action_config.input_schema)
-767            errors = sorted(validator.iter_errors(inputs), key=lambda e: e.path)
-768            if errors:
-769                message = ""
-770                for error in errors:
-771                    message += f"{list(error.schema_path)}, {error.message},\n "
-772                raise ValidationError(message, action_config.input_schema, inputs, source="input")
-773
-774            if "fields" in self.config.auth:
-775                auth_config = self.config.auth["fields"]
-776                validator = Draft7Validator(auth_config)
-777                errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
-778                if errors:
-779                    message = ""
-780                    for error in errors:
-781                        message += f"{list(error.schema_path)}, {error.message},\n "
-782                    raise ValidationError(message, auth_config, context.auth, source="input")
-783
-784            # Create handler instance and execute
-785            handler = self._action_handlers[name]()
-786            result = await handler.execute(inputs, context)
-787
-788            # Handle ActionError - skip output schema validation
-789            if isinstance(result, ActionError):
-790                return IntegrationResult(
-791                    version=__version__,
-792                    type=ResultType.ACTION_ERROR,
-793                    result=result
-794                )
-795
-796            # Validate that result is ActionResult
-797            if not isinstance(result, ActionResult):
-798                raise ValidationError(
-799                    f"Action handler '{name}' must return ActionResult or ActionError, got {type(result).__name__}",
-800                    source="output"
-801                )
-802
-803            # Validate output schema against the data inside ActionResult
-804            validator = Draft7Validator(action_config.output_schema)
-805            errors = sorted(validator.iter_errors(result.data), key=lambda e: e.path)
-806            if errors:
-807                message = ""
-808                for error in errors:
-809                    message += f"{list(error.schema_path)}, {error.message},\n "
-810                raise ValidationError(message, action_config.output_schema, result.data, source="output")
-811
-812            # Return IntegrationResult with ActionResult directly
-813            return IntegrationResult(
-814                version=__version__,
-815                type=ResultType.ACTION,
-816                result=result
-817            )
-818        except ValidationError as e:
-819            return IntegrationResult(
-820                version=__version__,
-821                type=ResultType.VALIDATION_ERROR,
-822                result={
-823                    'message': str(e),
-824                    'property': None,
-825                    'value': None,
-826                    'source': getattr(e, 'source', 'legacy')
-827                }
-828            )
-829
-830    async def execute_polling_trigger(self,
-831                                    name: str,
-832                                    inputs: Dict[str, Any],
-833                                    last_poll_ts: Optional[str],
-834                                    context: ExecutionContext) -> List[Dict[str, Any]]:
-835        """Execute a registered polling trigger
-836        
-837        Args:
-838            name: Name of the polling trigger to execute
-839            inputs: Trigger inputs
-840            last_poll_ts: Last poll timestamp
-841            context: Execution context
-842            
-843        Returns:
-844            List of records
+680        Raises:
+681            ConfigurationError: If action is not defined in config
+682            
+683        Example:
+684            ```python
+685            @integration.action("my_action")
+686            class MyActionHandler(ActionHandler):
+687                async def execute(self, inputs, context):
+688                    # Implementation
+689                    return result
+690            ```
+691        """
+692        def decorator(handler_class: Type[ActionHandler]):
+693            if name not in self.config.actions:
+694                raise ConfigurationError(f"Action '{name}' not defined in config")
+695            self._action_handlers[name] = handler_class
+696            return handler_class
+697        return decorator
+698
+699    def polling_trigger(self, name: str):
+700        """Decorator to register a polling trigger handler
+701        
+702        Args:
+703            name: Name of the polling trigger to register
+704            
+705        Returns:
+706            Decorator function
+707        
+708        Raises:
+709            ConfigurationError: If polling trigger is not defined in config
+710
+711        Example:
+712            ```python
+713            @integration.polling_trigger("my_polling_trigger")
+714            class MyPollingTriggerHandler(PollingTriggerHandler):
+715                async def poll(self, inputs, last_poll_ts, context):
+716                    # Implementation
+717                    return result
+718            ```
+719        """
+720        def decorator(handler_class: Type[PollingTriggerHandler]):
+721            if name not in self.config.polling_triggers:
+722                raise ConfigurationError(f"Polling trigger '{name}' not defined in config")
+723            self._polling_handlers[name] = handler_class
+724            return handler_class
+725        return decorator
+726
+727    def connected_account(self):
+728        """Decorator to register a connected account handler
+729        
+730        Returns:
+731            Decorator function
+732
+733        Example:
+734            ```python
+735            @integration.connected_account()
+736            class MyConnectedAccountHandler(ConnectedAccountHandler):
+737                async def get_account_info(self, context):
+738                    # Implementation
+739                    return {"email": "user@example.com", "name": "John Doe"}
+740            ```
+741        """
+742        def decorator(handler_class: Type[ConnectedAccountHandler]):
+743            self._connected_account_handler = handler_class
+744            return handler_class
+745        return decorator
+746
+747    async def execute_action(self,
+748                           name: str,
+749                           inputs: Dict[str, Any],
+750                           context: ExecutionContext) -> IntegrationResult:
+751        """Execute a registered action.
+752
+753        Args:
+754            name: Name of the action to execute
+755            inputs: Action inputs
+756            context: Execution context
+757
+758        Returns:
+759            IntegrationResult with action data (ResultType.ACTION),
+760            action error (ResultType.ACTION_ERROR) if the handler returned ActionError,
+761            or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
+762        """
+763        try:
+764            if name not in self._action_handlers:
+765                raise ValidationError(f"Action '{name}' not registered")
+766
+767            # Validate inputs against action schema
+768            action_config = self.config.actions[name]
+769            validator = Draft7Validator(action_config.input_schema)
+770            errors = sorted(validator.iter_errors(inputs), key=lambda e: e.path)
+771            if errors:
+772                message = ""
+773                for error in errors:
+774                    message += f"{list(error.schema_path)}, {error.message},\n "
+775                raise ValidationError(message, action_config.input_schema, inputs, source="input")
+776
+777            if "fields" in self.config.auth:
+778                auth_config = self.config.auth["fields"]
+779                validator = Draft7Validator(auth_config)
+780                errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
+781                if errors:
+782                    message = ""
+783                    for error in errors:
+784                        message += f"{list(error.schema_path)}, {error.message},\n "
+785                    raise ValidationError(message, auth_config, context.auth, source="input")
+786
+787            # Create handler instance and execute
+788            handler = self._action_handlers[name]()
+789            result = await handler.execute(inputs, context)
+790
+791            # Handle ActionError - skip output schema validation
+792            if isinstance(result, ActionError):
+793                return IntegrationResult(
+794                    version=__version__,
+795                    type=ResultType.ACTION_ERROR,
+796                    result=result
+797                )
+798
+799            # Validate that result is ActionResult
+800            if not isinstance(result, ActionResult):
+801                raise ValidationError(
+802                    f"Action handler '{name}' must return ActionResult or ActionError, got {type(result).__name__}",
+803                    source="output"
+804                )
+805
+806            # Validate output schema against the data inside ActionResult
+807            validator = Draft7Validator(action_config.output_schema)
+808            errors = sorted(validator.iter_errors(result.data), key=lambda e: e.path)
+809            if errors:
+810                message = ""
+811                for error in errors:
+812                    message += f"{list(error.schema_path)}, {error.message},\n "
+813                raise ValidationError(message, action_config.output_schema, result.data, source="output")
+814
+815            # Return IntegrationResult with ActionResult directly
+816            return IntegrationResult(
+817                version=__version__,
+818                type=ResultType.ACTION,
+819                result=result
+820            )
+821        except ValidationError as e:
+822            return IntegrationResult(
+823                version=__version__,
+824                type=ResultType.VALIDATION_ERROR,
+825                result={
+826                    'message': str(e),
+827                    'property': None,
+828                    'value': None,
+829                    'source': getattr(e, 'source', 'legacy')
+830                }
+831            )
+832
+833    async def execute_polling_trigger(self,
+834                                    name: str,
+835                                    inputs: Dict[str, Any],
+836                                    last_poll_ts: Optional[str],
+837                                    context: ExecutionContext) -> List[Dict[str, Any]]:
+838        """Execute a registered polling trigger
+839        
+840        Args:
+841            name: Name of the polling trigger to execute
+842            inputs: Trigger inputs
+843            last_poll_ts: Last poll timestamp
+844            context: Execution context
 845            
-846        Raises:
-847            ValidationError: If inputs or outputs don't match schema
-848        """
-849        if name not in self._polling_handlers:
-850            raise ValidationError(f"Polling trigger '{name}' not registered")
-851
-852        # Validate trigger configuration
-853        trigger_config = self.config.polling_triggers[name]
-854        try:
-855            validate(inputs, trigger_config.input_schema)
-856        except Exception as e:
-857            raise ValidationError(e.message, e.schema, e.instance)
-858
-859        try:
-860            auth_config = self.config.auth["fields"]
-861            validate(context.auth, auth_config)
-862        except Exception as e:
-863            raise ValidationError(e.message, e.schema, e.instance)
-864        
-865        # Create handler instance and execute
-866        handler = self._polling_handlers[name]()
-867        records = await handler.poll(inputs, last_poll_ts, context)
-868        # Validate each record
-869        for record in records:
-870            if "id" not in record:
-871                raise ValidationError(
-872                    f"Polling trigger '{name}' returned record without required 'id' field")
-873            if "data" not in record:
+846        Returns:
+847            List of records
+848            
+849        Raises:
+850            ValidationError: If inputs or outputs don't match schema
+851        """
+852        if name not in self._polling_handlers:
+853            raise ValidationError(f"Polling trigger '{name}' not registered")
+854
+855        # Validate trigger configuration
+856        trigger_config = self.config.polling_triggers[name]
+857        try:
+858            validate(inputs, trigger_config.input_schema)
+859        except Exception as e:
+860            raise ValidationError(e.message, e.schema, e.instance)
+861
+862        try:
+863            auth_config = self.config.auth["fields"]
+864            validate(context.auth, auth_config)
+865        except Exception as e:
+866            raise ValidationError(e.message, e.schema, e.instance)
+867        
+868        # Create handler instance and execute
+869        handler = self._polling_handlers[name]()
+870        records = await handler.poll(inputs, last_poll_ts, context)
+871        # Validate each record
+872        for record in records:
+873            if "id" not in record:
 874                raise ValidationError(
-875                    f"Polling trigger '{name}' returned record without required 'data' field")
-876
-877            # Validate record data against output schema
-878            try:
-879                validate(record["data"], trigger_config.output_schema)
-880            except Exception as e:
-881                raise ValidationError(e.message, e.schema, e.instance)
-882            
-883        return records
-884
-885    async def get_connected_account(self, context: ExecutionContext) -> IntegrationResult:
-886        """Get connected account information
+875                    f"Polling trigger '{name}' returned record without required 'id' field")
+876            if "data" not in record:
+877                raise ValidationError(
+878                    f"Polling trigger '{name}' returned record without required 'data' field")
+879
+880            # Validate record data against output schema
+881            try:
+882                validate(record["data"], trigger_config.output_schema)
+883            except Exception as e:
+884                raise ValidationError(e.message, e.schema, e.instance)
+885            
+886        return records
 887
-888        Args:
-889            context: Execution context
+888    async def get_connected_account(self, context: ExecutionContext) -> IntegrationResult:
+889        """Get connected account information
 890
-891        Returns:
-892            IntegrationResult containing connected account data
+891        Args:
+892            context: Execution context
 893
-894        Raises:
-895            ValidationError: If no connected account handler is registered or auth is invalid
-896        """
-897        if not self._connected_account_handler:
-898            raise ValidationError("No connected account handler registered")
-899
-900        if "fields" in self.config.auth:
-901            auth_config = self.config.auth["fields"]
-902            validator = Draft7Validator(auth_config)
-903            errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
-904            if errors:
-905                message = ""
-906                for error in errors:
-907                    message += f"{list(error.schema_path)}, {error.message},\n "
-908                raise ValidationError(message, auth_config, context.auth)
-909
-910        handler = self._connected_account_handler()
-911        account_info = await handler.get_account_info(context)
+894        Returns:
+895            IntegrationResult containing connected account data
+896
+897        Raises:
+898            ValidationError: If no connected account handler is registered or auth is invalid
+899        """
+900        if not self._connected_account_handler:
+901            raise ValidationError("No connected account handler registered")
+902
+903        if "fields" in self.config.auth:
+904            auth_config = self.config.auth["fields"]
+905            validator = Draft7Validator(auth_config)
+906            errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
+907            if errors:
+908                message = ""
+909                for error in errors:
+910                    message += f"{list(error.schema_path)}, {error.message},\n "
+911                raise ValidationError(message, auth_config, context.auth)
 912
-913        if not isinstance(account_info, ConnectedAccountInfo):
-914            raise ValidationError(
-915                f"Connected account handler must return ConnectedAccountInfo, got {type(account_info).__name__}"
-916            )
-917
-918        # Return IntegrationResult with ConnectedAccountInfo object directly
-919        return IntegrationResult(
-920            version=__version__,
-921            type=ResultType.CONNECTED_ACCOUNT,
-922            result=account_info
-923        )
+913        handler = self._connected_account_handler()
+914        account_info = await handler.get_account_info(context)
+915
+916        if not isinstance(account_info, ConnectedAccountInfo):
+917            raise ValidationError(
+918                f"Connected account handler must return ConnectedAccountInfo, got {type(account_info).__name__}"
+919            )
+920
+921        # Return IntegrationResult with ConnectedAccountInfo object directly
+922        return IntegrationResult(
+923            version=__version__,
+924            type=ResultType.CONNECTED_ACCOUNT,
+925            result=account_info
+926        )
 
    
 
 
@@ -4014,15 +4020,15 @@ 
    Inherited Members
    - 
    563    def __init__(self, config: IntegrationConfig):
-564        self.config = config
-565        """Integration configuration"""
-566        self._action_handlers: Dict[str, Type[ActionHandler]] = {}
-567        """Action handlers"""
-568        self._polling_handlers: Dict[str, Type[PollingTriggerHandler]] = {}
-569        """Polling handlers"""
-570        self._connected_account_handler: Optional[Type[ConnectedAccountHandler]] = None
-571        """Connected account handler"""
+            
    566    def __init__(self, config: IntegrationConfig):
+567        self.config = config
+568        """Integration configuration"""
+569        self._action_handlers: Dict[str, Type[ActionHandler]] = {}
+570        """Action handlers"""
+571        self._polling_handlers: Dict[str, Type[PollingTriggerHandler]] = {}
+572        """Polling handlers"""
+573        self._connected_account_handler: Optional[Type[ConnectedAccountHandler]] = None
+574        """Connected account handler"""
 
    
 
 
@@ -4054,52 +4060,52 @@ 
    Inherited Members
    - 
    573    @classmethod
-574    def load(cls, config_path: Union[str, Path] = None) -> 'Integration':
-575        """Load an integration from its ``config.json``.
-576
-577        Args:
-578            config_path: Explicit path to ``config.json``.  When omitted the
-579                SDK resolves the path relative to its own package location,
-580                which works when the SDK is vendored via
-581                ``pip install --target dependencies``.  Multi-file integrations
-582                that use ``actions/`` sub-packages should pass an explicit path
-583                (e.g. ``Integration.load("config.json")``).
-584
-585        Returns:
-586            A fully initialised ``Integration`` ready for handler registration.
+            
    576    @classmethod
+577    def load(cls, config_path: Union[str, Path] = None) -> 'Integration':
+578        """Load an integration from its ``config.json``.
+579
+580        Args:
+581            config_path: Explicit path to ``config.json``.  When omitted the
+582                SDK resolves the path relative to its own package location,
+583                which works when the SDK is vendored via
+584                ``pip install --target dependencies``.  Multi-file integrations
+585                that use ``actions/`` sub-packages should pass an explicit path
+586                (e.g. ``Integration.load("config.json")``).
 587
-588        Raises:
-589            ConfigurationError: If the file is missing or contains invalid JSON.
-590        """
-591        if config_path is None:
-592            config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'config.json')
-593        
-594        config_path = Path(config_path)
-595
-596        if not config_path.exists():
-597            raise ConfigurationError(f"Configuration file not found: {config_path}")
+588        Returns:
+589            A fully initialised ``Integration`` ready for handler registration.
+590
+591        Raises:
+592            ConfigurationError: If the file is missing or contains invalid JSON.
+593        """
+594        if config_path is None:
+595            config_path = os.path.join(os.path.dirname(os.path.dirname(os.path.dirname(__file__))), 'config.json')
+596        
+597        config_path = Path(config_path)
 598
-599        try:
-600            with open(config_path, 'r') as f:
-601                config_data = json.load(f)
-602        except json.JSONDecodeError as e:
-603            raise ConfigurationError(f"Invalid JSON configuration: {e}")
-604        
-605        # Parse configuration sections
-606        actions = cls._parse_actions(config_data.get("actions", {}))
-607        polling_triggers = cls._parse_polling_triggers(config_data.get("polling_triggers", {}))
-608
-609        config = IntegrationConfig(
-610            name=config_data["name"],
-611            version=config_data["version"],
-612            description=config_data["description"],
-613            auth=config_data.get("auth", {}),
-614            actions=actions,
-615            polling_triggers=polling_triggers
-616        )
-617
-618        return cls(config)
+599        if not config_path.exists():
+600            raise ConfigurationError(f"Configuration file not found: {config_path}")
+601
+602        try:
+603            with open(config_path, 'r') as f:
+604                config_data = json.load(f)
+605        except json.JSONDecodeError as e:
+606            raise ConfigurationError(f"Invalid JSON configuration: {e}")
+607        
+608        # Parse configuration sections
+609        actions = cls._parse_actions(config_data.get("actions", {}))
+610        polling_triggers = cls._parse_polling_triggers(config_data.get("polling_triggers", {}))
+611
+612        config = IntegrationConfig(
+613            name=config_data["name"],
+614            version=config_data["version"],
+615            description=config_data["description"],
+616            auth=config_data.get("auth", {}),
+617            actions=actions,
+618            polling_triggers=polling_triggers
+619        )
+620
+621        return cls(config)
 
    
 
 
@@ -4133,33 +4139,33 @@ 
    Inherited Members
    - 
    668    def action(self, name: str):
-669        """Decorator to register an action handler.
-670        
-671        Args:
-672            name: Name of the action to register
-673            
-674        Returns:
-675            Decorator function
+            
    671    def action(self, name: str):
+672        """Decorator to register an action handler.
+673        
+674        Args:
+675            name: Name of the action to register
 676            
-677        Raises:
-678            ConfigurationError: If action is not defined in config
+677        Returns:
+678            Decorator function
 679            
-680        Example:
-681            ```python
-682            @integration.action("my_action")
-683            class MyActionHandler(ActionHandler):
-684                async def execute(self, inputs, context):
-685                    # Implementation
-686                    return result
-687            ```
-688        """
-689        def decorator(handler_class: Type[ActionHandler]):
-690            if name not in self.config.actions:
-691                raise ConfigurationError(f"Action '{name}' not defined in config")
-692            self._action_handlers[name] = handler_class
-693            return handler_class
-694        return decorator
+680        Raises:
+681            ConfigurationError: If action is not defined in config
+682            
+683        Example:
+684            ```python
+685            @integration.action("my_action")
+686            class MyActionHandler(ActionHandler):
+687                async def execute(self, inputs, context):
+688                    # Implementation
+689                    return result
+690            ```
+691        """
+692        def decorator(handler_class: Type[ActionHandler]):
+693            if name not in self.config.actions:
+694                raise ConfigurationError(f"Action '{name}' not defined in config")
+695            self._action_handlers[name] = handler_class
+696            return handler_class
+697        return decorator
 
    
 
 
@@ -4200,33 +4206,33 @@ 
    Inherited Members
    - 
    696    def polling_trigger(self, name: str):
-697        """Decorator to register a polling trigger handler
-698        
-699        Args:
-700            name: Name of the polling trigger to register
-701            
-702        Returns:
-703            Decorator function
-704        
-705        Raises:
-706            ConfigurationError: If polling trigger is not defined in config
-707
-708        Example:
-709            ```python
-710            @integration.polling_trigger("my_polling_trigger")
-711            class MyPollingTriggerHandler(PollingTriggerHandler):
-712                async def poll(self, inputs, last_poll_ts, context):
-713                    # Implementation
-714                    return result
-715            ```
-716        """
-717        def decorator(handler_class: Type[PollingTriggerHandler]):
-718            if name not in self.config.polling_triggers:
-719                raise ConfigurationError(f"Polling trigger '{name}' not defined in config")
-720            self._polling_handlers[name] = handler_class
-721            return handler_class
-722        return decorator
+            
    699    def polling_trigger(self, name: str):
+700        """Decorator to register a polling trigger handler
+701        
+702        Args:
+703            name: Name of the polling trigger to register
+704            
+705        Returns:
+706            Decorator function
+707        
+708        Raises:
+709            ConfigurationError: If polling trigger is not defined in config
+710
+711        Example:
+712            ```python
+713            @integration.polling_trigger("my_polling_trigger")
+714            class MyPollingTriggerHandler(PollingTriggerHandler):
+715                async def poll(self, inputs, last_poll_ts, context):
+716                    # Implementation
+717                    return result
+718            ```
+719        """
+720        def decorator(handler_class: Type[PollingTriggerHandler]):
+721            if name not in self.config.polling_triggers:
+722                raise ConfigurationError(f"Polling trigger '{name}' not defined in config")
+723            self._polling_handlers[name] = handler_class
+724            return handler_class
+725        return decorator
 
    
 
 
@@ -4267,25 +4273,25 @@ 
    Inherited Members
    - 
    724    def connected_account(self):
-725        """Decorator to register a connected account handler
-726        
-727        Returns:
-728            Decorator function
-729
-730        Example:
-731            ```python
-732            @integration.connected_account()
-733            class MyConnectedAccountHandler(ConnectedAccountHandler):
-734                async def get_account_info(self, context):
-735                    # Implementation
-736                    return {"email": "user@example.com", "name": "John Doe"}
-737            ```
-738        """
-739        def decorator(handler_class: Type[ConnectedAccountHandler]):
-740            self._connected_account_handler = handler_class
-741            return handler_class
-742        return decorator
+            
    727    def connected_account(self):
+728        """Decorator to register a connected account handler
+729        
+730        Returns:
+731            Decorator function
+732
+733        Example:
+734            ```python
+735            @integration.connected_account()
+736            class MyConnectedAccountHandler(ConnectedAccountHandler):
+737                async def get_account_info(self, context):
+738                    # Implementation
+739                    return {"email": "user@example.com", "name": "John Doe"}
+740            ```
+741        """
+742        def decorator(handler_class: Type[ConnectedAccountHandler]):
+743            self._connected_account_handler = handler_class
+744            return handler_class
+745        return decorator
 
    
 
 
@@ -4320,91 +4326,91 @@ 
    Inherited Members
    - 
    744    async def execute_action(self,
-745                           name: str,
-746                           inputs: Dict[str, Any],
-747                           context: ExecutionContext) -> IntegrationResult:
-748        """Execute a registered action.
-749
-750        Args:
-751            name: Name of the action to execute
-752            inputs: Action inputs
-753            context: Execution context
-754
-755        Returns:
-756            IntegrationResult with action data (ResultType.ACTION),
-757            action error (ResultType.ACTION_ERROR) if the handler returned ActionError,
-758            or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
-759        """
-760        try:
-761            if name not in self._action_handlers:
-762                raise ValidationError(f"Action '{name}' not registered")
-763
-764            # Validate inputs against action schema
-765            action_config = self.config.actions[name]
-766            validator = Draft7Validator(action_config.input_schema)
-767            errors = sorted(validator.iter_errors(inputs), key=lambda e: e.path)
-768            if errors:
-769                message = ""
-770                for error in errors:
-771                    message += f"{list(error.schema_path)}, {error.message},\n "
-772                raise ValidationError(message, action_config.input_schema, inputs, source="input")
-773
-774            if "fields" in self.config.auth:
-775                auth_config = self.config.auth["fields"]
-776                validator = Draft7Validator(auth_config)
-777                errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
-778                if errors:
-779                    message = ""
-780                    for error in errors:
-781                        message += f"{list(error.schema_path)}, {error.message},\n "
-782                    raise ValidationError(message, auth_config, context.auth, source="input")
-783
-784            # Create handler instance and execute
-785            handler = self._action_handlers[name]()
-786            result = await handler.execute(inputs, context)
-787
-788            # Handle ActionError - skip output schema validation
-789            if isinstance(result, ActionError):
-790                return IntegrationResult(
-791                    version=__version__,
-792                    type=ResultType.ACTION_ERROR,
-793                    result=result
-794                )
-795
-796            # Validate that result is ActionResult
-797            if not isinstance(result, ActionResult):
-798                raise ValidationError(
-799                    f"Action handler '{name}' must return ActionResult or ActionError, got {type(result).__name__}",
-800                    source="output"
-801                )
-802
-803            # Validate output schema against the data inside ActionResult
-804            validator = Draft7Validator(action_config.output_schema)
-805            errors = sorted(validator.iter_errors(result.data), key=lambda e: e.path)
-806            if errors:
-807                message = ""
-808                for error in errors:
-809                    message += f"{list(error.schema_path)}, {error.message},\n "
-810                raise ValidationError(message, action_config.output_schema, result.data, source="output")
-811
-812            # Return IntegrationResult with ActionResult directly
-813            return IntegrationResult(
-814                version=__version__,
-815                type=ResultType.ACTION,
-816                result=result
-817            )
-818        except ValidationError as e:
-819            return IntegrationResult(
-820                version=__version__,
-821                type=ResultType.VALIDATION_ERROR,
-822                result={
-823                    'message': str(e),
-824                    'property': None,
-825                    'value': None,
-826                    'source': getattr(e, 'source', 'legacy')
-827                }
-828            )
+            
    747    async def execute_action(self,
+748                           name: str,
+749                           inputs: Dict[str, Any],
+750                           context: ExecutionContext) -> IntegrationResult:
+751        """Execute a registered action.
+752
+753        Args:
+754            name: Name of the action to execute
+755            inputs: Action inputs
+756            context: Execution context
+757
+758        Returns:
+759            IntegrationResult with action data (ResultType.ACTION),
+760            action error (ResultType.ACTION_ERROR) if the handler returned ActionError,
+761            or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
+762        """
+763        try:
+764            if name not in self._action_handlers:
+765                raise ValidationError(f"Action '{name}' not registered")
+766
+767            # Validate inputs against action schema
+768            action_config = self.config.actions[name]
+769            validator = Draft7Validator(action_config.input_schema)
+770            errors = sorted(validator.iter_errors(inputs), key=lambda e: e.path)
+771            if errors:
+772                message = ""
+773                for error in errors:
+774                    message += f"{list(error.schema_path)}, {error.message},\n "
+775                raise ValidationError(message, action_config.input_schema, inputs, source="input")
+776
+777            if "fields" in self.config.auth:
+778                auth_config = self.config.auth["fields"]
+779                validator = Draft7Validator(auth_config)
+780                errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
+781                if errors:
+782                    message = ""
+783                    for error in errors:
+784                        message += f"{list(error.schema_path)}, {error.message},\n "
+785                    raise ValidationError(message, auth_config, context.auth, source="input")
+786
+787            # Create handler instance and execute
+788            handler = self._action_handlers[name]()
+789            result = await handler.execute(inputs, context)
+790
+791            # Handle ActionError - skip output schema validation
+792            if isinstance(result, ActionError):
+793                return IntegrationResult(
+794                    version=__version__,
+795                    type=ResultType.ACTION_ERROR,
+796                    result=result
+797                )
+798
+799            # Validate that result is ActionResult
+800            if not isinstance(result, ActionResult):
+801                raise ValidationError(
+802                    f"Action handler '{name}' must return ActionResult or ActionError, got {type(result).__name__}",
+803                    source="output"
+804                )
+805
+806            # Validate output schema against the data inside ActionResult
+807            validator = Draft7Validator(action_config.output_schema)
+808            errors = sorted(validator.iter_errors(result.data), key=lambda e: e.path)
+809            if errors:
+810                message = ""
+811                for error in errors:
+812                    message += f"{list(error.schema_path)}, {error.message},\n "
+813                raise ValidationError(message, action_config.output_schema, result.data, source="output")
+814
+815            # Return IntegrationResult with ActionResult directly
+816            return IntegrationResult(
+817                version=__version__,
+818                type=ResultType.ACTION,
+819                result=result
+820            )
+821        except ValidationError as e:
+822            return IntegrationResult(
+823                version=__version__,
+824                type=ResultType.VALIDATION_ERROR,
+825                result={
+826                    'message': str(e),
+827                    'property': None,
+828                    'value': None,
+829                    'source': getattr(e, 'source', 'legacy')
+830                }
+831            )
 
    
 
 
@@ -4434,60 +4440,60 @@ 
    Inherited Members
    - 
    830    async def execute_polling_trigger(self,
-831                                    name: str,
-832                                    inputs: Dict[str, Any],
-833                                    last_poll_ts: Optional[str],
-834                                    context: ExecutionContext) -> List[Dict[str, Any]]:
-835        """Execute a registered polling trigger
-836        
-837        Args:
-838            name: Name of the polling trigger to execute
-839            inputs: Trigger inputs
-840            last_poll_ts: Last poll timestamp
-841            context: Execution context
-842            
-843        Returns:
-844            List of records
+            
    833    async def execute_polling_trigger(self,
+834                                    name: str,
+835                                    inputs: Dict[str, Any],
+836                                    last_poll_ts: Optional[str],
+837                                    context: ExecutionContext) -> List[Dict[str, Any]]:
+838        """Execute a registered polling trigger
+839        
+840        Args:
+841            name: Name of the polling trigger to execute
+842            inputs: Trigger inputs
+843            last_poll_ts: Last poll timestamp
+844            context: Execution context
 845            
-846        Raises:
-847            ValidationError: If inputs or outputs don't match schema
-848        """
-849        if name not in self._polling_handlers:
-850            raise ValidationError(f"Polling trigger '{name}' not registered")
-851
-852        # Validate trigger configuration
-853        trigger_config = self.config.polling_triggers[name]
-854        try:
-855            validate(inputs, trigger_config.input_schema)
-856        except Exception as e:
-857            raise ValidationError(e.message, e.schema, e.instance)
-858
-859        try:
-860            auth_config = self.config.auth["fields"]
-861            validate(context.auth, auth_config)
-862        except Exception as e:
-863            raise ValidationError(e.message, e.schema, e.instance)
-864        
-865        # Create handler instance and execute
-866        handler = self._polling_handlers[name]()
-867        records = await handler.poll(inputs, last_poll_ts, context)
-868        # Validate each record
-869        for record in records:
-870            if "id" not in record:
-871                raise ValidationError(
-872                    f"Polling trigger '{name}' returned record without required 'id' field")
-873            if "data" not in record:
+846        Returns:
+847            List of records
+848            
+849        Raises:
+850            ValidationError: If inputs or outputs don't match schema
+851        """
+852        if name not in self._polling_handlers:
+853            raise ValidationError(f"Polling trigger '{name}' not registered")
+854
+855        # Validate trigger configuration
+856        trigger_config = self.config.polling_triggers[name]
+857        try:
+858            validate(inputs, trigger_config.input_schema)
+859        except Exception as e:
+860            raise ValidationError(e.message, e.schema, e.instance)
+861
+862        try:
+863            auth_config = self.config.auth["fields"]
+864            validate(context.auth, auth_config)
+865        except Exception as e:
+866            raise ValidationError(e.message, e.schema, e.instance)
+867        
+868        # Create handler instance and execute
+869        handler = self._polling_handlers[name]()
+870        records = await handler.poll(inputs, last_poll_ts, context)
+871        # Validate each record
+872        for record in records:
+873            if "id" not in record:
 874                raise ValidationError(
-875                    f"Polling trigger '{name}' returned record without required 'data' field")
-876
-877            # Validate record data against output schema
-878            try:
-879                validate(record["data"], trigger_config.output_schema)
-880            except Exception as e:
-881                raise ValidationError(e.message, e.schema, e.instance)
-882            
-883        return records
+875                    f"Polling trigger '{name}' returned record without required 'id' field")
+876            if "data" not in record:
+877                raise ValidationError(
+878                    f"Polling trigger '{name}' returned record without required 'data' field")
+879
+880            # Validate record data against output schema
+881            try:
+882                validate(record["data"], trigger_config.output_schema)
+883            except Exception as e:
+884                raise ValidationError(e.message, e.schema, e.instance)
+885            
+886        return records
 
    
 
 
@@ -4519,45 +4525,45 @@ 
    Inherited Members
    - 
    885    async def get_connected_account(self, context: ExecutionContext) -> IntegrationResult:
-886        """Get connected account information
-887
-888        Args:
-889            context: Execution context
+            
    888    async def get_connected_account(self, context: ExecutionContext) -> IntegrationResult:
+889        """Get connected account information
 890
-891        Returns:
-892            IntegrationResult containing connected account data
+891        Args:
+892            context: Execution context
 893
-894        Raises:
-895            ValidationError: If no connected account handler is registered or auth is invalid
-896        """
-897        if not self._connected_account_handler:
-898            raise ValidationError("No connected account handler registered")
-899
-900        if "fields" in self.config.auth:
-901            auth_config = self.config.auth["fields"]
-902            validator = Draft7Validator(auth_config)
-903            errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
-904            if errors:
-905                message = ""
-906                for error in errors:
-907                    message += f"{list(error.schema_path)}, {error.message},\n "
-908                raise ValidationError(message, auth_config, context.auth)
-909
-910        handler = self._connected_account_handler()
-911        account_info = await handler.get_account_info(context)
+894        Returns:
+895            IntegrationResult containing connected account data
+896
+897        Raises:
+898            ValidationError: If no connected account handler is registered or auth is invalid
+899        """
+900        if not self._connected_account_handler:
+901            raise ValidationError("No connected account handler registered")
+902
+903        if "fields" in self.config.auth:
+904            auth_config = self.config.auth["fields"]
+905            validator = Draft7Validator(auth_config)
+906            errors = sorted(validator.iter_errors(context.auth), key=lambda e: e.path)
+907            if errors:
+908                message = ""
+909                for error in errors:
+910                    message += f"{list(error.schema_path)}, {error.message},\n "
+911                raise ValidationError(message, auth_config, context.auth)
 912
-913        if not isinstance(account_info, ConnectedAccountInfo):
-914            raise ValidationError(
-915                f"Connected account handler must return ConnectedAccountInfo, got {type(account_info).__name__}"
-916            )
-917
-918        # Return IntegrationResult with ConnectedAccountInfo object directly
-919        return IntegrationResult(
-920            version=__version__,
-921            type=ResultType.CONNECTED_ACCOUNT,
-922            result=account_info
-923        )
+913        handler = self._connected_account_handler()
+914        account_info = await handler.get_account_info(context)
+915
+916        if not isinstance(account_info, ConnectedAccountInfo):
+917            raise ValidationError(
+918                f"Connected account handler must return ConnectedAccountInfo, got {type(account_info).__name__}"
+919            )
+920
+921        # Return IntegrationResult with ConnectedAccountInfo object directly
+922        return IntegrationResult(
+923            version=__version__,
+924            type=ResultType.CONNECTED_ACCOUNT,
+925            result=account_info
+926        )
 
    
 
 
diff --git a/docs/apidocs/search.js b/docs/apidocs/search.js
index 2964862..86d314d 100644
--- a/docs/apidocs/search.js
+++ b/docs/apidocs/search.js
@@ -1,6 +1,6 @@
 window.pdocSearch = (function(){
 /** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();o
    \n"}, "autohive_integrations_sdk.integration": {"fullname": "autohive_integrations_sdk.integration", "modulename": "autohive_integrations_sdk.integration", "kind": "module", "doc": "
    Autohive Integrations SDK \u2014 core module.
    \n\n
    Provides the building blocks for creating Autohive integrations:
    \n\n
      \n
    • Integration \u2014 load config and register action/trigger/connected-account handlers
      • \n
    • ExecutionContext \u2014 authenticated HTTP client passed to every handler
      • \n
    • ActionHandler \u2014 base class for action implementations (return ActionResult)
      • \n
    • ConnectedAccountHandler \u2014 base class for connected-account lookups (return ConnectedAccountInfo)
      • \n
    • ActionResult \u2014 standard return type wrapping action output data and optional billing cost
      • \n
    • ConnectedAccountInfo \u2014 structured account info returned by connected-account handlers
      • \n
    \n\n
    Typical usage::
    \n\n
    from autohive_integrations_sdk import Integration, ActionHandler, ActionResult, ExecutionContext\n\nintegration = Integration.load()\n\n@integration.action(\"my_action\")\nclass MyAction(ActionHandler):\n    async def execute(self, inputs, context):\n        response = await context.fetch(\"https://api.example.com/resource\")\n        return ActionResult(data=response.data)\n
    \n"}, "autohive_integrations_sdk.integration.AuthType": {"fullname": "autohive_integrations_sdk.integration.AuthType", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType", "kind": "class", "doc": "
    Authentication strategy used by an integration.
    \n\n
    The platform stores the auth type alongside credentials and passes both\nto ExecutionContext.  context.fetch() uses the type to decide\nwhether to auto-inject an Authorization header.
    \n\n
    Members:\n    PlatformOauth2: Platform-managed OAuth 2.0 \u2014 the platform handles the\n        token lifecycle and injects Bearer <access_token> automatically.\n    PlatformTeams: Platform-managed Microsoft Teams auth.\n    ApiKey: A single API key provided by the user.\n    Basic: Username/password (HTTP Basic) credentials.\n    Custom: Free-form credential fields defined by the integration's\n        config.json auth schema.  The integration is responsible for\n        reading individual fields from context.auth.
    \n", "bases": "enum.Enum"}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"fullname": "autohive_integrations_sdk.integration.AuthType.PlatformOauth2", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.PlatformOauth2", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.PlatformOauth2: 'PlatformOauth2'>"}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"fullname": "autohive_integrations_sdk.integration.AuthType.PlatformTeams", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.PlatformTeams", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.PlatformTeams: 'PlatformTeams'>"}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"fullname": "autohive_integrations_sdk.integration.AuthType.ApiKey", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.ApiKey", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.ApiKey: 'ApiKey'>"}, "autohive_integrations_sdk.integration.AuthType.Basic": {"fullname": "autohive_integrations_sdk.integration.AuthType.Basic", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.Basic", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.Basic: 'Basic'>"}, "autohive_integrations_sdk.integration.AuthType.Custom": {"fullname": "autohive_integrations_sdk.integration.AuthType.Custom", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.Custom", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.Custom: 'Custom'>"}, "autohive_integrations_sdk.integration.ResultType": {"fullname": "autohive_integrations_sdk.integration.ResultType", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType", "kind": "class", "doc": "
    Type of result being returned
    \n", "bases": "enum.Enum"}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"fullname": "autohive_integrations_sdk.integration.ResultType.ACTION", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.ACTION", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.ACTION: 'action'>"}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"fullname": "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.ACTION_ERROR", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.ACTION_ERROR: 'action_error'>"}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"fullname": "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.CONNECTED_ACCOUNT", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.CONNECTED_ACCOUNT: 'connected_account'>"}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"fullname": "autohive_integrations_sdk.integration.ResultType.ERROR", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.ERROR", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.ERROR: 'error'>"}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"fullname": "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.VALIDATION_ERROR", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.VALIDATION_ERROR: 'validation_error'>"}, "autohive_integrations_sdk.integration.ValidationError": {"fullname": "autohive_integrations_sdk.integration.ValidationError", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError", "kind": "class", "doc": "
    Raised when SDK validation fails.
    \n\n
    This covers several cases:
    \n\n
      \n
    • Action inputs don't match the input_schema in config.json
      • \n
    • Action outputs don't match the output_schema
      • \n
    • Auth credentials don't match the auth.fields schema
      • \n
    • An action handler returns something other than ActionResult
      • \n
    • A handler name isn't registered
      • \n
    \n", "bases": "builtins.Exception"}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"fullname": "autohive_integrations_sdk.integration.ValidationError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tmessage: str,\tschema: str = None,\tinputs: str = None,\tsource: str = 'legacy')"}, "autohive_integrations_sdk.integration.ValidationError.schema": {"fullname": "autohive_integrations_sdk.integration.ValidationError.schema", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.schema", "kind": "variable", "doc": "
    The schema that failed validation
    \n"}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"fullname": "autohive_integrations_sdk.integration.ValidationError.inputs", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.inputs", "kind": "variable", "doc": "
    The data that failed validation
    \n"}, "autohive_integrations_sdk.integration.ValidationError.message": {"fullname": "autohive_integrations_sdk.integration.ValidationError.message", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.message", "kind": "variable", "doc": "
    The error message
    \n"}, "autohive_integrations_sdk.integration.ValidationError.source": {"fullname": "autohive_integrations_sdk.integration.ValidationError.source", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.source", "kind": "variable", "doc": "
    Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)
    \n"}, "autohive_integrations_sdk.integration.ConfigurationError": {"fullname": "autohive_integrations_sdk.integration.ConfigurationError", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConfigurationError", "kind": "class", "doc": "
    Raised when integration configuration is invalid
    \n", "bases": "builtins.Exception"}, "autohive_integrations_sdk.integration.HTTPError": {"fullname": "autohive_integrations_sdk.integration.HTTPError", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError", "kind": "class", "doc": "
    Raised by ExecutionContext.fetch() for non-2xx HTTP responses (except 429).
    \n", "bases": "builtins.Exception"}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"fullname": "autohive_integrations_sdk.integration.HTTPError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.__init__", "kind": "function", "doc": "
    \n", "signature": "(status: int, message: str, response_data: Any = None)"}, "autohive_integrations_sdk.integration.HTTPError.status": {"fullname": "autohive_integrations_sdk.integration.HTTPError.status", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.status", "kind": "variable", "doc": "
    Status code
    \n"}, "autohive_integrations_sdk.integration.HTTPError.message": {"fullname": "autohive_integrations_sdk.integration.HTTPError.message", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.message", "kind": "variable", "doc": "
    Error message
    \n"}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"fullname": "autohive_integrations_sdk.integration.HTTPError.response_data", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.response_data", "kind": "variable", "doc": "
    Response data
    \n"}, "autohive_integrations_sdk.integration.RateLimitError": {"fullname": "autohive_integrations_sdk.integration.RateLimitError", "modulename": "autohive_integrations_sdk.integration", "qualname": "RateLimitError", "kind": "class", "doc": "
    Raised by ExecutionContext.fetch() on HTTP 429 (Too Many Requests).
    \n\n
    Attributes:\n    retry_after: Seconds to wait before retrying, taken from the\n        Retry-After response header (defaults to 60 if absent).
    \n", "bases": "HTTPError"}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"fullname": "autohive_integrations_sdk.integration.RateLimitError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "RateLimitError.__init__", "kind": "function", "doc": "
    \n", "signature": "(retry_after: int, *args, **kwargs)"}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"fullname": "autohive_integrations_sdk.integration.RateLimitError.retry_after", "modulename": "autohive_integrations_sdk.integration", "qualname": "RateLimitError.retry_after", "kind": "variable", "doc": "
    Seconds to wait before retrying.
    \n"}, "autohive_integrations_sdk.integration.FetchResponse": {"fullname": "autohive_integrations_sdk.integration.FetchResponse", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse", "kind": "class", "doc": "
    Response object returned by ExecutionContext.fetch().
    \n\n
    Wraps the full HTTP response so callers can inspect status codes and\nheaders in addition to the parsed body.
    \n\n
    Attributes:\n    status: HTTP status code (e.g. 200, 201).\n    headers: Response headers as a plain dict.\n    data: Parsed JSON (dict/list) when the response is\n        application/json, otherwise the raw response text.\n        None for empty 200/201/204 responses.
    \n"}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.__init__", "kind": "function", "doc": "
    \n", "signature": "(status: int, headers: Dict[str, str], data: Any)"}, "autohive_integrations_sdk.integration.FetchResponse.status": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.status", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.status", "kind": "variable", "doc": "
    \n", "annotation": ": int"}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.headers", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.headers", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, str]"}, "autohive_integrations_sdk.integration.FetchResponse.data": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.data", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.data", "kind": "variable", "doc": "
    \n", "annotation": ": Any"}, "autohive_integrations_sdk.integration.ActionResult": {"fullname": "autohive_integrations_sdk.integration.ActionResult", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult", "kind": "class", "doc": "
    Result returned by action handlers.
    \n\n
    This class encapsulates the data returned by an action along with optional\nbilling information for cost tracking.
    \n\n
    Args:\n    data: The actual result data from the action\n    cost_usd: Optional USD cost for billing purposes
    \n\n
    Example:
    \n\n
    \n
    return ActionResult(\n    data={"message": "Success", "result": 42},\n    cost_usd=0.05\n)\n
    \n
    \n
    \n"}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"fullname": "autohive_integrations_sdk.integration.ActionResult.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult.__init__", "kind": "function", "doc": "
    \n", "signature": "(data: Any, cost_usd: Optional[float] = None)"}, "autohive_integrations_sdk.integration.ActionResult.data": {"fullname": "autohive_integrations_sdk.integration.ActionResult.data", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult.data", "kind": "variable", "doc": "
    \n", "annotation": ": Any"}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"fullname": "autohive_integrations_sdk.integration.ActionResult.cost_usd", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult.cost_usd", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[float]", "default_value": "None"}, "autohive_integrations_sdk.integration.ActionError": {"fullname": "autohive_integrations_sdk.integration.ActionError", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError", "kind": "class", "doc": "
    Error result returned by action handlers for expected/application-level errors.
    \n\n
    When returned from an action handler, output schema validation is skipped\nand the error is returned to the caller as a ResultType.ERROR result.
    \n\n
    Args:\n    message: Human-readable error message\n    cost_usd: Optional USD cost incurred before the error occurred
    \n\n
    Example:
    \n\n
    \n
    return ActionError(\n    message="User not found",\n    cost_usd=0.01\n)\n
    \n
    \n
    \n"}, "autohive_integrations_sdk.integration.ActionError.__init__": {"fullname": "autohive_integrations_sdk.integration.ActionError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError.__init__", "kind": "function", "doc": "
    \n", "signature": "(message: str, cost_usd: Optional[float] = None)"}, "autohive_integrations_sdk.integration.ActionError.message": {"fullname": "autohive_integrations_sdk.integration.ActionError.message", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError.message", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"fullname": "autohive_integrations_sdk.integration.ActionError.cost_usd", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError.cost_usd", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[float]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo", "kind": "class", "doc": "
    Account metadata returned by a ConnectedAccountHandler.
    \n\n
    The platform calls the connected-account handler after a user links\ntheir external account.  The returned info is displayed in the\nAutohive UI (avatar, name, email, etc.).
    \n\n
    All fields are optional \u2014 populate whichever ones the external API provides.
    \n"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.__init__", "kind": "function", "doc": "
    \n", "signature": "(\temail: Optional[str] = None,\tfirst_name: Optional[str] = None,\tlast_name: Optional[str] = None,\tusername: Optional[str] = None,\tuser_id: Optional[str] = None,\tavatar_url: Optional[str] = None,\torganization: Optional[str] = None)"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.email", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.email", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.first_name", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.last_name", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.username", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.username", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.user_id", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.avatar_url", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.organization", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.IntegrationResult": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult", "kind": "class", "doc": "
    Result format sent from lambda wrapper to backend.
    \n\n
    This class represents the standardized format that the lambda wrapper\nsends to the Autohive backend, including SDK version and type-specific data.
    \n\n
    Args:\n    version: SDK version (auto-populated)\n    type: Type of result payload (ResultType enum: ACTION, CONNECTED_ACCOUNT, ERROR)\n    result: The result object - ActionResult for actions, ActionError for\n            application-level action errors, or ConnectedAccountInfo for\n            connected accounts.\n            The lambda wrapper serializes these to dicts using asdict().
    \n\n
    Note:\n    This type is returned by Integration methods and serialized by the lambda wrapper.\n    Integration developers should use ActionResult for action handlers and\n    ActionError for expected error conditions.
    \n"}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tversion: str,\ttype: autohive_integrations_sdk.integration.ResultType,\tresult: Union[autohive_integrations_sdk.integration.ActionResult, autohive_integrations_sdk.integration.ActionError, autohive_integrations_sdk.integration.ConnectedAccountInfo])"}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.version", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.version", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.type", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.type", "kind": "variable", "doc": "
    \n", "annotation": ": autohive_integrations_sdk.integration.ResultType"}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.result", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.result", "kind": "variable", "doc": "
    \n", "annotation": ": Union[autohive_integrations_sdk.integration.ActionResult, autohive_integrations_sdk.integration.ActionError, autohive_integrations_sdk.integration.ConnectedAccountInfo]"}, "autohive_integrations_sdk.integration.Parameter": {"fullname": "autohive_integrations_sdk.integration.Parameter", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter", "kind": "class", "doc": "
    Definition of a parameter
    \n"}, "autohive_integrations_sdk.integration.Parameter.__init__": {"fullname": "autohive_integrations_sdk.integration.Parameter.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\ttype: str,\tdescription: str,\tenum: Optional[List[str]] = None,\trequired: bool = True,\tdefault: Any = None)"}, "autohive_integrations_sdk.integration.Parameter.name": {"fullname": "autohive_integrations_sdk.integration.Parameter.name", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.Parameter.type": {"fullname": "autohive_integrations_sdk.integration.Parameter.type", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.type", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.Parameter.description": {"fullname": "autohive_integrations_sdk.integration.Parameter.description", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.description", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.Parameter.enum": {"fullname": "autohive_integrations_sdk.integration.Parameter.enum", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.enum", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[List[str]]", "default_value": "None"}, "autohive_integrations_sdk.integration.Parameter.required": {"fullname": "autohive_integrations_sdk.integration.Parameter.required", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.required", "kind": "variable", "doc": "
    \n", "annotation": ": bool", "default_value": "True"}, "autohive_integrations_sdk.integration.Parameter.default": {"fullname": "autohive_integrations_sdk.integration.Parameter.default", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.default", "kind": "variable", "doc": "
    \n", "annotation": ": Any", "default_value": "None"}, "autohive_integrations_sdk.integration.SchemaDefinition": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition", "kind": "class", "doc": "
    Base class for components that have input/output schemas
    \n"}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tdescription: str,\tinput_schema: List[autohive_integrations_sdk.integration.Parameter],\toutput_schema: Optional[Dict[str, Any]] = None)"}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.name", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.description", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.description", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.input_schema", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.input_schema", "kind": "variable", "doc": "
    \n", "annotation": ": List[autohive_integrations_sdk.integration.Parameter]"}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.output_schema", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.output_schema", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[Dict[str, Any]]", "default_value": "None"}, "autohive_integrations_sdk.integration.Action": {"fullname": "autohive_integrations_sdk.integration.Action", "modulename": "autohive_integrations_sdk.integration", "qualname": "Action", "kind": "class", "doc": "
    Empty dataclass that inherits from SchemaDefinition
    \n", "bases": "SchemaDefinition"}, "autohive_integrations_sdk.integration.Action.__init__": {"fullname": "autohive_integrations_sdk.integration.Action.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "Action.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tdescription: str,\tinput_schema: List[autohive_integrations_sdk.integration.Parameter],\toutput_schema: Optional[Dict[str, Any]] = None)"}, "autohive_integrations_sdk.integration.PollingTrigger": {"fullname": "autohive_integrations_sdk.integration.PollingTrigger", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTrigger", "kind": "class", "doc": "
    Definition of a polling trigger
    \n", "bases": "SchemaDefinition"}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"fullname": "autohive_integrations_sdk.integration.PollingTrigger.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTrigger.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tdescription: str,\tinput_schema: List[autohive_integrations_sdk.integration.Parameter],\toutput_schema: Optional[Dict[str, Any]] = None,\tpolling_interval: datetime.timedelta = <factory>)"}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"fullname": "autohive_integrations_sdk.integration.PollingTrigger.polling_interval", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTrigger.polling_interval", "kind": "variable", "doc": "
    \n", "annotation": ": datetime.timedelta"}, "autohive_integrations_sdk.integration.IntegrationConfig": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig", "kind": "class", "doc": "
    Configuration for an integration
    \n"}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tversion: str,\tdescription: str,\tauth: Dict[str, Any],\tactions: Dict[str, autohive_integrations_sdk.integration.Action],\tpolling_triggers: Dict[str, autohive_integrations_sdk.integration.PollingTrigger])"}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.name", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.version", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.version", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.description", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.description", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.auth", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.auth", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, Any]"}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.actions", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.actions", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, autohive_integrations_sdk.integration.Action]"}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.polling_triggers", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, autohive_integrations_sdk.integration.PollingTrigger]"}, "autohive_integrations_sdk.integration.ActionHandler": {"fullname": "autohive_integrations_sdk.integration.ActionHandler", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionHandler", "kind": "class", "doc": "
    Base class for action handlers.
    \n\n
    Subclass this and implement execute() to handle a specific action.\nRegister it with the @integration.action(\"action_name\") decorator.
    \n\n
    Example::
    \n\n
    @integration.action(\"get_user\")\nclass GetUser(ActionHandler):\n    async def execute(self, inputs, context):\n        user = (await context.fetch(f\"https://api.example.com/users/{inputs['id']}\")).data\n        return ActionResult(data=user)\n
    \n", "bases": "abc.ABC"}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"fullname": "autohive_integrations_sdk.integration.ActionHandler.execute", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionHandler.execute", "kind": "function", "doc": "
    Run the action logic.
    \n\n
    Args:\n    inputs: Validated action inputs matching the input_schema from config.json.\n    context: Execution context providing fetch(), auth, and logging.
    \n\n
    Returns:\n    An ActionResult containing the output data and optional cost_usd.
    \n", "signature": "(\tself,\tinputs: Dict[str, Any],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> Any:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"fullname": "autohive_integrations_sdk.integration.PollingTriggerHandler", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTriggerHandler", "kind": "class", "doc": "
    Base class for polling trigger handlers
    \n", "bases": "abc.ABC"}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"fullname": "autohive_integrations_sdk.integration.PollingTriggerHandler.poll", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTriggerHandler.poll", "kind": "function", "doc": "
    Execute the polling trigger
    \n", "signature": "(\tself,\tinputs: Dict[str, Any],\tlast_poll_ts: Optional[str],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> List[Dict[str, Any]]:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountHandler", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountHandler", "kind": "class", "doc": "
    Base class for connected-account handlers.
    \n\n
    The platform calls this after a user links their external account.\nThe returned ConnectedAccountInfo is shown in the Autohive UI.
    \n\n
    Register with the @integration.connected_account() decorator.
    \n\n
    Example::
    \n\n
    @integration.connected_account()\nclass MyAccountHandler(ConnectedAccountHandler):\n    async def get_account_info(self, context):\n        me = (await context.fetch(\"https://api.example.com/me\")).data\n        return ConnectedAccountInfo(\n            email=me[\"email\"],\n            first_name=me[\"first_name\"],\n            last_name=me[\"last_name\"],\n        )\n
    \n", "bases": "abc.ABC"}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountHandler.get_account_info", "kind": "function", "doc": "
    Fetch account metadata from the external service.
    \n\n
    For platform OAuth integrations, context.fetch() auto-injects\nthe Bearer token \u2014 no manual auth handling needed.
    \n\n
    Returns:\n    A ConnectedAccountInfo with whichever fields the API provides.
    \n", "signature": "(\tself,\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> autohive_integrations_sdk.integration.ConnectedAccountInfo:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.ExecutionContext": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext", "kind": "class", "doc": "
    Context provided to integration handlers for making authenticated HTTP requests.
    \n\n
    Manages an aiohttp session with automatic retries, error handling, and\noptional Bearer-token injection for platform OAuth integrations.
    \n\n
    Use as an async context manager::
    \n\n
    async with ExecutionContext(auth=auth) as context:\n    result = await integration.execute_action(\"my_action\", inputs, context)\n
    \n\n
    Args:\n    auth: Authentication data.  In local tests this is a flat dict\n        matching the auth.fields schema in config.json\n        (e.g. {\"api_key\": \"...\"}).  In production the platform\n        wraps credentials as {\"auth_type\": \"...\", \"credentials\": {...}}.\n    request_config: Override default max_retries (3) and timeout (30 s).\n    metadata: Arbitrary metadata forwarded to handlers.\n    logger: Custom logger; falls back to logging.getLogger(__name__).
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tauth: Dict[str, Any] = {},\trequest_config: Optional[Dict[str, Any]] = None,\tmetadata: Optional[Dict[str, Any]] = None,\tlogger: Optional[logging.Logger] = None)"}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.auth", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.auth", "kind": "variable", "doc": "
    Authentication configuration
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.config", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.config", "kind": "variable", "doc": "
    Request configuration
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.metadata", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.metadata", "kind": "variable", "doc": "
    Additional metadata
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.logger", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.logger", "kind": "variable", "doc": "
    Logger instance
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.fetch", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.fetch", "kind": "function", "doc": "
    Make an HTTP request with automatic retries and error handling.
    \n\n
    For platform OAuth integrations (auth_type == \"PlatformOauth2\"),\na Bearer token is auto-injected from auth.credentials.access_token\nunless an Authorization header is explicitly provided.
    \n\n
    Retries up to max_retries (default 3) on transient network errors\nwith exponential back-off.  HTTP 429 responses raise RateLimitError\nimmediately (no automatic retry).
    \n\n
    Args:\n    url: The URL to request.\n    method: HTTP method (\"GET\", \"POST\", \"PUT\", etc.).\n    params: Query parameters appended to the URL.  Nested dicts/lists\n        are JSON-serialized automatically.\n    data: Raw request body.  Encoding depends on content_type.\n    json: JSON-serializable payload.  Sets content_type to\n        application/json automatically.\n    headers: Additional HTTP headers.  Merged after any auto-injected\n        auth header, so an explicit Authorization takes precedence.\n    content_type: Content-Type header value.\n    timeout: Per-request timeout in seconds (overrides request_config).\n    retry_count: Internal \u2014 current retry attempt number.
    \n\n
    Returns:\n    A FetchResponse containing the HTTP status code, response\n    headers, and parsed body data.
    \n\n
    Raises:\n    RateLimitError: On HTTP 429 with the Retry-After value.\n    HTTPError: On any other non-2xx status.
    \n", "signature": "(\tself,\turl: str,\tmethod: str = 'GET',\tparams: Optional[Dict[str, Any]] = None,\tdata: Any = None,\tjson: Any = None,\theaders: Optional[Dict[str, str]] = None,\tcontent_type: Optional[str] = None,\ttimeout: Optional[int] = None,\tretry_count: int = 0) -> autohive_integrations_sdk.integration.FetchResponse:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.Integration": {"fullname": "autohive_integrations_sdk.integration.Integration", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration", "kind": "class", "doc": "
    Base integration class with handler registration and execution.
    \n\n
    This class manages the integration configuration, handler registration,\nand provides methods to execute actions and triggers.
    \n\n
    Args:\n    config: Integration configuration
    \n\n
    Attributes:\n    config: Integration configuration
    \n"}, "autohive_integrations_sdk.integration.Integration.__init__": {"fullname": "autohive_integrations_sdk.integration.Integration.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.__init__", "kind": "function", "doc": "
    \n", "signature": "(config: autohive_integrations_sdk.integration.IntegrationConfig)"}, "autohive_integrations_sdk.integration.Integration.config": {"fullname": "autohive_integrations_sdk.integration.Integration.config", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.config", "kind": "variable", "doc": "
    Integration configuration
    \n"}, "autohive_integrations_sdk.integration.Integration.load": {"fullname": "autohive_integrations_sdk.integration.Integration.load", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.load", "kind": "function", "doc": "
    Load an integration from its config.json.
    \n\n
    Args:\n    config_path: Explicit path to config.json.  When omitted the\n        SDK resolves the path relative to its own package location,\n        which works when the SDK is vendored via\n        pip install --target dependencies.  Multi-file integrations\n        that use actions/ sub-packages should pass an explicit path\n        (e.g. Integration.load(\"config.json\")).
    \n\n
    Returns:\n    A fully initialised Integration ready for handler registration.
    \n\n
    Raises:\n    ConfigurationError: If the file is missing or contains invalid JSON.
    \n", "signature": "(\tcls,\tconfig_path: Union[str, pathlib._local.Path] = None) -> autohive_integrations_sdk.integration.Integration:", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.action": {"fullname": "autohive_integrations_sdk.integration.Integration.action", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.action", "kind": "function", "doc": "
    Decorator to register an action handler.
    \n\n
    Args:\n    name: Name of the action to register
    \n\n
    Returns:\n    Decorator function
    \n\n
    Raises:\n    ConfigurationError: If action is not defined in config
    \n\n
    Example:
    \n\n
    \n
    @integration.action("my_action")\nclass MyActionHandler(ActionHandler):\n    async def execute(self, inputs, context):\n        # Implementation\n        return result\n
    \n
    \n
    \n", "signature": "(self, name: str):", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"fullname": "autohive_integrations_sdk.integration.Integration.polling_trigger", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.polling_trigger", "kind": "function", "doc": "
    Decorator to register a polling trigger handler
    \n\n
    Args:\n    name: Name of the polling trigger to register
    \n\n
    Returns:\n    Decorator function
    \n\n
    Raises:\n    ConfigurationError: If polling trigger is not defined in config
    \n\n
    Example:
    \n\n
    \n
    @integration.polling_trigger("my_polling_trigger")\nclass MyPollingTriggerHandler(PollingTriggerHandler):\n    async def poll(self, inputs, last_poll_ts, context):\n        # Implementation\n        return result\n
    \n
    \n
    \n", "signature": "(self, name: str):", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.connected_account": {"fullname": "autohive_integrations_sdk.integration.Integration.connected_account", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.connected_account", "kind": "function", "doc": "
    Decorator to register a connected account handler
    \n\n
    Returns:\n    Decorator function
    \n\n
    Example:
    \n\n
    \n
    @integration.connected_account()\nclass MyConnectedAccountHandler(ConnectedAccountHandler):\n    async def get_account_info(self, context):\n        # Implementation\n        return {"email": "user@example.com", "name": "John Doe"}\n
    \n
    \n
    \n", "signature": "(self):", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.execute_action": {"fullname": "autohive_integrations_sdk.integration.Integration.execute_action", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.execute_action", "kind": "function", "doc": "
    Execute a registered action.
    \n\n
    Args:\n    name: Name of the action to execute\n    inputs: Action inputs\n    context: Execution context
    \n\n
    Returns:\n    IntegrationResult with action data (ResultType.ACTION),\n    action error (ResultType.ACTION_ERROR) if the handler returned ActionError,\n    or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
    \n", "signature": "(\tself,\tname: str,\tinputs: Dict[str, Any],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> autohive_integrations_sdk.integration.IntegrationResult:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"fullname": "autohive_integrations_sdk.integration.Integration.execute_polling_trigger", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.execute_polling_trigger", "kind": "function", "doc": "
    Execute a registered polling trigger
    \n\n
    Args:\n    name: Name of the polling trigger to execute\n    inputs: Trigger inputs\n    last_poll_ts: Last poll timestamp\n    context: Execution context
    \n\n
    Returns:\n    List of records
    \n\n
    Raises:\n    ValidationError: If inputs or outputs don't match schema
    \n", "signature": "(\tself,\tname: str,\tinputs: Dict[str, Any],\tlast_poll_ts: Optional[str],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> List[Dict[str, Any]]:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"fullname": "autohive_integrations_sdk.integration.Integration.get_connected_account", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.get_connected_account", "kind": "function", "doc": "
    Get connected account information
    \n\n
    Args:\n    context: Execution context
    \n\n
    Returns:\n    IntegrationResult containing connected account data
    \n\n
    Raises:\n    ValidationError: If no connected account handler is registered or auth is invalid
    \n", "signature": "(\tself,\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> autohive_integrations_sdk.integration.IntegrationResult:", "funcdef": "async def"}}, "docInfo": {"autohive_integrations_sdk": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 161}, "autohive_integrations_sdk.integration.AuthType": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 123}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.Basic": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.Custom": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 7}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ValidationError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 80}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ValidationError.schema": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "autohive_integrations_sdk.integration.ValidationError.message": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 5}, "autohive_integrations_sdk.integration.ValidationError.source": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "autohive_integrations_sdk.integration.ConfigurationError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 8}, "autohive_integrations_sdk.integration.HTTPError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 17}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.HTTPError.status": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.HTTPError.message": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.RateLimitError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 41}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "autohive_integrations_sdk.integration.FetchResponse": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 86}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.FetchResponse.status": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"qualname": 2, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.FetchResponse.data": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionResult": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 130}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionResult.data": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 117}, "autohive_integrations_sdk.integration.ActionError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionError.message": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 56}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 176, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 114}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 103, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"qualname": 2, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"qualname": 2, "fullname": 6, "annotation": 16, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "autohive_integrations_sdk.integration.Parameter.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.name": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.type": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.description": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.enum": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.required": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.default": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"qualname": 3, "fullname": 7, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"qualname": 3, "fullname": 7, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Action": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 8}, "autohive_integrations_sdk.integration.Action.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.PollingTrigger": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 7}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 123, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"qualname": 3, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 131, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"qualname": 2, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"qualname": 3, "fullname": 7, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionHandler": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 74}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 57}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 8}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 96, "bases": 0, "doc": 6}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 96}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 50, "bases": 0, "doc": 47}, "autohive_integrations_sdk.integration.ExecutionContext": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 155}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 132, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 232, "bases": 0, "doc": 238}, "autohive_integrations_sdk.integration.Integration": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 42}, "autohive_integrations_sdk.integration.Integration.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Integration.config": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.Integration.load": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 69, "bases": 0, "doc": 104}, "autohive_integrations_sdk.integration.Integration.action": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 132}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 144}, "autohive_integrations_sdk.integration.Integration.connected_account": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 136}, "autohive_integrations_sdk.integration.Integration.execute_action": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 53}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 107, "bases": 0, "doc": 48}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 50, "bases": 0, "doc": 35}}, "length": 106, "save": true}, "index": {"qualname": {"root": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}}, "df": 1}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 2}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 4}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 8}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 3, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 9}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}}, "df": 2}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 10, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 5}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 8}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 3, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}}, "df": 3}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}}, "df": 5}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}, "fullname": {"root": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk": {"tf": 1}, "autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 106}}}}}, "h": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}}, "df": 1}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 2}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 4}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 105, "s": {"docs": {"autohive_integrations_sdk": {"tf": 1}, "autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 106}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 5}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 8}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk": {"tf": 1}, "autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 106}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 3, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 8}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 3, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 9}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}}, "df": 2}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}}, "df": 3}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}}, "df": 5}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}, "annotation": {"root": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 34, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 4}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}}, "df": 11}}, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 5}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}}, "df": 5}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 4}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 7}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}}}}}}, "default_value": {"root": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 10, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 10}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 5}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}, "x": {"2": {"7": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 10}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "g": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 10}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 5}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 12}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}}}, "signature": {"root": {"0": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}, "3": {"9": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 7.745966692414834}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 5.830951894845301}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 4.898979485566356}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 6.164414002968976}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 5.5677643628300215}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 5.5677643628300215}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 12}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 8.831760866327848}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 9.16515138991168}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 8.48528137423857}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 8.48528137423857}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 9.848857801796104}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 10.198039027185569}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 7}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 8.717797887081348}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 6.164414002968976}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 10.488088481701515}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 13.711309200802088}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 4.47213595499958}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 7.416198487095663}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 4.242640687119285}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 4.242640687119285}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 3.1622776601683795}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 8.12403840463596}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 9.219544457292887}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 6.164414002968976}}, "df": 26, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 2.6457513110645907}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 2}}, "df": 20}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1.4142135623730951}}, "df": 4}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 10}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 2.6457513110645907}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 12}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 10}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 5}}}}, "t": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 6}}}, "t": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 11}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 5}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 14}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}}, "df": 1}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14}}}}}, "h": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 2.6457513110645907}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 11}}}}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 3}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 1, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1.4142135623730951}}, "df": 2}}}, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}}, "df": 3}}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}}, "df": 3}}}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "doc": {"root": {"0": {"1": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}, "5": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}, "docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 3}, "2": {"0": {"0": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1, "/": {"2": {"0": {"1": {"docs": {}, "df": 0, "/": {"2": {"0": {"4": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "1": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "x": {"docs": {}, "df": 0, "x": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "3": {"0": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}, "docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "4": {"2": {"9": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 3}, "docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "6": {"0": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"autohive_integrations_sdk": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration": {"tf": 7.416198487095663}, "autohive_integrations_sdk.integration.AuthType": {"tf": 4.898979485566356}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 5.385164807134504}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 3.3166247903554}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 5}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 8.54400374531753}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 7.3484692283495345}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 3.4641016151377544}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 3.4641016151377544}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 4.69041575982343}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 4.69041575982343}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 5.0990195135927845}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 3.872983346207417}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 6.708203932499369}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 8}, "autohive_integrations_sdk.integration.Integration": {"tf": 3.1622776601683795}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 5}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 9.327379053088816}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 9.539392014169456}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 9.797958971132712}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 2.8284271247461903}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 2.8284271247461903}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 2.8284271247461903}}, "df": 106, "a": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 17, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 4}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "h": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 7, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}}, "df": 3}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}}}, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}}, "df": 10, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.7320508075688772}}, "df": 10}, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 2.6457513110645907}}, "df": 10, "/": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 6}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.7320508075688772}}, "df": 7, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.7320508075688772}}, "df": 3, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 7}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 4, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 13}}, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 8, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 14, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.7320508075688772}}, "df": 9}, "/": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}}}}}}}}}}, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 13, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}, "f": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 7}, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 1}}, "d": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 4}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 6}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 8, "s": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "o": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 10, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.7320508075688772}}, "df": 6, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 4}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 13}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3}}}, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 2}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 4}}, "m": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "{": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 11}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}}}, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.action": {"tf": 1}}, "df": 1}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2}}, "df": 1, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}}, "df": 4}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}}, "df": 4}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 2}, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "x": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 4}, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 2}}, "df": 1}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 2}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 6, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 5, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "h": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 2.8284271247461903}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 2}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 26, "i": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 7}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 6}}}, "o": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 17, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4}}}, "o": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.23606797749979}}, "df": 6}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.7320508075688772}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 6}, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "y": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}}, "df": 9}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 3}}}}}}, "f": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 16, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 11}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}}, "df": 9, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 5}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 3}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1, "y": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 2}}, "o": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 2}}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 8, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 9}}, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 11}}}}, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.7320508075688772}}, "df": 3}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.23606797749979}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1, "d": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 4}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}}}}, "w": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 11, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}}, "df": 8}}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.449489742783178}}, "df": 7, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 2}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 5, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 6}}}}}}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 8}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 8}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 2, "l": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 3}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 2}}, "df": 7, "s": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}}, "df": 1}}}, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 5}, "r": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 8}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 6}}}}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}, "f": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 8, "f": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}, "n": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 2}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 13, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 5, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "@": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}}}}}}}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 1}}}, "g": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 5, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 2}}, "df": 7}}}, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.7320508075688772}}, "df": 6, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 10}}}, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3, "n": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}, "t": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 3, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 2.8284271247461903}}, "df": 5}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
+    /** pdoc search index */const docs = {"version": "0.9.5", "fields": ["qualname", "fullname", "annotation", "default_value", "signature", "bases", "doc"], "ref": "fullname", "documentStore": {"docs": {"autohive_integrations_sdk": {"fullname": "autohive_integrations_sdk", "modulename": "autohive_integrations_sdk", "kind": "module", "doc": "
    \n"}, "autohive_integrations_sdk.integration": {"fullname": "autohive_integrations_sdk.integration", "modulename": "autohive_integrations_sdk.integration", "kind": "module", "doc": "
    Autohive Integrations SDK \u2014 core module.
    \n\n
    Provides the building blocks for creating Autohive integrations:
    \n\n
      \n
    • Integration \u2014 load config and register action/trigger/connected-account handlers
      • \n
    • ExecutionContext \u2014 authenticated HTTP client passed to every handler
      • \n
    • ActionHandler \u2014 base class for action implementations (return ActionResult)
      • \n
    • ConnectedAccountHandler \u2014 base class for connected-account lookups (return ConnectedAccountInfo)
      • \n
    • ActionResult \u2014 standard return type wrapping action output data and optional billing cost
      • \n
    • ActionError \u2014 return type for expected application-level errors (bypasses output schema validation)
      • \n
    • FetchResponse \u2014 response object from context.fetch() with .status, .headers, and .data
      • \n
    • ConnectedAccountInfo \u2014 structured account info returned by connected-account handlers
      • \n
    • HTTPError / RateLimitError \u2014 exceptions raised by context.fetch() for non-2xx responses
      • \n
    \n\n
    Typical usage::
    \n\n
    from autohive_integrations_sdk import Integration, ActionHandler, ActionResult, ExecutionContext\n\nintegration = Integration.load()\n\n@integration.action(\"my_action\")\nclass MyAction(ActionHandler):\n    async def execute(self, inputs, context):\n        response = await context.fetch(\"https://api.example.com/resource\")\n        return ActionResult(data=response.data)\n
    \n"}, "autohive_integrations_sdk.integration.AuthType": {"fullname": "autohive_integrations_sdk.integration.AuthType", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType", "kind": "class", "doc": "
    Authentication strategy used by an integration.
    \n\n
    The platform stores the auth type alongside credentials and passes both\nto ExecutionContext.  context.fetch() uses the type to decide\nwhether to auto-inject an Authorization header.
    \n\n
    Members:\n    PlatformOauth2: Platform-managed OAuth 2.0 \u2014 the platform handles the\n        token lifecycle and injects Bearer <access_token> automatically.\n    PlatformTeams: Platform-managed Microsoft Teams auth.\n    ApiKey: A single API key provided by the user.\n    Basic: Username/password (HTTP Basic) credentials.\n    Custom: Free-form credential fields defined by the integration's\n        config.json auth schema.  The integration is responsible for\n        reading individual fields from context.auth.
    \n", "bases": "enum.Enum"}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"fullname": "autohive_integrations_sdk.integration.AuthType.PlatformOauth2", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.PlatformOauth2", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.PlatformOauth2: 'PlatformOauth2'>"}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"fullname": "autohive_integrations_sdk.integration.AuthType.PlatformTeams", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.PlatformTeams", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.PlatformTeams: 'PlatformTeams'>"}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"fullname": "autohive_integrations_sdk.integration.AuthType.ApiKey", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.ApiKey", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.ApiKey: 'ApiKey'>"}, "autohive_integrations_sdk.integration.AuthType.Basic": {"fullname": "autohive_integrations_sdk.integration.AuthType.Basic", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.Basic", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.Basic: 'Basic'>"}, "autohive_integrations_sdk.integration.AuthType.Custom": {"fullname": "autohive_integrations_sdk.integration.AuthType.Custom", "modulename": "autohive_integrations_sdk.integration", "qualname": "AuthType.Custom", "kind": "variable", "doc": "
    \n", "default_value": "<AuthType.Custom: 'Custom'>"}, "autohive_integrations_sdk.integration.ResultType": {"fullname": "autohive_integrations_sdk.integration.ResultType", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType", "kind": "class", "doc": "
    Type of result being returned
    \n", "bases": "enum.Enum"}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"fullname": "autohive_integrations_sdk.integration.ResultType.ACTION", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.ACTION", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.ACTION: 'action'>"}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"fullname": "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.ACTION_ERROR", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.ACTION_ERROR: 'action_error'>"}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"fullname": "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.CONNECTED_ACCOUNT", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.CONNECTED_ACCOUNT: 'connected_account'>"}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"fullname": "autohive_integrations_sdk.integration.ResultType.ERROR", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.ERROR", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.ERROR: 'error'>"}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"fullname": "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR", "modulename": "autohive_integrations_sdk.integration", "qualname": "ResultType.VALIDATION_ERROR", "kind": "variable", "doc": "
    \n", "default_value": "<ResultType.VALIDATION_ERROR: 'validation_error'>"}, "autohive_integrations_sdk.integration.ValidationError": {"fullname": "autohive_integrations_sdk.integration.ValidationError", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError", "kind": "class", "doc": "
    Raised when SDK validation fails.
    \n\n
    This covers several cases:
    \n\n
      \n
    • Action inputs don't match the input_schema in config.json
      • \n
    • Action outputs don't match the output_schema
      • \n
    • Auth credentials don't match the auth.fields schema
      • \n
    • An action handler returns something other than ActionResult
      • \n
    • A handler name isn't registered
      • \n
    \n", "bases": "builtins.Exception"}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"fullname": "autohive_integrations_sdk.integration.ValidationError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tmessage: str,\tschema: str = None,\tinputs: str = None,\tsource: str = 'legacy')"}, "autohive_integrations_sdk.integration.ValidationError.schema": {"fullname": "autohive_integrations_sdk.integration.ValidationError.schema", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.schema", "kind": "variable", "doc": "
    The schema that failed validation
    \n"}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"fullname": "autohive_integrations_sdk.integration.ValidationError.inputs", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.inputs", "kind": "variable", "doc": "
    The data that failed validation
    \n"}, "autohive_integrations_sdk.integration.ValidationError.message": {"fullname": "autohive_integrations_sdk.integration.ValidationError.message", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.message", "kind": "variable", "doc": "
    The error message
    \n"}, "autohive_integrations_sdk.integration.ValidationError.source": {"fullname": "autohive_integrations_sdk.integration.ValidationError.source", "modulename": "autohive_integrations_sdk.integration", "qualname": "ValidationError.source", "kind": "variable", "doc": "
    Where the validation failed: 'input', 'output', or 'legacy' (pre-versioning default)
    \n"}, "autohive_integrations_sdk.integration.ConfigurationError": {"fullname": "autohive_integrations_sdk.integration.ConfigurationError", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConfigurationError", "kind": "class", "doc": "
    Raised when integration configuration is invalid
    \n", "bases": "builtins.Exception"}, "autohive_integrations_sdk.integration.HTTPError": {"fullname": "autohive_integrations_sdk.integration.HTTPError", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError", "kind": "class", "doc": "
    Raised by ExecutionContext.fetch() for non-2xx HTTP responses (except 429).
    \n", "bases": "builtins.Exception"}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"fullname": "autohive_integrations_sdk.integration.HTTPError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.__init__", "kind": "function", "doc": "
    \n", "signature": "(status: int, message: str, response_data: Any = None)"}, "autohive_integrations_sdk.integration.HTTPError.status": {"fullname": "autohive_integrations_sdk.integration.HTTPError.status", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.status", "kind": "variable", "doc": "
    Status code
    \n"}, "autohive_integrations_sdk.integration.HTTPError.message": {"fullname": "autohive_integrations_sdk.integration.HTTPError.message", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.message", "kind": "variable", "doc": "
    Error message
    \n"}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"fullname": "autohive_integrations_sdk.integration.HTTPError.response_data", "modulename": "autohive_integrations_sdk.integration", "qualname": "HTTPError.response_data", "kind": "variable", "doc": "
    Response data
    \n"}, "autohive_integrations_sdk.integration.RateLimitError": {"fullname": "autohive_integrations_sdk.integration.RateLimitError", "modulename": "autohive_integrations_sdk.integration", "qualname": "RateLimitError", "kind": "class", "doc": "
    Raised by ExecutionContext.fetch() on HTTP 429 (Too Many Requests).
    \n\n
    Attributes:\n    retry_after: Seconds to wait before retrying, taken from the\n        Retry-After response header (defaults to 60 if absent).
    \n", "bases": "HTTPError"}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"fullname": "autohive_integrations_sdk.integration.RateLimitError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "RateLimitError.__init__", "kind": "function", "doc": "
    \n", "signature": "(retry_after: int, *args, **kwargs)"}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"fullname": "autohive_integrations_sdk.integration.RateLimitError.retry_after", "modulename": "autohive_integrations_sdk.integration", "qualname": "RateLimitError.retry_after", "kind": "variable", "doc": "
    Seconds to wait before retrying.
    \n"}, "autohive_integrations_sdk.integration.FetchResponse": {"fullname": "autohive_integrations_sdk.integration.FetchResponse", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse", "kind": "class", "doc": "
    Response object returned by ExecutionContext.fetch().
    \n\n
    Wraps the full HTTP response so callers can inspect status codes and\nheaders in addition to the parsed body.
    \n\n
    Attributes:\n    status: HTTP status code (e.g. 200, 201).\n    headers: Response headers as a plain dict.\n    data: Parsed JSON (dict/list) when the response is\n        application/json, otherwise the raw response text.\n        None for empty 200/201/204 responses.
    \n"}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.__init__", "kind": "function", "doc": "
    \n", "signature": "(status: int, headers: Dict[str, str], data: Any)"}, "autohive_integrations_sdk.integration.FetchResponse.status": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.status", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.status", "kind": "variable", "doc": "
    \n", "annotation": ": int"}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.headers", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.headers", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, str]"}, "autohive_integrations_sdk.integration.FetchResponse.data": {"fullname": "autohive_integrations_sdk.integration.FetchResponse.data", "modulename": "autohive_integrations_sdk.integration", "qualname": "FetchResponse.data", "kind": "variable", "doc": "
    \n", "annotation": ": Any"}, "autohive_integrations_sdk.integration.ActionResult": {"fullname": "autohive_integrations_sdk.integration.ActionResult", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult", "kind": "class", "doc": "
    Result returned by action handlers.
    \n\n
    This class encapsulates the data returned by an action along with optional\nbilling information for cost tracking.
    \n\n
    Args:\n    data: The actual result data from the action\n    cost_usd: Optional USD cost for billing purposes
    \n\n
    Example:
    \n\n
    \n
    return ActionResult(\n    data={"message": "Success", "result": 42},\n    cost_usd=0.05\n)\n
    \n
    \n
    \n"}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"fullname": "autohive_integrations_sdk.integration.ActionResult.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult.__init__", "kind": "function", "doc": "
    \n", "signature": "(data: Any, cost_usd: Optional[float] = None)"}, "autohive_integrations_sdk.integration.ActionResult.data": {"fullname": "autohive_integrations_sdk.integration.ActionResult.data", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult.data", "kind": "variable", "doc": "
    \n", "annotation": ": Any"}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"fullname": "autohive_integrations_sdk.integration.ActionResult.cost_usd", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionResult.cost_usd", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[float]", "default_value": "None"}, "autohive_integrations_sdk.integration.ActionError": {"fullname": "autohive_integrations_sdk.integration.ActionError", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError", "kind": "class", "doc": "
    Error result returned by action handlers for expected/application-level errors.
    \n\n
    When returned from an action handler, output schema validation is skipped\nand the error is returned to the caller as a ResultType.ERROR result.
    \n\n
    Args:\n    message: Human-readable error message\n    cost_usd: Optional USD cost incurred before the error occurred
    \n\n
    Example:
    \n\n
    \n
    return ActionError(\n    message="User not found",\n    cost_usd=0.01\n)\n
    \n
    \n
    \n"}, "autohive_integrations_sdk.integration.ActionError.__init__": {"fullname": "autohive_integrations_sdk.integration.ActionError.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError.__init__", "kind": "function", "doc": "
    \n", "signature": "(message: str, cost_usd: Optional[float] = None)"}, "autohive_integrations_sdk.integration.ActionError.message": {"fullname": "autohive_integrations_sdk.integration.ActionError.message", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError.message", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"fullname": "autohive_integrations_sdk.integration.ActionError.cost_usd", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionError.cost_usd", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[float]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo", "kind": "class", "doc": "
    Account metadata returned by a ConnectedAccountHandler.
    \n\n
    The platform calls the connected-account handler after a user links\ntheir external account.  The returned info is displayed in the\nAutohive UI (avatar, name, email, etc.).
    \n\n
    All fields are optional \u2014 populate whichever ones the external API provides.
    \n"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.__init__", "kind": "function", "doc": "
    \n", "signature": "(\temail: Optional[str] = None,\tfirst_name: Optional[str] = None,\tlast_name: Optional[str] = None,\tusername: Optional[str] = None,\tuser_id: Optional[str] = None,\tavatar_url: Optional[str] = None,\torganization: Optional[str] = None)"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.email", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.email", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.first_name", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.last_name", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.username", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.username", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.user_id", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.avatar_url", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountInfo.organization", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[str]", "default_value": "None"}, "autohive_integrations_sdk.integration.IntegrationResult": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult", "kind": "class", "doc": "
    Result format sent from lambda wrapper to backend.
    \n\n
    This class represents the standardized format that the lambda wrapper\nsends to the Autohive backend, including SDK version and type-specific data.
    \n\n
    Args:\n    version: SDK version (auto-populated)\n    type: Type of result payload (ResultType enum: ACTION, CONNECTED_ACCOUNT, ERROR)\n    result: The result object - ActionResult for actions, ActionError for\n            application-level action errors, or ConnectedAccountInfo for\n            connected accounts.\n            The lambda wrapper serializes these to dicts using asdict().
    \n\n
    Note:\n    This type is returned by Integration methods and serialized by the lambda wrapper.\n    Integration developers should use ActionResult for action handlers and\n    ActionError for expected error conditions.
    \n"}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tversion: str,\ttype: autohive_integrations_sdk.integration.ResultType,\tresult: Union[autohive_integrations_sdk.integration.ActionResult, autohive_integrations_sdk.integration.ActionError, autohive_integrations_sdk.integration.ConnectedAccountInfo])"}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.version", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.version", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.type", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.type", "kind": "variable", "doc": "
    \n", "annotation": ": autohive_integrations_sdk.integration.ResultType"}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"fullname": "autohive_integrations_sdk.integration.IntegrationResult.result", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationResult.result", "kind": "variable", "doc": "
    \n", "annotation": ": Union[autohive_integrations_sdk.integration.ActionResult, autohive_integrations_sdk.integration.ActionError, autohive_integrations_sdk.integration.ConnectedAccountInfo]"}, "autohive_integrations_sdk.integration.Parameter": {"fullname": "autohive_integrations_sdk.integration.Parameter", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter", "kind": "class", "doc": "
    Definition of a parameter
    \n"}, "autohive_integrations_sdk.integration.Parameter.__init__": {"fullname": "autohive_integrations_sdk.integration.Parameter.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\ttype: str,\tdescription: str,\tenum: Optional[List[str]] = None,\trequired: bool = True,\tdefault: Any = None)"}, "autohive_integrations_sdk.integration.Parameter.name": {"fullname": "autohive_integrations_sdk.integration.Parameter.name", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.Parameter.type": {"fullname": "autohive_integrations_sdk.integration.Parameter.type", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.type", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.Parameter.description": {"fullname": "autohive_integrations_sdk.integration.Parameter.description", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.description", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.Parameter.enum": {"fullname": "autohive_integrations_sdk.integration.Parameter.enum", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.enum", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[List[str]]", "default_value": "None"}, "autohive_integrations_sdk.integration.Parameter.required": {"fullname": "autohive_integrations_sdk.integration.Parameter.required", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.required", "kind": "variable", "doc": "
    \n", "annotation": ": bool", "default_value": "True"}, "autohive_integrations_sdk.integration.Parameter.default": {"fullname": "autohive_integrations_sdk.integration.Parameter.default", "modulename": "autohive_integrations_sdk.integration", "qualname": "Parameter.default", "kind": "variable", "doc": "
    \n", "annotation": ": Any", "default_value": "None"}, "autohive_integrations_sdk.integration.SchemaDefinition": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition", "kind": "class", "doc": "
    Base class for components that have input/output schemas
    \n"}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tdescription: str,\tinput_schema: List[autohive_integrations_sdk.integration.Parameter],\toutput_schema: Optional[Dict[str, Any]] = None)"}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.name", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.description", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.description", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.input_schema", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.input_schema", "kind": "variable", "doc": "
    \n", "annotation": ": List[autohive_integrations_sdk.integration.Parameter]"}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"fullname": "autohive_integrations_sdk.integration.SchemaDefinition.output_schema", "modulename": "autohive_integrations_sdk.integration", "qualname": "SchemaDefinition.output_schema", "kind": "variable", "doc": "
    \n", "annotation": ": Optional[Dict[str, Any]]", "default_value": "None"}, "autohive_integrations_sdk.integration.Action": {"fullname": "autohive_integrations_sdk.integration.Action", "modulename": "autohive_integrations_sdk.integration", "qualname": "Action", "kind": "class", "doc": "
    Empty dataclass that inherits from SchemaDefinition
    \n", "bases": "SchemaDefinition"}, "autohive_integrations_sdk.integration.Action.__init__": {"fullname": "autohive_integrations_sdk.integration.Action.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "Action.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tdescription: str,\tinput_schema: List[autohive_integrations_sdk.integration.Parameter],\toutput_schema: Optional[Dict[str, Any]] = None)"}, "autohive_integrations_sdk.integration.PollingTrigger": {"fullname": "autohive_integrations_sdk.integration.PollingTrigger", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTrigger", "kind": "class", "doc": "
    Definition of a polling trigger
    \n", "bases": "SchemaDefinition"}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"fullname": "autohive_integrations_sdk.integration.PollingTrigger.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTrigger.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tdescription: str,\tinput_schema: List[autohive_integrations_sdk.integration.Parameter],\toutput_schema: Optional[Dict[str, Any]] = None,\tpolling_interval: datetime.timedelta = <factory>)"}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"fullname": "autohive_integrations_sdk.integration.PollingTrigger.polling_interval", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTrigger.polling_interval", "kind": "variable", "doc": "
    \n", "annotation": ": datetime.timedelta"}, "autohive_integrations_sdk.integration.IntegrationConfig": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig", "kind": "class", "doc": "
    Configuration for an integration
    \n"}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tname: str,\tversion: str,\tdescription: str,\tauth: Dict[str, Any],\tactions: Dict[str, autohive_integrations_sdk.integration.Action],\tpolling_triggers: Dict[str, autohive_integrations_sdk.integration.PollingTrigger])"}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.name", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.name", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.version", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.version", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.description", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.description", "kind": "variable", "doc": "
    \n", "annotation": ": str"}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.auth", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.auth", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, Any]"}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.actions", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.actions", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, autohive_integrations_sdk.integration.Action]"}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"fullname": "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers", "modulename": "autohive_integrations_sdk.integration", "qualname": "IntegrationConfig.polling_triggers", "kind": "variable", "doc": "
    \n", "annotation": ": Dict[str, autohive_integrations_sdk.integration.PollingTrigger]"}, "autohive_integrations_sdk.integration.ActionHandler": {"fullname": "autohive_integrations_sdk.integration.ActionHandler", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionHandler", "kind": "class", "doc": "
    Base class for action handlers.
    \n\n
    Subclass this and implement execute() to handle a specific action.\nRegister it with the @integration.action(\"action_name\") decorator.
    \n\n
    Example::
    \n\n
    @integration.action(\"get_user\")\nclass GetUser(ActionHandler):\n    async def execute(self, inputs, context):\n        user = (await context.fetch(f\"https://api.example.com/users/{inputs['id']}\")).data\n        return ActionResult(data=user)\n
    \n", "bases": "abc.ABC"}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"fullname": "autohive_integrations_sdk.integration.ActionHandler.execute", "modulename": "autohive_integrations_sdk.integration", "qualname": "ActionHandler.execute", "kind": "function", "doc": "
    Run the action logic.
    \n\n
    Args:\n    inputs: Validated action inputs matching the input_schema from config.json.\n    context: Execution context providing fetch(), auth, and logging.
    \n\n
    Returns:\n    An ActionResult containing the output data and optional cost_usd.
    \n", "signature": "(\tself,\tinputs: Dict[str, Any],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> Any:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"fullname": "autohive_integrations_sdk.integration.PollingTriggerHandler", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTriggerHandler", "kind": "class", "doc": "
    Base class for polling trigger handlers
    \n", "bases": "abc.ABC"}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"fullname": "autohive_integrations_sdk.integration.PollingTriggerHandler.poll", "modulename": "autohive_integrations_sdk.integration", "qualname": "PollingTriggerHandler.poll", "kind": "function", "doc": "
    Execute the polling trigger
    \n", "signature": "(\tself,\tinputs: Dict[str, Any],\tlast_poll_ts: Optional[str],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> List[Dict[str, Any]]:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountHandler", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountHandler", "kind": "class", "doc": "
    Base class for connected-account handlers.
    \n\n
    The platform calls this after a user links their external account.\nThe returned ConnectedAccountInfo is shown in the Autohive UI.
    \n\n
    Register with the @integration.connected_account() decorator.
    \n\n
    Example::
    \n\n
    @integration.connected_account()\nclass MyAccountHandler(ConnectedAccountHandler):\n    async def get_account_info(self, context):\n        me = (await context.fetch(\"https://api.example.com/me\")).data\n        return ConnectedAccountInfo(\n            email=me[\"email\"],\n            first_name=me[\"first_name\"],\n            last_name=me[\"last_name\"],\n        )\n
    \n", "bases": "abc.ABC"}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"fullname": "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info", "modulename": "autohive_integrations_sdk.integration", "qualname": "ConnectedAccountHandler.get_account_info", "kind": "function", "doc": "
    Fetch account metadata from the external service.
    \n\n
    For platform OAuth integrations, context.fetch() auto-injects\nthe Bearer token \u2014 no manual auth handling needed.
    \n\n
    Returns:\n    A ConnectedAccountInfo with whichever fields the API provides.
    \n", "signature": "(\tself,\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> autohive_integrations_sdk.integration.ConnectedAccountInfo:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.ExecutionContext": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext", "kind": "class", "doc": "
    Context provided to integration handlers for making authenticated HTTP requests.
    \n\n
    Manages an aiohttp session with automatic retries, error handling, and\noptional Bearer-token injection for platform OAuth integrations.
    \n\n
    Use as an async context manager::
    \n\n
    async with ExecutionContext(auth=auth) as context:\n    result = await integration.execute_action(\"my_action\", inputs, context)\n
    \n\n
    Args:\n    auth: Authentication data.  In local tests this is a flat dict\n        matching the auth.fields schema in config.json\n        (e.g. {\"api_key\": \"...\"}).  In production the platform\n        wraps credentials as {\"auth_type\": \"...\", \"credentials\": {...}}.\n    request_config: Override default max_retries (3) and timeout (30 s).\n    metadata: Arbitrary metadata forwarded to handlers.\n    logger: Custom logger; falls back to logging.getLogger(__name__).
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.__init__", "kind": "function", "doc": "
    \n", "signature": "(\tauth: Dict[str, Any] = {},\trequest_config: Optional[Dict[str, Any]] = None,\tmetadata: Optional[Dict[str, Any]] = None,\tlogger: Optional[logging.Logger] = None)"}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.auth", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.auth", "kind": "variable", "doc": "
    Authentication configuration
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.config", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.config", "kind": "variable", "doc": "
    Request configuration
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.metadata", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.metadata", "kind": "variable", "doc": "
    Additional metadata
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.logger", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.logger", "kind": "variable", "doc": "
    Logger instance
    \n"}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"fullname": "autohive_integrations_sdk.integration.ExecutionContext.fetch", "modulename": "autohive_integrations_sdk.integration", "qualname": "ExecutionContext.fetch", "kind": "function", "doc": "
    Make an HTTP request with automatic retries and error handling.
    \n\n
    For platform OAuth integrations (auth_type == \"PlatformOauth2\"),\na Bearer token is auto-injected from auth.credentials.access_token\nunless an Authorization header is explicitly provided.
    \n\n
    Retries up to max_retries (default 3) on transient network errors\nwith exponential back-off.  HTTP 429 responses raise RateLimitError\nimmediately (no automatic retry).
    \n\n
    Args:\n    url: The URL to request.\n    method: HTTP method (\"GET\", \"POST\", \"PUT\", etc.).\n    params: Query parameters appended to the URL.  Nested dicts/lists\n        are JSON-serialized automatically.\n    data: Raw request body.  Encoding depends on content_type.\n    json: JSON-serializable payload.  Sets content_type to\n        application/json automatically.\n    headers: Additional HTTP headers.  Merged after any auto-injected\n        auth header, so an explicit Authorization takes precedence.\n    content_type: Content-Type header value.\n    timeout: Per-request timeout in seconds (overrides request_config).\n    retry_count: Internal \u2014 current retry attempt number.
    \n\n
    Returns:\n    A FetchResponse containing the HTTP status code, response\n    headers, and parsed body data.
    \n\n
    Raises:\n    RateLimitError: On HTTP 429 with the Retry-After value.\n    HTTPError: On any other non-2xx status.
    \n", "signature": "(\tself,\turl: str,\tmethod: str = 'GET',\tparams: Optional[Dict[str, Any]] = None,\tdata: Any = None,\tjson: Any = None,\theaders: Optional[Dict[str, str]] = None,\tcontent_type: Optional[str] = None,\ttimeout: Optional[int] = None,\tretry_count: int = 0) -> autohive_integrations_sdk.integration.FetchResponse:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.Integration": {"fullname": "autohive_integrations_sdk.integration.Integration", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration", "kind": "class", "doc": "
    Base integration class with handler registration and execution.
    \n\n
    This class manages the integration configuration, handler registration,\nand provides methods to execute actions and triggers.
    \n\n
    Args:\n    config: Integration configuration
    \n\n
    Attributes:\n    config: Integration configuration
    \n"}, "autohive_integrations_sdk.integration.Integration.__init__": {"fullname": "autohive_integrations_sdk.integration.Integration.__init__", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.__init__", "kind": "function", "doc": "
    \n", "signature": "(config: autohive_integrations_sdk.integration.IntegrationConfig)"}, "autohive_integrations_sdk.integration.Integration.config": {"fullname": "autohive_integrations_sdk.integration.Integration.config", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.config", "kind": "variable", "doc": "
    Integration configuration
    \n"}, "autohive_integrations_sdk.integration.Integration.load": {"fullname": "autohive_integrations_sdk.integration.Integration.load", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.load", "kind": "function", "doc": "
    Load an integration from its config.json.
    \n\n
    Args:\n    config_path: Explicit path to config.json.  When omitted the\n        SDK resolves the path relative to its own package location,\n        which works when the SDK is vendored via\n        pip install --target dependencies.  Multi-file integrations\n        that use actions/ sub-packages should pass an explicit path\n        (e.g. Integration.load(\"config.json\")).
    \n\n
    Returns:\n    A fully initialised Integration ready for handler registration.
    \n\n
    Raises:\n    ConfigurationError: If the file is missing or contains invalid JSON.
    \n", "signature": "(\tcls,\tconfig_path: Union[str, pathlib._local.Path] = None) -> autohive_integrations_sdk.integration.Integration:", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.action": {"fullname": "autohive_integrations_sdk.integration.Integration.action", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.action", "kind": "function", "doc": "
    Decorator to register an action handler.
    \n\n
    Args:\n    name: Name of the action to register
    \n\n
    Returns:\n    Decorator function
    \n\n
    Raises:\n    ConfigurationError: If action is not defined in config
    \n\n
    Example:
    \n\n
    \n
    @integration.action("my_action")\nclass MyActionHandler(ActionHandler):\n    async def execute(self, inputs, context):\n        # Implementation\n        return result\n
    \n
    \n
    \n", "signature": "(self, name: str):", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"fullname": "autohive_integrations_sdk.integration.Integration.polling_trigger", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.polling_trigger", "kind": "function", "doc": "
    Decorator to register a polling trigger handler
    \n\n
    Args:\n    name: Name of the polling trigger to register
    \n\n
    Returns:\n    Decorator function
    \n\n
    Raises:\n    ConfigurationError: If polling trigger is not defined in config
    \n\n
    Example:
    \n\n
    \n
    @integration.polling_trigger("my_polling_trigger")\nclass MyPollingTriggerHandler(PollingTriggerHandler):\n    async def poll(self, inputs, last_poll_ts, context):\n        # Implementation\n        return result\n
    \n
    \n
    \n", "signature": "(self, name: str):", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.connected_account": {"fullname": "autohive_integrations_sdk.integration.Integration.connected_account", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.connected_account", "kind": "function", "doc": "
    Decorator to register a connected account handler
    \n\n
    Returns:\n    Decorator function
    \n\n
    Example:
    \n\n
    \n
    @integration.connected_account()\nclass MyConnectedAccountHandler(ConnectedAccountHandler):\n    async def get_account_info(self, context):\n        # Implementation\n        return {"email": "user@example.com", "name": "John Doe"}\n
    \n
    \n
    \n", "signature": "(self):", "funcdef": "def"}, "autohive_integrations_sdk.integration.Integration.execute_action": {"fullname": "autohive_integrations_sdk.integration.Integration.execute_action", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.execute_action", "kind": "function", "doc": "
    Execute a registered action.
    \n\n
    Args:\n    name: Name of the action to execute\n    inputs: Action inputs\n    context: Execution context
    \n\n
    Returns:\n    IntegrationResult with action data (ResultType.ACTION),\n    action error (ResultType.ACTION_ERROR) if the handler returned ActionError,\n    or validation error (ResultType.VALIDATION_ERROR) if schema validation fails.
    \n", "signature": "(\tself,\tname: str,\tinputs: Dict[str, Any],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> autohive_integrations_sdk.integration.IntegrationResult:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"fullname": "autohive_integrations_sdk.integration.Integration.execute_polling_trigger", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.execute_polling_trigger", "kind": "function", "doc": "
    Execute a registered polling trigger
    \n\n
    Args:\n    name: Name of the polling trigger to execute\n    inputs: Trigger inputs\n    last_poll_ts: Last poll timestamp\n    context: Execution context
    \n\n
    Returns:\n    List of records
    \n\n
    Raises:\n    ValidationError: If inputs or outputs don't match schema
    \n", "signature": "(\tself,\tname: str,\tinputs: Dict[str, Any],\tlast_poll_ts: Optional[str],\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> List[Dict[str, Any]]:", "funcdef": "async def"}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"fullname": "autohive_integrations_sdk.integration.Integration.get_connected_account", "modulename": "autohive_integrations_sdk.integration", "qualname": "Integration.get_connected_account", "kind": "function", "doc": "
    Get connected account information
    \n\n
    Args:\n    context: Execution context
    \n\n
    Returns:\n    IntegrationResult containing connected account data
    \n\n
    Raises:\n    ValidationError: If no connected account handler is registered or auth is invalid
    \n", "signature": "(\tself,\tcontext: autohive_integrations_sdk.integration.ExecutionContext) -> autohive_integrations_sdk.integration.IntegrationResult:", "funcdef": "async def"}}, "docInfo": {"autohive_integrations_sdk": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 229}, "autohive_integrations_sdk.integration.AuthType": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 123}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.Basic": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.AuthType.Custom": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 7}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ValidationError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 80}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ValidationError.schema": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 7}, "autohive_integrations_sdk.integration.ValidationError.message": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 5}, "autohive_integrations_sdk.integration.ValidationError.source": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 14}, "autohive_integrations_sdk.integration.ConfigurationError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 8}, "autohive_integrations_sdk.integration.HTTPError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 17}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 42, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.HTTPError.status": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.HTTPError.message": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.RateLimitError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 41}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 8}, "autohive_integrations_sdk.integration.FetchResponse": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 86}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.FetchResponse.status": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"qualname": 2, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.FetchResponse.data": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionResult": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 130}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionResult.data": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionError": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 117}, "autohive_integrations_sdk.integration.ActionError.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 38, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionError.message": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 56}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 176, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"qualname": 3, "fullname": 7, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 114}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 103, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"qualname": 2, "fullname": 6, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"qualname": 2, "fullname": 6, "annotation": 16, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "autohive_integrations_sdk.integration.Parameter.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 101, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.name": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.type": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.description": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.enum": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.required": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Parameter.default": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 10}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"qualname": 3, "fullname": 7, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"qualname": 3, "fullname": 7, "annotation": 3, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Action": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 8}, "autohive_integrations_sdk.integration.Action.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 91, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.PollingTrigger": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 7}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 123, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"qualname": 3, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 6}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 131, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"qualname": 2, "fullname": 6, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"qualname": 2, "fullname": 6, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"qualname": 3, "fullname": 7, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ActionHandler": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 74}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 57}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 8}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 96, "bases": 0, "doc": 6}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 96}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 50, "bases": 0, "doc": 47}, "autohive_integrations_sdk.integration.ExecutionContext": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 155}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 132, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 232, "bases": 0, "doc": 238}, "autohive_integrations_sdk.integration.Integration": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 42}, "autohive_integrations_sdk.integration.Integration.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 26, "bases": 0, "doc": 3}, "autohive_integrations_sdk.integration.Integration.config": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 4}, "autohive_integrations_sdk.integration.Integration.load": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 69, "bases": 0, "doc": 104}, "autohive_integrations_sdk.integration.Integration.action": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 132}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 144}, "autohive_integrations_sdk.integration.Integration.connected_account": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 136}, "autohive_integrations_sdk.integration.Integration.execute_action": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 84, "bases": 0, "doc": 53}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 107, "bases": 0, "doc": 48}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"qualname": 4, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 50, "bases": 0, "doc": 35}}, "length": 106, "save": true}, "index": {"qualname": {"root": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}}, "df": 1}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 2}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 4}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 8}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 3, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 9}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}}, "df": 2}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 10, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 5}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 8}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 3, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}}, "df": 2}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}}, "df": 3}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}}, "df": 5}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}, "fullname": {"root": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk": {"tf": 1}, "autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 106}}}}}, "h": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 6, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}}, "df": 1}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 2}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 4}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 105, "s": {"docs": {"autohive_integrations_sdk": {"tf": 1}, "autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 106}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 5}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 8}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 15}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk": {"tf": 1}, "autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 106}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 3, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 8}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 3, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 9}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}}, "df": 2, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 6}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}}, "df": 2}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}}, "df": 3}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}}, "df": 5}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}, "annotation": {"root": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 34, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 5}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 4}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1}}, "df": 11}}, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 5}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1}}, "df": 5}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 4}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}}, "df": 7}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1}}, "df": 1}}}}}}}}}}}, "default_value": {"root": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 10, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 10}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}}, "df": 5}}}}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}, "x": {"2": {"7": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 10}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "g": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 10}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1}}, "df": 5}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1}}, "df": 12}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Parameter.required": {"tf": 1}}, "df": 1}}}}}}, "signature": {"root": {"0": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}, "3": {"9": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}, "docs": {}, "df": 0}, "docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 7.745966692414834}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 5.830951894845301}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 4.898979485566356}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 6.164414002968976}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 5.5677643628300215}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 5.5677643628300215}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 12}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 8.831760866327848}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 9.16515138991168}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 8.48528137423857}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 8.48528137423857}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 9.848857801796104}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 10.198039027185569}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 7}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 8.717797887081348}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 6.164414002968976}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 10.488088481701515}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 13.711309200802088}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 4.47213595499958}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 7.416198487095663}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 4.242640687119285}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 4.242640687119285}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 3.1622776601683795}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 8.12403840463596}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 9.219544457292887}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 6.164414002968976}}, "df": 26, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 3}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 2.6457513110645907}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 2}}, "df": 20}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1.4142135623730951}}, "df": 4}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 10}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 2.6457513110645907}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 12}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 10}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 5}}}}, "t": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 6}}}, "t": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.4142135623730951}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 11}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 5}}}}}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 14}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}}, "df": 1}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 2}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 14}}}}}, "h": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 2.6457513110645907}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 11}}}}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 3}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 2}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 3}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 1, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1.4142135623730951}}, "df": 2}}}, "x": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}}, "df": 3}}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}}, "df": 3}}}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "doc": {"root": {"0": {"1": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}, "5": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}, "docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 3}, "2": {"0": {"0": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1, "/": {"2": {"0": {"1": {"docs": {}, "df": 0, "/": {"2": {"0": {"4": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "1": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "x": {"docs": {}, "df": 0, "x": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}, "3": {"0": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}, "docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "4": {"2": {"9": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 3}, "docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "6": {"0": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {"autohive_integrations_sdk": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration": {"tf": 9.433981132056603}, "autohive_integrations_sdk.integration.AuthType": {"tf": 4.898979485566356}, "autohive_integrations_sdk.integration.AuthType.PlatformOauth2": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.PlatformTeams": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.ApiKey": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.Basic": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType.Custom": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType.ACTION": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.ACTION_ERROR": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.CONNECTED_ACCOUNT": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.ERROR": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ResultType.VALIDATION_ERROR": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 5.385164807134504}, "autohive_integrations_sdk.integration.ValidationError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.HTTPError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 3.3166247903554}, "autohive_integrations_sdk.integration.RateLimitError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 5}, "autohive_integrations_sdk.integration.FetchResponse.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse.status": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse.headers": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.FetchResponse.data": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 8.54400374531753}, "autohive_integrations_sdk.integration.ActionResult.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult.data": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult.cost_usd": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 7.3484692283495345}, "autohive_integrations_sdk.integration.ActionError.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError.message": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError.cost_usd": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 3.4641016151377544}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.email": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.first_name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.last_name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.username": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.user_id": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.avatar_url": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo.organization": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 3.4641016151377544}, "autohive_integrations_sdk.integration.IntegrationResult.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult.version": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult.type": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult.result": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Parameter.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.type": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.description": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.enum": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.required": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Parameter.default": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.SchemaDefinition.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.description": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.input_schema": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.SchemaDefinition.output_schema": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Action.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTrigger.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTrigger.polling_interval": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationConfig.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.name": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.version": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.description": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.auth": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.actions": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationConfig.polling_triggers": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 4.69041575982343}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 4.69041575982343}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 5.0990195135927845}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 3.872983346207417}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 6.708203932499369}, "autohive_integrations_sdk.integration.ExecutionContext.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 8}, "autohive_integrations_sdk.integration.Integration": {"tf": 3.1622776601683795}, "autohive_integrations_sdk.integration.Integration.__init__": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 5}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 9.327379053088816}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 9.539392014169456}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 9.797958971132712}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 2.8284271247461903}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 2.8284271247461903}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 2.8284271247461903}}, "df": 106, "a": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 17, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 4}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "h": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 7, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}}, "df": 3}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}}}, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}}, "df": 10, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.7320508075688772}}, "df": 10}, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 2.6457513110645907}}, "df": 10, "/": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 6}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 4}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3}}}}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.7320508075688772}}, "df": 7, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 2, "/": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 4, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.7320508075688772}}, "df": 3, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 7}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 3}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4}}}}, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 13}}, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 8, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 14, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.7320508075688772}}, "df": 9}, "/": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}}}}}}}}}}, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 13, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}, "f": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 7}, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 1}}, "d": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2, "d": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 4}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 9, "s": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 6}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 10, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.auth": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.config": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.7320508075688772}}, "df": 6, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 4}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1.4142135623730951}}, "df": 13}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3}}}, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 2}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 4}}, "m": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "{": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.HTTPError.status": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 11}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}}}, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "y": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.action": {"tf": 1}}, "df": 1}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2}}, "df": 1, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}}, "df": 4}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.metadata": {"tf": 1}}, "df": 4}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 2}, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "x": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 4}, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 2}}, "df": 1}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 2}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 6, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"2": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 5, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2, "h": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 2.8284271247461903}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 2}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 2}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 26, "i": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 7}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}}, "df": 1}, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 6}}}, "o": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 17, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 4}}}, "o": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.23606797749979}}, "df": 6}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.7320508075688772}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}}, "df": 6}, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "y": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}}, "df": 9, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 3}}}}}}, "f": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationConfig": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 16, "m": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}}, "df": 1}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1.4142135623730951}}, "df": 9, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 11}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 5}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 3}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1, "y": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 2}}, "o": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.logger": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 3}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 3}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 4}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 2}}}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 8, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 9}}, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 11}}}}, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}}, "df": 2, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.7320508075688772}}, "df": 3}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.config": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.23606797749979}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 5}, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}}}}, "w": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}, "u": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 11, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTriggerHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}}, "df": 8}}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.SchemaDefinition": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2.449489742783178}}, "df": 7, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}}}, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 3}}}}}}}}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 3}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3, "x": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 5, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 6}}}}}}}}}}, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.PollingTriggerHandler.poll": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 8}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 2, "/": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 2, "l": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.HTTPError": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 8}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 3}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError.message": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.message": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 2.23606797749979}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 2}}, "df": 7, "s": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 3}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1}}, "df": 1}}}}}}}}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "c": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2}}}, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 2}}, "df": 1}}}, "s": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}}, "df": 9}}}, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConfigurationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1.4142135623730951}}, "df": 5}, "r": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 2}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.RateLimitError.retry_after": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 5, "s": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 6}}}}}}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 4}}}}, "f": {"docs": {"autohive_integrations_sdk.integration.ResultType": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 8, "f": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 2, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}}}}}}}, "r": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 6}, "n": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 2}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}}, "df": 1}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration": {"tf": 2}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError.response_data": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionResult": {"tf": 2}, "autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 13, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Action": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 3}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Parameter": {"tf": 1}, "autohive_integrations_sdk.integration.PollingTrigger": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3, "s": {"docs": {"autohive_integrations_sdk.integration.RateLimitError": {"tf": 1}}, "df": 1}}}}}}, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1.4142135623730951}}, "df": 5}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}}, "df": 2}, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2, "s": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1, "/": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}}, "df": 1}}}}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.schema": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.inputs": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.7320508075688772}}, "df": 7, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 2}}}}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1.7320508075688772}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.ValidationError.source": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {"autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 3, "n": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}, "autohive_integrations_sdk.integration.HTTPError": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 3, "e": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}}, "df": 1}}, "t": {"docs": {"autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1}}, "df": 3, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 2}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.execute_action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.execute_polling_trigger": {"tf": 1.4142135623730951}}, "df": 10}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountHandler.get_account_info": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "s": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "r": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 5, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "@": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}}}}}}}}}, "d": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}}, "df": 3}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"autohive_integrations_sdk.integration.IntegrationResult": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {"autohive_integrations_sdk.integration.ConnectedAccountInfo": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}, "p": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "l": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}}, "df": 1}}}, "g": {"docs": {"autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 1}}, "df": 3, "t": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ConnectedAccountHandler": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}, "autohive_integrations_sdk.integration.Integration.get_connected_account": {"tf": 1}}, "df": 5, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ActionHandler": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 1}}}}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}}, "df": 2}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.AuthType": {"tf": 1}, "autohive_integrations_sdk.integration.ValidationError": {"tf": 1}, "autohive_integrations_sdk.integration.FetchResponse": {"tf": 1}, "autohive_integrations_sdk.integration.ActionHandler.execute": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext": {"tf": 1}, "autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1.7320508075688772}, "autohive_integrations_sdk.integration.Integration.load": {"tf": 2}}, "df": 7}}}, "o": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "n": {"docs": {"autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"autohive_integrations_sdk.integration.ActionResult": {"tf": 2.449489742783178}, "autohive_integrations_sdk.integration.ActionError": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.action": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.polling_trigger": {"tf": 1.4142135623730951}, "autohive_integrations_sdk.integration.Integration.connected_account": {"tf": 2.8284271247461903}}, "df": 5}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"autohive_integrations_sdk.integration.ExecutionContext.fetch": {"tf": 1}}, "df": 1}}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true};
 
     // mirrored in build-search-index.js (part 1)
     // Also split on html tags. this is a cheap heuristic, but good enough.
diff --git a/pyproject.toml b/pyproject.toml
index 3b47121..72cdf9c 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,9 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "autohive_integrations_sdk"
-version = "1.1.1"
+version = "2.0.0"
 authors = [
-  { name="Hamish Taylor", email="hamish@autohive.com" },
   { name="Reilly Oldham", email="reilly@autohive.com" },
   { name="Kai Koenig", email="kai@autohive.com" },
   { name="Ninos Awas", email="ninos@raygun.com" }
diff --git a/src/autohive_integrations_sdk/__init__.py b/src/autohive_integrations_sdk/__init__.py
index d654d80..f27fadd 100644
--- a/src/autohive_integrations_sdk/__init__.py
+++ b/src/autohive_integrations_sdk/__init__.py
@@ -1,5 +1,5 @@
 # Version
-__version__ = "1.1.1"
+__version__ = "2.0.0"
 
 # Re-export classes from integration module
 from autohive_integrations_sdk.integration import (
diff --git a/tests/test_integration.py b/tests/test_integration.py
index 89342a5..e1f003a 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -550,3 +550,39 @@ async def execute(self, inputs, context):
             return ActionResult(data={"greeting": "second"})
 
     assert integration._action_handlers["test_action"] is Second
+
+
+# ── Abstract base class pass-through ───────────────────────────────────────
+
+
+async def test_action_handler_abstract_execute_returns_none():
+    """super().execute() on the ABC body executes the `pass` and returns None."""
+
+    class Concrete(ActionHandler):
+        async def execute(self, inputs, context):
+            return await super().execute(inputs, context)
+
+    result = await Concrete().execute({}, None)
+    assert result is None
+
+
+async def test_polling_trigger_handler_abstract_poll_returns_none():
+    """super().poll() on the ABC body executes the `pass` and returns None."""
+
+    class Concrete(PollingTriggerHandler):
+        async def poll(self, inputs, last_poll_ts, context):
+            return await super().poll(inputs, last_poll_ts, context)
+
+    result = await Concrete().poll({}, None, None)
+    assert result is None
+
+
+async def test_connected_account_handler_abstract_get_account_info_returns_none():
+    """super().get_account_info() on the ABC body executes the `pass` and returns None."""
+
+    class Concrete(ConnectedAccountHandler):
+        async def get_account_info(self, context):
+            return await super().get_account_info(context)
+
+    result = await Concrete().get_account_info(None)
+    assert result is None