sendithq 0.1.0__tar.gz

sendithq-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/

sendithq-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SendItWhenever
+
+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.

sendithq-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: sendithq
+Version: 0.1.0
+Summary: SendItWhenever Python SDK — 초정밀 예약 웹훅을 3줄로.
+Project-URL: Homepage, https://www.sendit-whenever.com
+Project-URL: Documentation, https://www.sendit-whenever.com/docs/sdk-reference
+Project-URL: Repository, https://github.com/soft37-git/senditwhenever
+Project-URL: Issues, https://github.com/soft37-git/senditwhenever/issues
+Author: SendItWhenever
+License: MIT
+License-File: LICENSE
+Keywords: cron,delayed-http,hmac,schedule,scheduler,sendit,sendithq,senditwhenever,webhook
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# sendithq — SendItWhenever Python SDK
+
+초정밀 예약 웹훅(HTTP)을 3줄로. Node SDK([`@sendithq/sdk`](https://www.npmjs.com/package/@sendithq/sdk))와 동일한
+표면을 Python 관용구로 제공합니다. 동기(`SendIt`) + 비동기(`AsyncSendIt`), 의존성은 `httpx` 하나.
+
+```bash
+pip install sendithq
+```
+
+## Quickstart (sync)
+
+```python
+from sendithq import SendIt
+
+sendit = SendIt("sw_live_xxx")
+ref = sendit.schedule(
+    url="https://api.myapp.com/hook",
+    in_="2h",                    # 또는 fire_at=datetime(...) / "2026-01-01T00:00:00Z"
+    payload={"user_id": 42},     # dict → JSON + Content-Type 자동, str → 그대로
+    idempotency_key="trial-end:42",
+)
+print(ref.id, ref.fire_at, ref.status)
+```
+
+> `in` 은 Python 예약어라 상대 시간 인자는 **`in_`** 을 씁니다(`in_="30s" | "15m" | "2h" | "1d"`).
+
+## Quickstart (async)
+
+```python
+import asyncio
+from sendithq import AsyncSendIt
+
+async def main():
+    async with AsyncSendIt("sw_live_xxx") as sendit:
+        ref = await sendit.schedule(url="https://api.myapp.com/hook", in_="2h")
+        print(ref.id)
+
+asyncio.run(main())
+```
+
+## Constructor
+
+```python
+SendIt(
+    api_key,                                  # "sw_live_…" / "sw_test_…" — 형식 오류 시 즉시 예외
+    base_url="https://api.sendit-whenever.com",
+    timeout=30.0,                             # 초
+    max_retries=2,                            # 멱등 경로 한정 재시도
+    signing_secret=None,                      # verify_signature 기본 시크릿
+)
+```
+
+## Methods
+
+| 메서드 | 반환 | 비고 |
+|--------|------|------|
+| `schedule(url, *, fire_at\|in_, payload, method, headers, idempotency_key)` | `ScheduleRef` | `idempotency_key` 있을 때만 자동 재시도 |
+| `schedule_many(items)` | `BulkScheduleResult` | 부분성공. `items` 는 schedule() 키의 dict 리스트 |
+| `list(*, status, q, limit, offset)` | `ListResult` | 멱등 재시도 |
+| `get(id)` | `Schedule` | |
+| `get_attempts(id)` | `list[DeliveryAttempt]` | 발송 시도 로그 |
+| `reschedule(id, *, fire_at\|in_)` | `Schedule` | `scheduled` 상태에서만 |
+| `replay(id)` | `ScheduleRef` | 동일 암호문 재발송(비멱등) |
+| `clone(id, *, payload, fire_at\|in_)` | `ScheduleRef` | 새 페이로드(비멱등) |
+| `cancel(id)` | `Schedule` | 멱등 |
+| `verify_signature(body, headers, *, secrets\|secret, tolerance_sec)` | `bool` | 나가는 웹훅 HMAC 검증 |
+| `signing_secrets.get()` / `.rotate()` | `SigningSecretPair` | 2키 회전 |
+
+`AsyncSendIt` 은 동일 표면이며 메서드가 코루틴입니다(`await`).
+
+## Verifying incoming webhooks
+
+SendItWhenever 가 보내는 웹훅에는 항상 `X-SendIt-Signature` 헤더(HMAC-SHA256)가 붙습니다.
+**서명 대상은 raw 본문**이므로 파싱 전 원본 바이트를 넘기세요.
+
+```python
+# Flask 예시
+from flask import request
+from sendithq import SendIt
+
+sendit = SendIt("sw_live_xxx")
+
+@app.post("/hook")
+def hook():
+    secrets = sendit.signing_secrets.get()           # 무중단 회전 대비 2키
+    ok = sendit.verify_signature(
+        request.get_data(),                            # raw bytes
+        request.headers,
+        secrets=[secrets.current.secret, secrets.next.secret],
+    )
+    if not ok:
+        return ("bad signature", 400)
+    ...
+```
+
+## Errors
+
+모든 실패는 `SendItError(code, message, status)` 를 던집니다.
+
+```python
+from sendithq import SendItError
+
+try:
+    sendit.get("missing")
+except SendItError as err:
+    if err.code == "NOT_FOUND":
+        ...
+```
+
+`code` ∈ `UNAUTHORIZED | FORBIDDEN | NOT_FOUND | VALIDATION | CONFLICT | RATE_LIMITED | INTERNAL | NETWORK`.
+
+## Links
+
+- 문서: <https://www.sendit-whenever.com/docs/sdk-reference>
+- 대시보드(API Key 발급): <https://www.sendit-whenever.com>
+
+MIT License.

sendithq-0.1.0/README.md

@@ -0,0 +1,117 @@
+# sendithq — SendItWhenever Python SDK
+
+초정밀 예약 웹훅(HTTP)을 3줄로. Node SDK([`@sendithq/sdk`](https://www.npmjs.com/package/@sendithq/sdk))와 동일한
+표면을 Python 관용구로 제공합니다. 동기(`SendIt`) + 비동기(`AsyncSendIt`), 의존성은 `httpx` 하나.
+
+```bash
+pip install sendithq
+```
+
+## Quickstart (sync)
+
+```python
+from sendithq import SendIt
+
+sendit = SendIt("sw_live_xxx")
+ref = sendit.schedule(
+    url="https://api.myapp.com/hook",
+    in_="2h",                    # 또는 fire_at=datetime(...) / "2026-01-01T00:00:00Z"
+    payload={"user_id": 42},     # dict → JSON + Content-Type 자동, str → 그대로
+    idempotency_key="trial-end:42",
+)
+print(ref.id, ref.fire_at, ref.status)
+```
+
+> `in` 은 Python 예약어라 상대 시간 인자는 **`in_`** 을 씁니다(`in_="30s" | "15m" | "2h" | "1d"`).
+
+## Quickstart (async)
+
+```python
+import asyncio
+from sendithq import AsyncSendIt
+
+async def main():
+    async with AsyncSendIt("sw_live_xxx") as sendit:
+        ref = await sendit.schedule(url="https://api.myapp.com/hook", in_="2h")
+        print(ref.id)
+
+asyncio.run(main())
+```
+
+## Constructor
+
+```python
+SendIt(
+    api_key,                                  # "sw_live_…" / "sw_test_…" — 형식 오류 시 즉시 예외
+    base_url="https://api.sendit-whenever.com",
+    timeout=30.0,                             # 초
+    max_retries=2,                            # 멱등 경로 한정 재시도
+    signing_secret=None,                      # verify_signature 기본 시크릿
+)
+```
+
+## Methods
+
+| 메서드 | 반환 | 비고 |
+|--------|------|------|
+| `schedule(url, *, fire_at\|in_, payload, method, headers, idempotency_key)` | `ScheduleRef` | `idempotency_key` 있을 때만 자동 재시도 |
+| `schedule_many(items)` | `BulkScheduleResult` | 부분성공. `items` 는 schedule() 키의 dict 리스트 |
+| `list(*, status, q, limit, offset)` | `ListResult` | 멱등 재시도 |
+| `get(id)` | `Schedule` | |
+| `get_attempts(id)` | `list[DeliveryAttempt]` | 발송 시도 로그 |
+| `reschedule(id, *, fire_at\|in_)` | `Schedule` | `scheduled` 상태에서만 |
+| `replay(id)` | `ScheduleRef` | 동일 암호문 재발송(비멱등) |
+| `clone(id, *, payload, fire_at\|in_)` | `ScheduleRef` | 새 페이로드(비멱등) |
+| `cancel(id)` | `Schedule` | 멱등 |
+| `verify_signature(body, headers, *, secrets\|secret, tolerance_sec)` | `bool` | 나가는 웹훅 HMAC 검증 |
+| `signing_secrets.get()` / `.rotate()` | `SigningSecretPair` | 2키 회전 |
+
+`AsyncSendIt` 은 동일 표면이며 메서드가 코루틴입니다(`await`).
+
+## Verifying incoming webhooks
+
+SendItWhenever 가 보내는 웹훅에는 항상 `X-SendIt-Signature` 헤더(HMAC-SHA256)가 붙습니다.
+**서명 대상은 raw 본문**이므로 파싱 전 원본 바이트를 넘기세요.
+
+```python
+# Flask 예시
+from flask import request
+from sendithq import SendIt
+
+sendit = SendIt("sw_live_xxx")
+
+@app.post("/hook")
+def hook():
+    secrets = sendit.signing_secrets.get()           # 무중단 회전 대비 2키
+    ok = sendit.verify_signature(
+        request.get_data(),                            # raw bytes
+        request.headers,
+        secrets=[secrets.current.secret, secrets.next.secret],
+    )
+    if not ok:
+        return ("bad signature", 400)
+    ...
+```
+
+## Errors
+
+모든 실패는 `SendItError(code, message, status)` 를 던집니다.
+
+```python
+from sendithq import SendItError
+
+try:
+    sendit.get("missing")
+except SendItError as err:
+    if err.code == "NOT_FOUND":
+        ...
+```
+
+`code` ∈ `UNAUTHORIZED | FORBIDDEN | NOT_FOUND | VALIDATION | CONFLICT | RATE_LIMITED | INTERNAL | NETWORK`.
+
+## Links
+
+- 문서: <https://www.sendit-whenever.com/docs/sdk-reference>
+- 대시보드(API Key 발급): <https://www.sendit-whenever.com>
+
+MIT License.

sendithq-0.1.0/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "sendithq"
+version = "0.1.0"
+description = "SendItWhenever Python SDK — 초정밀 예약 웹훅을 3줄로."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "SendItWhenever" }]
+requires-python = ">=3.9"
+keywords = [
+    "webhook",
+    "scheduler",
+    "schedule",
+    "delayed-http",
+    "cron",
+    "hmac",
+    "sendit",
+    "senditwhenever",
+    "sendithq",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.27"]
+
+[project.urls]
+Homepage = "https://www.sendit-whenever.com"
+Documentation = "https://www.sendit-whenever.com/docs/sdk-reference"
+Repository = "https://github.com/soft37-git/senditwhenever"
+Issues = "https://github.com/soft37-git/senditwhenever/issues"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.23",
+    "mypy>=1.10",
+    "ruff>=0.5",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/sendithq"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+
+# mypy 는 3.10+ 만 타깃 가능(런타임은 3.9 지원 — typing.List/Optional + future annotations 사용).
+[tool.mypy]
+strict = true
+python_version = "3.10"
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.ruff.lint]
+# UP(pyupgrade)는 3.9 호환 typing.List/Optional 을 builtin 제네릭으로 강제하므로 제외.
+select = ["E", "F", "I", "B"]

sendithq-0.1.0/src/sendithq/__init__.py

@@ -0,0 +1,52 @@
+"""SendItWhenever Python SDK — 초정밀 예약 웹훅을 3줄로.
+
+    from sendithq import SendIt
+    sendit = SendIt("sw_live_xxx")
+    sendit.schedule(url="https://api.myapp.com/hook", in_="2h", payload={"id": 42})
+
+비동기는 ``AsyncSendIt`` 를 쓴다. HMAC 검증은 ``SendIt.verify_signature`` / 모듈 함수.
+"""
+
+from __future__ import annotations
+
+from ._async import AsyncSendIt
+from ._signing import SIGNATURE_HEADER, verify_webhook
+from ._sync import SendIt
+from ._version import __version__
+from .duration import parse_duration
+from .errors import SendItError, SendItErrorCode
+from .models import (
+    BulkAccepted,
+    BulkRejected,
+    BulkScheduleResult,
+    DeliveryAttempt,
+    HttpMethod,
+    ListResult,
+    Schedule,
+    ScheduleRef,
+    ScheduleStatus,
+    SigningSecret,
+    SigningSecretPair,
+)
+
+__all__ = [
+    "__version__",
+    "SendIt",
+    "AsyncSendIt",
+    "SendItError",
+    "SendItErrorCode",
+    "parse_duration",
+    "verify_webhook",
+    "SIGNATURE_HEADER",
+    "Schedule",
+    "ScheduleRef",
+    "DeliveryAttempt",
+    "SigningSecret",
+    "SigningSecretPair",
+    "BulkAccepted",
+    "BulkRejected",
+    "BulkScheduleResult",
+    "ListResult",
+    "HttpMethod",
+    "ScheduleStatus",
+]

sendithq-0.1.0/src/sendithq/_apikey.py

@@ -0,0 +1,32 @@
+# API Key 포맷 선검증(생성자에서 첫 요청 전에 빈/형식오류를 표면화). 값 자체의 유효성(폐기·오타)은
+# 서버가 UNAUTHORIZED 로 최종 판정한다. 서버와 단일 규칙을 공유하기 위해 KEY_PATTERN 을 포팅한다.
+# 미러: packages/shared/src/crypto/api-key.ts (parseApiKey)
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Literal, Optional, cast
+
+ApiKeyEnv = Literal["live", "test"]
+
+__all__ = ["ParsedApiKey", "parse_api_key"]
+
+_KEY_PATTERN = re.compile(r"^sw_(live|test)_([A-Za-z0-9_-]{8,})$")
+
+
+@dataclass(frozen=True)
+class ParsedApiKey:
+    env: ApiKeyEnv
+    prefix: str
+    last4: str
+
+
+def parse_api_key(key: str) -> Optional[ParsedApiKey]:
+    """키 포맷을 검증·파싱한다. 형식이 잘못되면 None."""
+    match = _KEY_PATTERN.match(key)
+    if match is None:
+        return None
+    env = cast(ApiKeyEnv, match.group(1))
+    token = match.group(2)
+    return ParsedApiKey(env=env, prefix=f"sw_{env}", last4=token[-4:])

sendithq-0.1.0/src/sendithq/_async.py

@@ -0,0 +1,213 @@
+# 비동기 클라이언트(AsyncSendIt) — httpx.AsyncClient 래퍼. 동기판(_sync.SendIt)과 표면 동일,
+# transport 만 await. 미러: packages/sdk/src/index.ts
+
+from __future__ import annotations
+
+import asyncio
+from types import TracebackType
+from typing import Any, List, Mapping, Optional, Sequence, Type, Union
+
+import httpx
+
+from ._base import _BaseSendIt, clean_query
+from ._core import build_clone_body, build_schedule_body, is_retriable, resolve_fire_at
+from .errors import SendItError
+from .models import (
+    BulkScheduleResult,
+    DeliveryAttempt,
+    HttpMethod,
+    ListResult,
+    Schedule,
+    ScheduleRef,
+    ScheduleStatus,
+    SigningSecretPair,
+)
+
+__all__ = ["AsyncSendIt"]
+
+FireAt = Union[str, Any]
+
+
+class _AsyncSigningSecrets:
+    """signing_secrets.get()/rotate() 네임스페이스(코루틴)."""
+
+    def __init__(self, client: "AsyncSendIt") -> None:
+        self._client = client
+
+    async def get(self) -> SigningSecretPair:
+        raw = await self._client._request("GET", "v1/signing-secrets", retryable=True)
+        return SigningSecretPair.from_wire(raw)
+
+    async def rotate(self) -> SigningSecretPair:
+        raw = await self._client._request("POST", "v1/signing-secrets/rotate", retryable=False)
+        return SigningSecretPair.from_wire(raw)
+
+
+class AsyncSendIt(_BaseSendIt):
+    """SendItWhenever 비동기 클라이언트.
+
+        from sendithq import AsyncSendIt
+        async with AsyncSendIt("sw_live_xxx") as sendit:
+            ref = await sendit.schedule(url="https://api.myapp.com/hook", in_="2h")
+    """
+
+    def __init__(self, api_key: str, **kwargs: Any) -> None:
+        super().__init__(api_key, **kwargs)
+        self._http = httpx.AsyncClient(timeout=self._timeout, follow_redirects=False)
+        self.signing_secrets = _AsyncSigningSecrets(self)
+
+    # ── lifecycle ────────────────────────────────────────────────────────────
+    async def aclose(self) -> None:
+        await self._http.aclose()
+
+    async def __aenter__(self) -> "AsyncSendIt":
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc: Optional[BaseException],
+        tb: Optional[TracebackType],
+    ) -> None:
+        await self.aclose()
+
+    # ── transport ──────────────────────────────────────────────────────────
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        query: Optional[Mapping[str, Any]] = None,
+        body: Optional[Any] = None,
+        retryable: bool = False,
+    ) -> Any:
+        url = self._url(path)
+        headers = self._headers(body is not None)
+        content = self._encode(body)
+        max_attempts = self._max_retries + 1 if retryable else 1
+        last: Optional[SendItError] = None
+
+        for attempt in range(max_attempts):
+            try:
+                resp = await self._http.request(
+                    method, url, params=clean_query(query), content=content, headers=headers
+                )
+                return self._process(resp.status_code, resp.text, resp.is_success)
+            except SendItError as err:
+                last = err
+            except httpx.RequestError as err:
+                last = SendItError("NETWORK", str(err) or "request failed")
+
+            if attempt < max_attempts - 1 and is_retriable(last):
+                await asyncio.sleep(self._backoff_seconds(attempt))
+                continue
+            raise last
+        raise last if last is not None else SendItError("NETWORK", "request failed")
+
+    # ── methods ──────────────────────────────────────────────────────────────
+    async def schedule(
+        self,
+        *,
+        url: str,
+        fire_at: Optional[FireAt] = None,
+        in_: Optional[str] = None,
+        payload: Any = None,
+        method: Optional[HttpMethod] = None,
+        headers: Optional[Mapping[str, str]] = None,
+        idempotency_key: Optional[str] = None,
+    ) -> ScheduleRef:
+        body = build_schedule_body(
+            url=url,
+            fire_at=fire_at,
+            in_=in_,
+            payload=payload,
+            method=method,
+            headers=headers,
+            idempotency_key=idempotency_key,
+        )
+        raw = await self._request(
+            "POST", "v1/schedules", body=body, retryable=idempotency_key is not None
+        )
+        return ScheduleRef.from_wire(raw)
+
+    async def schedule_many(self, items: Sequence[Mapping[str, Any]]) -> BulkScheduleResult:
+        if not items:
+            raise SendItError("VALIDATION", "schedule_many: items must not be empty")
+        bodies = [
+            build_schedule_body(
+                url=it["url"],
+                fire_at=it.get("fire_at"),
+                in_=it.get("in_"),
+                payload=it.get("payload"),
+                method=it.get("method"),
+                headers=it.get("headers"),
+                idempotency_key=it.get("idempotency_key"),
+            )
+            for it in items
+        ]
+        retryable = all(it.get("idempotency_key") is not None for it in items)
+        raw = await self._request(
+            "POST", "v1/schedules/bulk", body={"items": bodies}, retryable=retryable
+        )
+        return BulkScheduleResult.from_wire(raw)
+
+    async def list(
+        self,
+        *,
+        status: Optional[ScheduleStatus] = None,
+        q: Optional[str] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> ListResult:
+        raw = await self._request(
+            "GET",
+            "v1/schedules",
+            query={"status": status, "q": q, "limit": limit, "offset": offset},
+            retryable=True,
+        )
+        return ListResult.from_wire(raw)
+
+    async def get(self, schedule_id: str) -> Schedule:
+        raw = await self._request("GET", f"v1/schedules/{schedule_id}", retryable=True)
+        return Schedule.from_wire(raw)
+
+    async def get_attempts(self, schedule_id: str) -> List[DeliveryAttempt]:
+        raw = await self._request("GET", f"v1/schedules/{schedule_id}/attempts", retryable=True)
+        return [DeliveryAttempt.from_wire(r) for r in raw.get("items", [])]
+
+    async def reschedule(
+        self,
+        schedule_id: str,
+        *,
+        fire_at: Optional[FireAt] = None,
+        in_: Optional[str] = None,
+    ) -> Schedule:
+        raw = await self._request(
+            "PATCH",
+            f"v1/schedules/{schedule_id}",
+            body={"fireAt": resolve_fire_at(fire_at, in_)},
+            retryable=False,
+        )
+        return Schedule.from_wire(raw)
+
+    async def replay(self, schedule_id: str) -> ScheduleRef:
+        raw = await self._request("POST", f"v1/schedules/{schedule_id}/replay", retryable=False)
+        return ScheduleRef.from_wire(raw)
+
+    async def clone(
+        self,
+        schedule_id: str,
+        *,
+        payload: Any,
+        fire_at: Optional[FireAt] = None,
+        in_: Optional[str] = None,
+    ) -> ScheduleRef:
+        body = build_clone_body(payload=payload, fire_at=fire_at, in_=in_)
+        raw = await self._request(
+            "POST", f"v1/schedules/{schedule_id}/clone", body=body, retryable=False
+        )
+        return ScheduleRef.from_wire(raw)
+
+    async def cancel(self, schedule_id: str) -> Schedule:
+        raw = await self._request("DELETE", f"v1/schedules/{schedule_id}", retryable=True)
+        return Schedule.from_wire(raw)