hypeline 0.1.1__tar.gz

hypeline-0.1.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: hypeline
+Version: 0.1.1
+Summary: Official Hypeline SDK: turn any source into a unified, deduplicated live stream of change events. Watches, change history, SSE with gap-free resume, and Standard Webhooks signature verification.
+License: MIT
+Keywords: hypeline,monitoring,webhooks,sse,change-detection,agents
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3<3.0.0,>=1.25.3
+Requires-Dist: python_dateutil>=2.8.2
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.7.1
+Requires-Dist: standardwebhooks>=1.0.0
+
+# hypeline
+
+Official Python SDK for Hypeline. Create watches on any source URL, poll change
+history, subscribe to the live event stream over SSE (gap-free resume), and verify
+signed webhooks.
+
+```python
+from hypeline import Hypeline
+
+hy = Hypeline(api_key="...")
+watch = hy.create_watch("https://example.com/blog", keywords=["incident"])
+for change in hy.get_changes_since(watch.cursor).events:
+    print(change.content)
+
+for ev in hy.stream(keyword="incident"):
+    print(ev.emitted_at, ev.content)
+```
+
+See `sdk/README.md` for the shared regen/drift workflow.

hypeline-0.1.1/README.md

@@ -0,0 +1,19 @@
+# hypeline
+
+Official Python SDK for Hypeline. Create watches on any source URL, poll change
+history, subscribe to the live event stream over SSE (gap-free resume), and verify
+signed webhooks.
+
+```python
+from hypeline import Hypeline
+
+hy = Hypeline(api_key="...")
+watch = hy.create_watch("https://example.com/blog", keywords=["incident"])
+for change in hy.get_changes_since(watch.cursor).events:
+    print(change.content)
+
+for ev in hy.stream(keyword="incident"):
+    print(ev.emitted_at, ev.content)
+```
+
+See `sdk/README.md` for the shared regen/drift workflow.

hypeline-0.1.1/hypeline/__init__.py

@@ -0,0 +1,190 @@
+"""hypeline: the official Python SDK.
+
+Wraps the generated core (``hypeline_core``, openapi-generator) and re-exposes exactly
+the marketed snake_case surface:
+    create_watch, list_watches, delete_watch, get_changes_since, stream, verify_signature
+
+The event model mirrors the REST/SSE wire (``content`` + ``emitted_at``, ``simhash`` a
+string), NOT the MCP projection (``summary``/``occurred_at``).
+"""
+from __future__ import annotations
+
+import random
+import time
+from dataclasses import dataclass
+from typing import Any, Iterator, List, Optional
+
+from hypeline_core.api.history_api import HistoryApi
+from hypeline_core.api.sources_api import SourcesApi
+from hypeline_core.api_client import ApiClient
+from hypeline_core.configuration import Configuration
+from hypeline_core.models.create_source_request import CreateSourceRequest
+from hypeline_core.models.history_page import HistoryPage
+from hypeline_core.models.source_dto import SourceDTO
+from hypeline_core.models.stream_event import StreamEvent
+
+from .stream import CursorExpired, stream_events
+from .webhook import verify_signature
+
+__all__ = [
+    "Hypeline",
+    "Watch",
+    "StreamEvent",
+    "SourceDTO",
+    "HistoryPage",
+    "CursorExpired",
+    "verify_signature",
+]
+
+DEFAULT_BASE_URL = "https://api.hypeline.io"
+
+
+@dataclass
+class Watch:
+    """A created watch: the source id plus a head cursor to poll get_changes_since from."""
+
+    id: str
+    cursor: str
+    source: SourceDTO
+
+
+class Hypeline:
+    """The idiomatic Hypeline client."""
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        access_token: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._access_token = access_token
+        config = Configuration(host=self._base_url)
+        if api_key:
+            # Auth scheme name from the overlay: ApiKeyAuth -> header X-API-Key.
+            config.api_key = {"ApiKeyAuth": api_key}
+        if access_token:
+            config.access_token = access_token
+        self._client = ApiClient(config)
+        self._sources = SourcesApi(self._client)
+        self._history = HistoryApi(self._client)
+
+    # --- watches ---------------------------------------------------------------
+
+    def create_watch(
+        self,
+        url: str,
+        keywords: Optional[List[str]] = None,
+        type: Optional[str] = None,
+    ) -> Watch:
+        """Create a watch on a source URL. ``keywords`` are stored as source ``tags``.
+
+        Returns the watch id plus a head cursor (the current newest event id) so the
+        first ``get_changes_since(cursor)`` receives only changes after creation.
+        """
+        req = CreateSourceRequest(
+            url=url,
+            tags=keywords if keywords else None,
+            type=type,
+        )
+        source = self._sources.create_source(create_source_request=req)
+        return Watch(id=source.id, cursor=self._head_cursor(), source=source)
+
+    def list_watches(self) -> List[SourceDTO]:
+        """List all watches (sources) for the authenticated key."""
+        return self._sources.list_sources()
+
+    def delete_watch(self, watch_id: str) -> None:
+        """Delete a watch by id."""
+        self._sources.delete_source(id=watch_id)
+
+    # --- changes ---------------------------------------------------------------
+
+    def get_changes_since(
+        self,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = None,
+        source: Optional[Any] = None,
+        keyword: Optional[Any] = None,
+    ) -> HistoryPage:
+        """Fetch changes strictly after ``cursor`` (oldest-first).
+
+        Returns a ``HistoryPage`` whose ``.events`` are typed ``StreamEvent`` objects and
+        whose ``.next_cursor`` pages the next call (``None`` once caught up).
+        """
+        return self._history.query_events(
+            var_from=cursor,
+            order="asc",
+            limit=limit,
+            source=_as_list(source),
+            keyword=_as_list(keyword),
+        )
+
+    # --- live stream -----------------------------------------------------------
+
+    def stream(
+        self,
+        keyword: Optional[str] = None,
+        source: Optional[Any] = None,
+        source_type: Optional[str] = None,
+        tag: Optional[Any] = None,
+        since: Optional[str] = None,
+    ) -> Iterator[StreamEvent]:
+        """Subscribe to the live stream (SSE), resuming gap-free on disconnect.
+
+        The filter is a SINGULAR ``keyword`` string (mapped to ``?keyword=``); there is
+        no plural ``keywords`` list here (that belongs to ``create_watch`` -> ``tags``).
+        A 410 raises :class:`CursorExpired`.
+        """
+        return stream_events(
+            self._base_url,
+            api_key=self._api_key,
+            access_token=self._access_token,
+            keyword=keyword,
+            source=source,
+            source_type=source_type,
+            tag=tag,
+            since=since,
+        )
+
+    # --- webhooks --------------------------------------------------------------
+
+    def verify_signature(self, secret: str, headers: dict, body: Any) -> Any:
+        """Verify a signed webhook delivery (see :func:`hypeline.verify_signature`)."""
+        return verify_signature(secret, headers, body)
+
+    # --- internals -------------------------------------------------------------
+
+    def _head_cursor(self) -> str:
+        """Current head event id (mirrors MCP headCursor: GET /v1/events?order=desc&limit=1).
+
+        On an empty log or any failure, synthesize a time-ordered cursor so polling still
+        starts from the present.
+        """
+        try:
+            page = self._history.query_events(order="desc", limit=1)
+            events = page.events or []
+            if events and events[0].id:
+                return events[0].id
+        except Exception:  # noqa: BLE001
+            pass
+        return _synthesize_cursor()
+
+
+def _as_list(val: Any) -> Optional[List[str]]:
+    if val is None:
+        return None
+    return list(val) if isinstance(val, (list, tuple)) else [val]
+
+
+def _synthesize_cursor() -> str:
+    """A UUIDv7-ish time-ordered id used as a 'now' cursor fallback."""
+    ms = int(time.time() * 1000)
+    time_hex = f"{ms:012x}"
+    rand = f"{random.getrandbits(64):016x}"
+    var = random.choice("89ab")
+    return (
+        f"{time_hex[:8]}-{time_hex[8:12]}-7{rand[:3]}-"
+        f"{var}{rand[3:6]}-{rand[6:16]}{rand[:2]}"
+    )

hypeline-0.1.1/hypeline/stream.py

@@ -0,0 +1,192 @@
+"""Hand-written Server-Sent Events resume shim over GET /v1/stream.
+
+The generated core (openapi-generator python) models /v1/stream as a one-shot JSON
+response, so it cannot iterate SSE frames. This shim owns the SSE wire directly
+(matching internal/api/stream.go):
+
+  - frames: ``id: <uuidv7>`` (the resume cursor), ``event: <source_type>``, ``data: <json>``
+  - ``: keepalive`` comment frames are heartbeats and are skipped (never yielded)
+  - reconnect on disconnect sends the ``Last-Event-ID`` header and resumes gap-free
+  - a server ``retry:`` hint sets the reconnect backoff
+  - HTTP 410 Gone (a resume cursor past the retained window) raises ``CursorExpired``
+
+The stream filter is a SINGULAR ``keyword`` string (mapped to ``?keyword=``), matching
+the marketed ``/learn`` copy; the PLURAL ``keywords`` list belongs only to
+``create_watch`` (mapped to source ``tags``).
+"""
+from __future__ import annotations
+
+import json
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Iterator, List, Optional
+from urllib.parse import urlencode, urljoin
+
+from hypeline_core.models.stream_event import StreamEvent
+
+
+class CursorExpired(Exception):
+    """Raised when a resume cursor predates the retained backfill window (HTTP 410)."""
+
+    status = 410
+
+    def __init__(self, message: Optional[str] = None) -> None:
+        super().__init__(
+            message
+            or "stream cursor expired: the Last-Event-ID predates the retained window; "
+            "reconnect without it to resume from the live tail"
+        )
+
+
+# A minimal opener signature: (url, headers) -> a file-like response with .read()/
+# .readline() and a .status/.getcode(). Defaults to urllib.request.urlopen; injectable
+# for tests that want to avoid a real socket (the suite uses a real localhost server).
+Opener = Callable[[urllib.request.Request], Any]
+
+
+def _build_url(
+    base_url: str,
+    source: Optional[Any],
+    source_type: Optional[str],
+    tag: Optional[Any],
+    keyword: Optional[str],
+    since: Optional[str],
+) -> str:
+    params: List[tuple] = []
+
+    def add(key: str, val: Any) -> None:
+        if val is None:
+            return
+        for v in val if isinstance(val, (list, tuple)) else [val]:
+            if v != "":
+                params.append((key, v))
+
+    add("source", source)
+    add("source_type", source_type)
+    add("tag", tag)
+    add("keyword", keyword)  # SINGULAR; never a plural keywords list
+    add("since", since)
+    base = base_url if base_url.endswith("/") else base_url + "/"
+    url = urljoin(base, "v1/stream")
+    if params:
+        url = url + "?" + urlencode(params)
+    return url
+
+
+def _parse_frame(raw: str):
+    """Parse a single SSE frame; returns (event_id, data_str, retry_ms, is_comment)."""
+    data_lines: List[str] = []
+    event_id: Optional[str] = None
+    retry_ms: Optional[int] = None
+    is_comment = False
+    for line in raw.split("\n"):
+        if line == "":
+            continue
+        if line.startswith(":"):
+            is_comment = True
+            continue
+        idx = line.find(":")
+        field = line if idx == -1 else line[:idx]
+        value = "" if idx == -1 else line[idx + 1 :]
+        if value.startswith(" "):
+            value = value[1:]
+        if field == "id":
+            event_id = value
+        elif field == "data":
+            data_lines.append(value)
+        elif field == "retry":
+            try:
+                retry_ms = int(value)
+            except ValueError:
+                pass
+    return event_id, "\n".join(data_lines), retry_ms, is_comment
+
+
+def stream_events(
+    base_url: str,
+    api_key: Optional[str] = None,
+    access_token: Optional[str] = None,
+    *,
+    source: Optional[Any] = None,
+    source_type: Optional[str] = None,
+    tag: Optional[Any] = None,
+    keyword: Optional[str] = None,
+    since: Optional[str] = None,
+    opener: Optional[Opener] = None,
+    reconnect_delay: float = 1.0,
+) -> Iterator[StreamEvent]:
+    """Iterate the live stream, resuming gap-free across disconnects.
+
+    Yields typed ``StreamEvent`` objects. On a mid-stream disconnect it reconnects with
+    the ``Last-Event-ID`` header set to the last seen id, so no event is skipped or
+    repeated. A 410 raises :class:`CursorExpired` (terminal, no reconnect).
+    """
+    do_open: Opener = opener or (lambda req: urllib.request.urlopen(req))
+    url = _build_url(base_url, source, source_type, tag, keyword, since)
+    last_id: Optional[str] = since
+    retry = reconnect_delay
+
+    while True:
+        headers = {"Accept": "text/event-stream"}
+        if api_key:
+            headers["X-API-Key"] = api_key
+        if access_token:
+            headers["Authorization"] = f"Bearer {access_token}"
+        if last_id:
+            headers["Last-Event-ID"] = last_id
+
+        req = urllib.request.Request(url, headers=headers, method="GET")
+        try:
+            resp = do_open(req)
+        except urllib.error.HTTPError as err:
+            if err.code == 410:
+                raise CursorExpired() from None
+            if 400 <= err.code < 500:
+                raise
+            time.sleep(retry)
+            continue
+        except urllib.error.URLError:
+            time.sleep(retry)
+            continue
+
+        frame_lines: List[str] = []
+        disconnected = False
+        try:
+            while True:
+                raw_line = resp.readline()
+                if not raw_line:
+                    disconnected = True
+                    break
+                line = raw_line.decode("utf-8", errors="replace").rstrip("\n").rstrip("\r")
+                if line != "":
+                    frame_lines.append(line)
+                    continue
+                # Blank line: end of frame.
+                if not frame_lines:
+                    continue
+                event_id, data, retry_ms, is_comment = _parse_frame("\n".join(frame_lines))
+                frame_lines = []
+                if retry_ms is not None:
+                    retry = retry_ms / 1000.0
+                if event_id:
+                    last_id = event_id
+                if is_comment or data == "":
+                    continue
+                try:
+                    payload = json.loads(data)
+                except json.JSONDecodeError:
+                    continue
+                yield StreamEvent.from_dict(payload)
+        except (urllib.error.URLError, OSError):
+            disconnected = True
+        finally:
+            try:
+                resp.close()
+            except Exception:  # noqa: BLE001
+                pass
+
+        if disconnected:
+            time.sleep(retry)
+            continue
+        return

hypeline-0.1.1/hypeline/webhook.py

@@ -0,0 +1,43 @@
+"""Webhook signature verification for Hypeline deliveries.
+
+Hypeline signs webhooks with the Standard Webhooks scheme (the same scheme the engine
+implements in internal/delivery/sign.go). We do NOT hand-roll HMAC here:
+``verify_signature`` wraps the official ``standardwebhooks`` library, which strips the
+``whsec_`` prefix, base64-decodes the secret, checks the three ``webhook-*`` headers,
+enforces the 5-minute timestamp freshness window, and constant-time compares the v1
+HMAC-SHA256 signature.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, Union
+
+from standardwebhooks import Webhook
+
+
+def verify_signature(
+    secret: str,
+    headers: Dict[str, str],
+    body: Union[str, bytes],
+) -> Any:
+    """Verify a Hypeline webhook delivery.
+
+    Args:
+        secret: The endpoint's signing secret (the ``whsec_...`` value shown when the
+            webhook was created). Passed through to ``standardwebhooks`` verbatim.
+        headers: The delivery's HTTP headers. Must include ``webhook-id``,
+            ``webhook-timestamp`` and ``webhook-signature`` (header keys are normalized
+            to lower-case before verification).
+        body: The RAW request body (verify BEFORE parsing JSON: any re-serialization
+            changes bytes and breaks the signature).
+
+    Returns:
+        The parsed JSON payload when the signature and timestamp are valid.
+
+    Raises:
+        WebhookVerificationError: When the signature does not match, a required header
+            is missing, or the timestamp is outside the Standard Webhooks tolerance.
+    """
+    normalized = {str(k).lower(): v for k, v in headers.items()}
+    data = body.decode("utf-8") if isinstance(body, (bytes, bytearray)) else body
+    wh = Webhook(secret)
+    return wh.verify(data, normalized)

hypeline-0.1.1/hypeline.egg-info/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: hypeline
+Version: 0.1.1
+Summary: Official Hypeline SDK: turn any source into a unified, deduplicated live stream of change events. Watches, change history, SSE with gap-free resume, and Standard Webhooks signature verification.
+License: MIT
+Keywords: hypeline,monitoring,webhooks,sse,change-detection,agents
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: urllib3<3.0.0,>=1.25.3
+Requires-Dist: python_dateutil>=2.8.2
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.7.1
+Requires-Dist: standardwebhooks>=1.0.0
+
+# hypeline
+
+Official Python SDK for Hypeline. Create watches on any source URL, poll change
+history, subscribe to the live event stream over SSE (gap-free resume), and verify
+signed webhooks.
+
+```python
+from hypeline import Hypeline
+
+hy = Hypeline(api_key="...")
+watch = hy.create_watch("https://example.com/blog", keywords=["incident"])
+for change in hy.get_changes_since(watch.cursor).events:
+    print(change.content)
+
+for ev in hy.stream(keyword="incident"):
+    print(ev.emitted_at, ev.content)
+```
+
+See `sdk/README.md` for the shared regen/drift workflow.

hypeline-0.1.1/hypeline.egg-info/SOURCES.txt

@@ -0,0 +1,77 @@
+README.md
+pyproject.toml
+hypeline/__init__.py
+hypeline/stream.py
+hypeline/webhook.py
+hypeline.egg-info/PKG-INFO
+hypeline.egg-info/SOURCES.txt
+hypeline.egg-info/dependency_links.txt
+hypeline.egg-info/requires.txt
+hypeline.egg-info/top_level.txt
+hypeline_core/__init__.py
+hypeline_core/api_client.py
+hypeline_core/api_response.py
+hypeline_core/configuration.py
+hypeline_core/exceptions.py
+hypeline_core/py.typed
+hypeline_core/rest.py
+hypeline_core/api/__init__.py
+hypeline_core/api/event_kinds_api.py
+hypeline_core/api/history_api.py
+hypeline_core/api/render_api.py
+hypeline_core/api/sources_api.py
+hypeline_core/api/stream_api.py
+hypeline_core/api/templates_api.py
+hypeline_core/api/transparency_log_api.py
+hypeline_core/models/__init__.py
+hypeline_core/models/alert_result.py
+hypeline_core/models/alert_spec.py
+hypeline_core/models/content_diff.py
+hypeline_core/models/copy.py
+hypeline_core/models/create_source_request.py
+hypeline_core/models/delivery.py
+hypeline_core/models/delta_op.py
+hypeline_core/models/delta_stats.py
+hypeline_core/models/detect_dto.py
+hypeline_core/models/detect_source_request.py
+hypeline_core/models/diff_segment.py
+hypeline_core/models/error_detail.py
+hypeline_core/models/error_model.py
+hypeline_core/models/event_kind_dto.py
+hypeline_core/models/health_dto.py
+hypeline_core/models/history_page.py
+hypeline_core/models/inclusion.py
+hypeline_core/models/instantiate_adhoc_template_request.py
+hypeline_core/models/instantiate_template_request.py
+hypeline_core/models/manifest.py
+hypeline_core/models/next_steps.py
+hypeline_core/models/parameter.py
+hypeline_core/models/pdf_page_span.py
+hypeline_core/models/picker_box.py
+hypeline_core/models/picker_dto.py
+hypeline_core/models/preview_row_dto.py
+hypeline_core/models/preview_template_request.py
+hypeline_core/models/receipt.py
+hypeline_core/models/render_doc_body.py
+hypeline_core/models/render_doc_viewport.py
+hypeline_core/models/render_doc_wait.py
+hypeline_core/models/render_multi_response.py
+hypeline_core/models/report.py
+hypeline_core/models/signed_tree_head.py
+hypeline_core/models/source_dto.py
+hypeline_core/models/source_leaf_entry.py
+hypeline_core/models/source_log_page.py
+hypeline_core/models/source_result.py
+hypeline_core/models/source_spec.py
+hypeline_core/models/stream_event.py
+hypeline_core/models/summary.py
+hypeline_core/models/template_summary_dto.py
+hypeline_core/models/text_delta.py
+hypeline_core/models/typed_payload.py
+hypeline_core/models/update_source_request.py
+tests/test_changes.py
+tests/test_event_shape.py
+tests/test_stream.py
+tests/test_surface.py
+tests/test_watch.py
+tests/test_webhook.py

hypeline-0.1.1/hypeline.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hypeline-0.1.1/hypeline.egg-info/requires.txt

@@ -0,0 +1,5 @@
+urllib3<3.0.0,>=1.25.3
+python_dateutil>=2.8.2
+pydantic>=2
+typing-extensions>=4.7.1
+standardwebhooks>=1.0.0

hypeline-0.1.1/hypeline.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+hypeline
+hypeline_core

hypeline-0.1.1/hypeline_core/__init__.py

@@ -0,0 +1,84 @@
+# coding: utf-8
+
+# flake8: noqa
+
+"""
+    Hypeline Stream API
+
+    Subscribe to Hypeline's unified, deduplicated live event stream over Server-Sent Events. Latency is honest and per-source-tier: push sources arrive in seconds, RSS/JSON feeds in minutes, and feed-less HTML-diff sources in minutes to tens of minutes. Resume gap-free with the Last-Event-ID cursor; a cursor older than the retained window returns 410 Gone.
+
+    The version of the OpenAPI document: 1.0.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+__version__ = "1.0.0"
+
+# import apis into sdk package
+from hypeline_core.api.event_kinds_api import EventKindsApi
+from hypeline_core.api.history_api import HistoryApi
+from hypeline_core.api.render_api import RenderApi
+from hypeline_core.api.sources_api import SourcesApi
+from hypeline_core.api.stream_api import StreamApi
+from hypeline_core.api.templates_api import TemplatesApi
+from hypeline_core.api.transparency_log_api import TransparencyLogApi
+
+# import ApiClient
+from hypeline_core.api_response import ApiResponse
+from hypeline_core.api_client import ApiClient
+from hypeline_core.configuration import Configuration
+from hypeline_core.exceptions import OpenApiException
+from hypeline_core.exceptions import ApiTypeError
+from hypeline_core.exceptions import ApiValueError
+from hypeline_core.exceptions import ApiKeyError
+from hypeline_core.exceptions import ApiAttributeError
+from hypeline_core.exceptions import ApiException
+
+# import models into sdk package
+from hypeline_core.models.alert_result import AlertResult
+from hypeline_core.models.alert_spec import AlertSpec
+from hypeline_core.models.content_diff import ContentDiff
+from hypeline_core.models.copy import Copy
+from hypeline_core.models.create_source_request import CreateSourceRequest
+from hypeline_core.models.delivery import Delivery
+from hypeline_core.models.delta_op import DeltaOp
+from hypeline_core.models.delta_stats import DeltaStats
+from hypeline_core.models.detect_dto import DetectDTO
+from hypeline_core.models.detect_source_request import DetectSourceRequest
+from hypeline_core.models.diff_segment import DiffSegment
+from hypeline_core.models.error_detail import ErrorDetail
+from hypeline_core.models.error_model import ErrorModel
+from hypeline_core.models.event_kind_dto import EventKindDTO
+from hypeline_core.models.health_dto import HealthDTO
+from hypeline_core.models.history_page import HistoryPage
+from hypeline_core.models.inclusion import Inclusion
+from hypeline_core.models.instantiate_adhoc_template_request import InstantiateAdhocTemplateRequest
+from hypeline_core.models.instantiate_template_request import InstantiateTemplateRequest
+from hypeline_core.models.manifest import Manifest
+from hypeline_core.models.next_steps import NextSteps
+from hypeline_core.models.pdf_page_span import PDFPageSpan
+from hypeline_core.models.parameter import Parameter
+from hypeline_core.models.picker_box import PickerBox
+from hypeline_core.models.picker_dto import PickerDTO
+from hypeline_core.models.preview_row_dto import PreviewRowDTO
+from hypeline_core.models.preview_template_request import PreviewTemplateRequest
+from hypeline_core.models.receipt import Receipt
+from hypeline_core.models.render_doc_body import RenderDocBody
+from hypeline_core.models.render_doc_viewport import RenderDocViewport
+from hypeline_core.models.render_doc_wait import RenderDocWait
+from hypeline_core.models.render_multi_response import RenderMultiResponse
+from hypeline_core.models.report import Report
+from hypeline_core.models.signed_tree_head import SignedTreeHead
+from hypeline_core.models.source_dto import SourceDTO
+from hypeline_core.models.source_leaf_entry import SourceLeafEntry
+from hypeline_core.models.source_log_page import SourceLogPage
+from hypeline_core.models.source_result import SourceResult
+from hypeline_core.models.source_spec import SourceSpec
+from hypeline_core.models.stream_event import StreamEvent
+from hypeline_core.models.summary import Summary
+from hypeline_core.models.template_summary_dto import TemplateSummaryDTO
+from hypeline_core.models.text_delta import TextDelta
+from hypeline_core.models.typed_payload import TypedPayload
+from hypeline_core.models.update_source_request import UpdateSourceRequest