zammad-python-client 0.1.1__tar.gz

zammad_python_client-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stefan Schulte-Ortbeck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

zammad_python_client-0.1.1/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: zammad-python-client
+Version: 0.1.1
+Summary: A typed Python client for the Zammad REST API
+Author-email: Stefan Schulte-Ortbeck <info@codefighters.de>
+License: MIT
+Project-URL: Repository, https://gitlab.codefighters.de/python/zammad-python-client
+Project-URL: Changelog, https://gitlab.codefighters.de/python/zammad-python-client/-/blob/main/CHANGELOG.md
+Keywords: zammad,helpdesk,api,client
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dotenv
+Requires-Dist: python-dotenv>=1.0.0; extra == "dotenv"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: responses>=0.23; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: types-requests; extra == "dev"
+Dynamic: license-file
+
+# zammad-python-client
+
+A typed Python client for the [Zammad](https://zammad.org) REST API. `requests`
+underneath, `py.typed`, no other dependencies. Built for Zammad 7.x and used by
+[`python/zammad-mcp`](https://gitlab.codefighters.de/python/zammad-mcp).
+
+Two layers:
+
+- **Curated**: `client.tickets`, `client.ticket_articles`, `client.tags`,
+  `client.time_accountings`, `client.users`, `client.organizations`,
+  `client.groups`, `client.ticket_states`, `client.ticket_priorities`,
+  `client.knowledge_base`, plus plain CRUD collections (`client.text_modules`,
+  `client.macros`, `client.slas`, ...). One call per question, sensible defaults.
+- **Complete**: `client.api.<controller>.<action>()`, one method per route of
+  Zammad's own routing — 612 routes, 118 controllers, generated from
+  `config/routes/*.rb` of the pinned Zammad version. See
+  [`docs/endpoints.md`](docs/endpoints.md). Nothing the web UI can do is out of
+  reach, including the knowledge base, two-factor, channels and integrations.
+
+## Install
+
+```bash
+pip install zammad-python-client
+```
+
+Published to PyPI on every tag; the same wheel also lands in this project's GitLab
+package registry for internal CI. From a checkout: `pip install -e ".[dev]"`.
+
+## Use
+
+```python
+from zammad import ZammadClient
+
+c = ZammadClient("https://zammad.example.com", token="...")   # Authorization: Token token=...
+
+c.version()                                        # "7.2.2"
+c.users.current()                                  # the token's user
+open_ = c.tickets.search_tickets("state.name:open owner.login:me", limit=20)
+t = c.tickets.get(42, expand=True)                 # names next to ids
+c.ticket_articles.by_ticket(42)
+c.ticket_articles.add(42, "<p>Looked at it.</p>")  # internal note (default)
+c.ticket_articles.add(42, "<p>Fixed.</p>", article_type="email", internal=False, to="customer@example.com")
+c.time_accountings.book(42, 15)                    # unit is instance config
+c.tags.add_to(42, "billing")
+
+kb = c.knowledge_base.init()                       # bases, locales, categories, answers as assets
+c.knowledge_base.search("vpn", flavor="agent")
+a = c.knowledge_base.create_answer(1, category_id=3, title="VPN", body_html="<p>…</p>", kb_locale_id=1)
+c.knowledge_base.set_internal(1, a["id"])         # draft -> internal (agents only)
+
+# Everything else: the generated layer, named after Zammad's controllers and actions.
+c.api.settings.index_by_area("Ticket::Base")
+c.api.user_two_factors.personal_configuration()
+c.api.channels_email.index()
+```
+
+Acting as another user (needs `admin.user`): every method takes
+`on_behalf_of="login-or-email-or-id"`, sent as Zammad's `From` header.
+
+Pagination: `list(page=, per_page=)` is one page, `iter_all()` / `list_all()`
+walk pages (Zammad returns bare arrays without a total, so a short page ends the
+walk). `expand=True` adds related names next to the `*_id` fields.
+
+## Errors
+
+`ZammadError` covers everything; `ZammadAuthError` (401), `ZammadPermissionError`
+(403, the token lacks a permission), `ZammadNotFoundError` (404, which Zammad also
+uses for "not visible to you") and `ZammadRateLimitError` (429 that could not be
+waited out; `retry_after` when known) narrow it.
+
+## Keeping up with Zammad
+
+```bash
+scripts/extract-routes.py --ref stable      # or --zammad /path/to/checkout
+scripts/generate-resources.py
+pytest
+```
+
+`docs/routes.json` records the Zammad version it came from. Rails `resources`
+blocks (knowledge base, two-factor, checklists, …) are expanded by hand in
+`scripts/extract-routes.py`; the script says which route files contain such
+blocks so a new one is not missed. CI fails when `generated.py` and
+`docs/routes.json` disagree.
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+pytest -q            # mocks only, never the network
+mypy
+scripts/verify-live.py   # read-only, needs ZAMMAD_URL + ZAMMAD_TOKEN in .env
+```
+
+Releases: bump `__version__` in `src/zammad/__init__.py`, update the changelog,
+tag `vX.Y.Z`; CI publishes to PyPI (needs the `PYPI_TOKEN` CI variable) and to the
+project's GitLab registry.

zammad_python_client-0.1.1/README.md

@@ -0,0 +1,96 @@
+# zammad-python-client
+
+A typed Python client for the [Zammad](https://zammad.org) REST API. `requests`
+underneath, `py.typed`, no other dependencies. Built for Zammad 7.x and used by
+[`python/zammad-mcp`](https://gitlab.codefighters.de/python/zammad-mcp).
+
+Two layers:
+
+- **Curated**: `client.tickets`, `client.ticket_articles`, `client.tags`,
+  `client.time_accountings`, `client.users`, `client.organizations`,
+  `client.groups`, `client.ticket_states`, `client.ticket_priorities`,
+  `client.knowledge_base`, plus plain CRUD collections (`client.text_modules`,
+  `client.macros`, `client.slas`, ...). One call per question, sensible defaults.
+- **Complete**: `client.api.<controller>.<action>()`, one method per route of
+  Zammad's own routing — 612 routes, 118 controllers, generated from
+  `config/routes/*.rb` of the pinned Zammad version. See
+  [`docs/endpoints.md`](docs/endpoints.md). Nothing the web UI can do is out of
+  reach, including the knowledge base, two-factor, channels and integrations.
+
+## Install
+
+```bash
+pip install zammad-python-client
+```
+
+Published to PyPI on every tag; the same wheel also lands in this project's GitLab
+package registry for internal CI. From a checkout: `pip install -e ".[dev]"`.
+
+## Use
+
+```python
+from zammad import ZammadClient
+
+c = ZammadClient("https://zammad.example.com", token="...")   # Authorization: Token token=...
+
+c.version()                                        # "7.2.2"
+c.users.current()                                  # the token's user
+open_ = c.tickets.search_tickets("state.name:open owner.login:me", limit=20)
+t = c.tickets.get(42, expand=True)                 # names next to ids
+c.ticket_articles.by_ticket(42)
+c.ticket_articles.add(42, "<p>Looked at it.</p>")  # internal note (default)
+c.ticket_articles.add(42, "<p>Fixed.</p>", article_type="email", internal=False, to="customer@example.com")
+c.time_accountings.book(42, 15)                    # unit is instance config
+c.tags.add_to(42, "billing")
+
+kb = c.knowledge_base.init()                       # bases, locales, categories, answers as assets
+c.knowledge_base.search("vpn", flavor="agent")
+a = c.knowledge_base.create_answer(1, category_id=3, title="VPN", body_html="<p>…</p>", kb_locale_id=1)
+c.knowledge_base.set_internal(1, a["id"])         # draft -> internal (agents only)
+
+# Everything else: the generated layer, named after Zammad's controllers and actions.
+c.api.settings.index_by_area("Ticket::Base")
+c.api.user_two_factors.personal_configuration()
+c.api.channels_email.index()
+```
+
+Acting as another user (needs `admin.user`): every method takes
+`on_behalf_of="login-or-email-or-id"`, sent as Zammad's `From` header.
+
+Pagination: `list(page=, per_page=)` is one page, `iter_all()` / `list_all()`
+walk pages (Zammad returns bare arrays without a total, so a short page ends the
+walk). `expand=True` adds related names next to the `*_id` fields.
+
+## Errors
+
+`ZammadError` covers everything; `ZammadAuthError` (401), `ZammadPermissionError`
+(403, the token lacks a permission), `ZammadNotFoundError` (404, which Zammad also
+uses for "not visible to you") and `ZammadRateLimitError` (429 that could not be
+waited out; `retry_after` when known) narrow it.
+
+## Keeping up with Zammad
+
+```bash
+scripts/extract-routes.py --ref stable      # or --zammad /path/to/checkout
+scripts/generate-resources.py
+pytest
+```
+
+`docs/routes.json` records the Zammad version it came from. Rails `resources`
+blocks (knowledge base, two-factor, checklists, …) are expanded by hand in
+`scripts/extract-routes.py`; the script says which route files contain such
+blocks so a new one is not missed. CI fails when `generated.py` and
+`docs/routes.json` disagree.
+
+## Development
+
+```bash
+uv venv && uv pip install -e ".[dev]"
+pytest -q            # mocks only, never the network
+mypy
+scripts/verify-live.py   # read-only, needs ZAMMAD_URL + ZAMMAD_TOKEN in .env
+```
+
+Releases: bump `__version__` in `src/zammad/__init__.py`, update the changelog,
+tag `vX.Y.Z`; CI publishes to PyPI (needs the `PYPI_TOKEN` CI variable) and to the
+project's GitLab registry.

zammad_python_client-0.1.1/pyproject.toml

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zammad-python-client"
+dynamic = ["version"]
+description = "A typed Python client for the Zammad REST API"
+authors = [{name = "Stefan Schulte-Ortbeck", email = "info@codefighters.de"}]
+readme = "README.md"
+license = {text = "MIT"}
+keywords = ["zammad", "helpdesk", "api", "client"]
+dependencies = [
+    "requests>=2.28.0",
+]
+# Keep in lockstep with the matrix in .gitlab-ci.yml. Same floor as
+# billomat-python-client, for the same reason (3.10 is EOL in October 2026).
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Typing :: Typed",
+]
+
+[project.optional-dependencies]
+dotenv = ["python-dotenv>=1.0.0"]
+dev = [
+    "pytest>=7.0",
+    "responses>=0.23",
+    "mypy>=1.8",
+    "types-requests",
+]
+
+[project.urls]
+Repository = "https://gitlab.codefighters.de/python/zammad-python-client"
+Changelog = "https://gitlab.codefighters.de/python/zammad-python-client/-/blob/main/CHANGELOG.md"
+
+[tool.setuptools.dynamic]
+# Single source of truth; the publish job refuses a tag that does not match it.
+version = {attr = "zammad.__version__"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+zammad = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.11"
+files = ["src/zammad"]
+warn_unused_ignores = true
+warn_redundant_casts = true
+warn_unreachable = true

zammad_python_client-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zammad_python_client-0.1.1/src/zammad/__init__.py

@@ -0,0 +1,56 @@
+"""A typed Python client for the Zammad REST API."""
+
+import logging
+
+from .client import ZammadClient
+from .exceptions import (
+    ZammadAuthError,
+    ZammadError,
+    ZammadNotFoundError,
+    ZammadPermissionError,
+    ZammadRateLimitError,
+)
+from .resources import Api, Endpoint, Resource
+from .transport import Transport
+from .types import (
+    GenericDict,
+    GroupDict,
+    KnowledgeBaseAnswerDict,
+    KnowledgeBaseCategoryDict,
+    OrganizationDict,
+    TicketArticleDict,
+    TicketDict,
+    TicketPriorityDict,
+    TicketStateDict,
+    TimeAccountingDict,
+    UserDict,
+)
+
+__version__ = "0.1.1"
+
+logging.getLogger(__name__).addHandler(logging.NullHandler())
+
+__all__ = [
+    "ZammadClient",
+    "ZammadError",
+    "ZammadAuthError",
+    "ZammadPermissionError",
+    "ZammadNotFoundError",
+    "ZammadRateLimitError",
+    "Transport",
+    "Endpoint",
+    "Resource",
+    "Api",
+    "GenericDict",
+    "TicketDict",
+    "TicketArticleDict",
+    "UserDict",
+    "OrganizationDict",
+    "GroupDict",
+    "TicketStateDict",
+    "TicketPriorityDict",
+    "TimeAccountingDict",
+    "KnowledgeBaseAnswerDict",
+    "KnowledgeBaseCategoryDict",
+    "__version__",
+]

zammad_python_client-0.1.1/src/zammad/client.py

@@ -0,0 +1,99 @@
+"""Composition root: one ``ZammadClient`` per instance and credential."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import requests
+
+from .resources import (
+    Api,
+    Groups,
+    KnowledgeBase,
+    Organizations,
+    Resource,
+    Roles,
+    Tags,
+    TicketArticles,
+    TicketPriorities,
+    Tickets,
+    TicketStates,
+    TimeAccountings,
+    Users,
+)
+from .transport import Transport
+
+
+class ZammadClient:
+    """Entry point.
+
+    The curated attributes (``tickets``, ``users``, ...) are the ergonomic
+    layer. ``api`` exposes every controller of the instance's routing with one
+    method per route (``client.api.settings.index_by_area(...)``), so nothing
+    the UI can do is out of reach -- see docs/endpoints.md.
+    """
+
+    def __init__(
+        self,
+        url: str,
+        token: Optional[str] = None,
+        *,
+        bearer: Optional[str] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        session: Optional[requests.Session] = None,
+        timeout: float = 30.0,
+        max_attempts: int = 3,
+    ) -> None:
+        self.transport = Transport(
+            url,
+            token=token,
+            bearer=bearer,
+            username=username,
+            password=password,
+            session=session,
+            timeout=timeout,
+            max_attempts=max_attempts,
+        )
+        t = self.transport
+        # Curated
+        self.tickets = Tickets(t)
+        self.ticket_articles = TicketArticles(t)
+        self.tags = Tags(t)
+        self.time_accountings = TimeAccountings(t)
+        self.users = Users(t)
+        self.organizations = Organizations(t)
+        self.groups = Groups(t)
+        self.roles = Roles(t)
+        self.ticket_states = TicketStates(t)
+        self.ticket_priorities = TicketPriorities(t)
+        self.knowledge_base = KnowledgeBase(t)
+        # Plain CRUD collections that need nothing beyond list/get/create/update/delete.
+        self.text_modules: Resource[Dict[str, Any]] = Resource(t, "/text_modules")
+        self.macros: Resource[Dict[str, Any]] = Resource(t, "/macros")
+        self.overviews: Resource[Dict[str, Any]] = Resource(t, "/overviews")
+        self.templates: Resource[Dict[str, Any]] = Resource(t, "/templates")
+        self.signatures: Resource[Dict[str, Any]] = Resource(t, "/signatures")
+        self.email_addresses: Resource[Dict[str, Any]] = Resource(t, "/email_addresses")
+        self.slas: Resource[Dict[str, Any]] = Resource(t, "/slas")
+        self.triggers: Resource[Dict[str, Any]] = Resource(t, "/triggers")
+        self.jobs: Resource[Dict[str, Any]] = Resource(t, "/jobs")
+        self.webhooks: Resource[Dict[str, Any]] = Resource(t, "/webhooks")
+        self.calendars: Resource[Dict[str, Any]] = Resource(t, "/calendars")
+        self.object_manager_attributes: Resource[Dict[str, Any]] = Resource(t, "/object_manager_attributes")
+        self.online_notifications: Resource[Dict[str, Any]] = Resource(t, "/online_notifications")
+        self.user_access_tokens: Resource[Dict[str, Any]] = Resource(t, "/user_access_token")
+        self.checklist_templates: Resource[Dict[str, Any]] = Resource(t, "/checklist_templates")
+        # Everything
+        self.api = Api(t)
+
+    def version(self) -> str:
+        """The instance's Zammad version (``/version``)."""
+        result = self.api.version.index()
+        return str(result.get("version", "")) if isinstance(result, dict) else str(result)
+
+    def __repr__(self) -> str:
+        return f"<ZammadClient {self.transport.base_url}>"
+
+
+__all__ = ["ZammadClient"]

zammad_python_client-0.1.1/src/zammad/exceptions.py

@@ -0,0 +1,50 @@
+"""Exception hierarchy for the Zammad client."""
+
+from typing import Optional
+
+
+class ZammadError(Exception):
+    """Base exception for all Zammad API errors.
+
+    Transport failures (connection errors, timeouts) are wrapped in this
+    exception as well, so catching it covers everything the client raises.
+    """
+
+
+class ZammadAuthError(ZammadError):
+    """Raised when authentication fails (HTTP 401) or credentials are missing."""
+
+
+class ZammadPermissionError(ZammadError):
+    """Raised when the token lacks a permission for the call (HTTP 403).
+
+    Zammad is explicit about this, e.g. a token without ``ticket.agent`` reading
+    tickets, or ``knowledge_base.reader`` missing for the knowledge base.
+    """
+
+
+class ZammadNotFoundError(ZammadError):
+    """Raised when the record does not exist or is not visible (HTTP 404).
+
+    Zammad answers 404 for both cases, so "not found" may mean "not yours".
+    """
+
+
+class ZammadRateLimitError(ZammadError):
+    """Raised when a rate limit (HTTP 429) could not be resolved automatically.
+
+    ``retry_after`` carries the seconds Zammad asked to wait, when it said so.
+    """
+
+    def __init__(self, message: str, retry_after: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.retry_after = retry_after
+
+
+__all__ = [
+    "ZammadError",
+    "ZammadAuthError",
+    "ZammadPermissionError",
+    "ZammadNotFoundError",
+    "ZammadRateLimitError",
+]

zammad_python_client-0.1.1/src/zammad/resources/__init__.py

@@ -0,0 +1,22 @@
+from .base import Endpoint, Resource
+from .generated import Api
+from .knowledge_base import KnowledgeBase
+from .people import Groups, Organizations, Roles, TicketPriorities, TicketStates, Users
+from .tickets import Tags, TicketArticles, TimeAccountings, Tickets
+
+__all__ = [
+    "Endpoint",
+    "Resource",
+    "Api",
+    "KnowledgeBase",
+    "Tickets",
+    "TicketArticles",
+    "Tags",
+    "TimeAccountings",
+    "Users",
+    "Organizations",
+    "Groups",
+    "Roles",
+    "TicketStates",
+    "TicketPriorities",
+]

zammad_python_client-0.1.1/src/zammad/resources/base.py

@@ -0,0 +1,114 @@
+"""Base classes shared by generated and hand-written resources.
+
+``Endpoint`` is the thinnest possible layer over :class:`Transport`: it turns a
+route template plus path parameters into one call. The generated module builds
+one method per Zammad route on it. ``Resource`` adds the CRUD conveniences that
+most Zammad collections share (``/things``, ``/things/:id``).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Generic, Iterator, List, Mapping, Optional, TypeVar, cast
+
+from ..transport import DEFAULT_PER_PAGE, Transport
+
+T = TypeVar("T", bound=Mapping[str, Any])
+
+Params = Optional[Mapping[str, Any]]
+Json = Optional[Mapping[str, Any]]
+
+
+class Endpoint:
+    """A group of routes sharing one Zammad controller."""
+
+    controller: str = ""
+
+    def __init__(self, transport: Transport) -> None:
+        self._transport = transport
+
+    @staticmethod
+    def _fill(template: str, **path_params: Any) -> str:
+        """Substitutes ``:name`` segments; values are stringified as-is."""
+        path = template
+        for name, value in path_params.items():
+            path = path.replace(f":{name}", str(value))
+        if ":" in path.split("?")[0]:
+            raise ValueError(f"unfilled path parameter in {path!r}")
+        return path.lstrip("/")
+
+    def _call(
+        self,
+        method: str,
+        template: str,
+        path_params: Mapping[str, Any],
+        params: Params = None,
+        json: Json = None,
+        on_behalf_of: Optional[str] = None,
+        raw: bool = False,
+    ) -> Any:
+        return self._transport.request(
+            method,
+            self._fill(template, **path_params),
+            params=dict(params) if params else None,
+            json=dict(json) if json is not None else None,
+            on_behalf_of=on_behalf_of,
+            raw=raw,
+        )
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} controller={self.controller!r}>"
+
+
+class Resource(Endpoint, Generic[T]):
+    """CRUD over a standard Zammad collection.
+
+    ``path`` is the collection path relative to ``/api/v1`` (``/users``). Most
+    collections also support ``?expand=true`` to inline relations and
+    ``page``/``per_page`` for paging; both are plain query parameters here.
+    """
+
+    path: str = ""
+
+    def __init__(self, transport: Transport, path: Optional[str] = None) -> None:
+        super().__init__(transport)
+        if path is not None:
+            self.path = path
+        if not self.path:
+            raise ValueError(f"{type(self).__name__} needs a collection path")
+
+    def list(self, *, expand: bool = False, on_behalf_of: Optional[str] = None, **params: Any) -> List[T]:
+        """One page of records (``page``/``per_page`` as keyword arguments)."""
+        if expand:
+            params["expand"] = "true"
+        result = self._transport.get(self.path.lstrip("/"), params=params or None, on_behalf_of=on_behalf_of)
+        return cast(List[T], list(result) if isinstance(result, list) else [])
+
+    def iter_all(
+        self, *, expand: bool = False, per_page: int = DEFAULT_PER_PAGE, on_behalf_of: Optional[str] = None, **params: Any
+    ) -> Iterator[T]:
+        """Every record, fetching pages lazily."""
+        if expand:
+            params["expand"] = "true"
+        return cast(
+            Iterator[T],
+            self._transport.paginate(self.path.lstrip("/"), params=params or None, per_page=per_page, on_behalf_of=on_behalf_of),
+        )
+
+    def list_all(self, **kwargs: Any) -> List[T]:
+        return list(self.iter_all(**kwargs))
+
+    def get(self, record_id: int, *, expand: bool = False, on_behalf_of: Optional[str] = None) -> T:
+        params = {"expand": "true"} if expand else None
+        return cast(T, self._transport.get(f"{self.path.lstrip('/')}/{record_id}", params=params, on_behalf_of=on_behalf_of))
+
+    def create(self, data: Mapping[str, Any], *, on_behalf_of: Optional[str] = None) -> T:
+        return cast(T, self._transport.post(self.path.lstrip("/"), json=dict(data), on_behalf_of=on_behalf_of))
+
+    def update(self, record_id: int, data: Mapping[str, Any], *, on_behalf_of: Optional[str] = None) -> T:
+        return cast(T, self._transport.put(f"{self.path.lstrip('/')}/{record_id}", json=dict(data), on_behalf_of=on_behalf_of))
+
+    def delete(self, record_id: int, *, on_behalf_of: Optional[str] = None) -> None:
+        self._transport.delete(f"{self.path.lstrip('/')}/{record_id}", on_behalf_of=on_behalf_of)
+
+
+__all__ = ["Endpoint", "Resource", "Params", "Json"]