stackshift 1.0.0__tar.gz → 1.1.0__tar.gz

stackshift-1.1.0/PKG-INFO

@@ -0,0 +1,252 @@
+Metadata-Version: 2.4
+Name: stackshift
+Version: 1.1.0
+Summary: Official Python SDK for StackShift.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31
+
+# StackShift Python SDK
+
+Official Python SDK for StackShift.
+
+## Install
+
+```bash
+pip install stackshift
+```
+
+## Send email
+
+```python
+from stackshift import StackShift
+
+stackshift = StackShift()
+
+message = stackshift.mail.send(
+    from_="StackShift <noreply@mail.stackshift.cloud>",
+    to="ada@example.com",
+    subject="Welcome",
+    text="Welcome to StackShift.",
+    idempotency_key="welcome:user_123",
+)
+
+print(message["id"], message["status"], message["idempotencyStatus"])
+```
+
+Inspect message status:
+
+```python
+messages = stackshift.mail.messages.list(status="mta_accepted", limit=20)
+detail = stackshift.mail.messages.get(messages["data"][0]["id"])
+attempts = stackshift.mail.messages.attempts(detail["id"])
+logs = stackshift.mail.messages.logs(detail["id"])
+```
+
+`mta_accepted` means the message was accepted by StackShift's outbound MTA. It does not mean recipient-MX acceptance, inbox placement, opens, clicks, or spam placement. Recipient records later transition independently to `delayed`, `delivered`, `bounced`, `failed`, `suppressed`, or `complained`.
+
+## Events and webhooks
+
+```python
+events = stackshift.mail.events.list(
+    type="mail.message.bounced",
+    message_id="msg_123",
+    limit=20,
+)
+
+event = stackshift.mail.events.get("evt_123")
+timeline = stackshift.mail.messages.timeline("msg_123")
+
+webhook = stackshift.mail.webhooks.create(
+    url="https://example.com/stackshift-mail",
+    event_types=["mail.message.bounced", "mail.otp.verified"],
+)
+print(webhook["id"], webhook["secret"])  # Secret is only returned on create/rotate.
+
+deliveries = stackshift.mail.webhooks.deliveries(webhook["id"], status="failed")
+retried = stackshift.mail.webhooks.retry_delivery(deliveries["data"][0]["id"])
+```
+
+Verify a webhook signature before processing the payload:
+
+```python
+valid = stackshift.mail.webhooks.verify_signature(
+    raw_body=request.get_data(),
+    signature_header=request.headers.get("StackShift-Signature"),
+    timestamp_header=request.headers.get("StackShift-Timestamp"),
+    secret=os.environ["STACKSHIFT_WEBHOOK_SECRET"],
+)
+```
+
+Webhook handlers should be idempotent. StackShift retries non-2xx responses. Delivery events do not include full email bodies or OTP codes by default.
+
+## Send a template
+
+Templates are rendered by StackShift servers. The Python SDK only calls the REST API.
+
+```python
+stackshift.mail.templates.create(
+    name="Welcome Email",
+    slug="welcome-email",
+    subject="Welcome, {{name}}",
+    text="Welcome, {{name}}",
+)
+
+preview = stackshift.mail.templates.preview(
+    "welcome-email",
+    data={"name": "Ada"},
+)
+
+message = stackshift.mail.send_template(
+    template="welcome-email",
+    to="ada@example.com",
+    from_="Acme <noreply@acme.com>",
+    data={"name": "Ada"},
+    idempotency_key="welcome:user_123",
+)
+```
+
+Missing variables fail before a message is queued. Template sends use the same sender-domain, suppression, idempotency, Durable Jobs, and Postfix handoff pipeline as `mail.send`.
+
+## Bounces and suppressions
+
+```python
+suppressions = stackshift.mail.suppressions.list()
+
+manual = stackshift.mail.suppressions.create(
+    email="bad@example.com",
+    reason="manual",
+)
+
+stackshift.mail.suppressions.delete(manual["id"])
+
+bounces = stackshift.mail.bounces.list(type="hard")
+message_bounces = stackshift.mail.messages.bounces("msg_123")
+```
+
+Hard bounces are automatically suppressed by the backend. Suppressions are workspace scoped and checked before a message is queued.
+
+## Verify a sending domain
+
+```python
+domain = stackshift.mail.domains.create("acme.com")
+print(domain["records"])
+
+stackshift.mail.domains.verify(domain["id"])
+
+message = stackshift.mail.send(
+    from_="Acme <noreply@acme.com>",
+    to="user@example.com",
+    subject="Welcome",
+    html="<h1>Welcome</h1>",
+    text="Welcome",
+)
+```
+
+Add the returned SPF, DKIM, and return-path DNS records before verification. DMARC is recommended unless your environment sets `MAIL_DMARC_REQUIRED=true`. DNS propagation can take time.
+
+## Upload an asset
+
+```python
+from stackshift import StackShift
+
+stackshift = StackShift()
+
+asset = stackshift.assets.upload(
+    "avatar.png",
+    folder="avatars",
+    visibility="public",
+    metadata={"user_id": "user_123"},
+)
+
+print(asset["url"])
+```
+
+You do not pass a deployed StackShift project ID. The API key identifies the StackShift account, and StackShift resolves the default asset space internally.
+
+## Private asset URL
+
+```python
+signed = stackshift.assets.signed_url(
+    asset["id"],
+    expires_in="10m",
+    max_downloads=1,
+)
+
+print(signed["url"])
+```
+
+## Image transformations
+
+Use built-in presets or create your own named transformations.
+
+```python
+from stackshift import StackShift, asset_transform_options, get_asset_transform_preset
+
+stackshift = StackShift()
+hero = get_asset_transform_preset("hero")
+hero_options = asset_transform_options(hero)
+
+stackshift.assets.create_transformation(hero["name"], **hero_options)
+
+named = stackshift.assets.named_url("asset_123", hero["name"])
+signed = stackshift.assets.signed_transform_url("asset_123", **hero_options, expiresIn="10m")
+
+stackshift.assets.delete_transformation("old-preset")
+print(named, signed["url"])
+```
+
+## Direct browser uploads
+
+Create the upload session on your Python backend:
+
+```python
+upload = stackshift.assets.signed_upload_url(
+    bucket="avatars",
+    key="users/user_123.png",
+    visibility="public",
+    expiresIn="10m",
+    maxBytes=5_000_000,
+)
+```
+
+Then upload the browser `File` to `upload["url"]` from your frontend. Do not expose your StackShift API key to browser code.
+
+The SDK only talks to the StackShift REST API. Storage placement, replication, disks, and repair are StackShift internals.
+
+### Campaign drafts and engagement
+
+`mail.campaigns.create(content={...})` accepts a private campaign content snapshot; template/version inputs still work. Save the complete draft with `update(id, revision=revision, **draft)` (draft keys use API camelCase). `preview`, `test`, `send(id, revision=revision)`, and `schedule(id, send_at, revision=revision)` protect the reviewed content. Stale revisions return 409.
+
+Send methods accept `tracking={"opens": False, "clicks": True}`. Omitted fields inherit workspace defaults. `mail.tracking` exposes `settings`, `update_settings`, `message`, `campaign`, and branded-domain methods. Deployment capability flags control availability. Opens are approximate; detailed activity expires after 90 days. OTPs and tests never track.
+
+### Isolated testing, brands, migration, and spending
+
+Use a `sspat_test_` credential and `simulation={"scenario": "delayed"}` for a 60-second simulated delay. Delivered, bounced, and complained outcomes are also supported. Test resources are isolated; no real email is delivered.
+
+```python
+brand = client.mail.brands.create(name="Product", editable_fields=["company"])
+audience = client.mail.audiences.create(brand_id=brand["id"], name="Product news")
+```
+
+Audience creation requires an explicit `brand_id`. Shared profile fields belong to the brand; consent stays per audience. `mail.automations`, `mail.forms`, and `mail.segments` expose create/list methods; their input dictionaries use API camelCase keys.
+
+`mail.migration` supports public DNS audits/plans and authenticated checklists. `mail.billing.summary()` and `mail.campaigns.estimate(id)` expose allowance and credit. Pass `approved_max_kobo=0` (or another approved maximum) alongside `revision` when sending/scheduling campaigns. Billing remains inactive until a rate card is explicitly published and activated; funding and spending opt-in are separate owner-only dashboard actions.
+
+## Native video, governed DAM and product rendering
+
+Use the space-scoped DAM and video clients for collaborators, metadata schemas, bucket governance, reviewed publications, picker capabilities, model preparation, product rendering, galleries, version-pinned encoding, captions and playback sessions.
+
+```python
+dam = sdk.assets.dam.for_space(space_id)
+video = sdk.assets.video.for_space(space_id)
+schema = dam.create_metadata_schema({"name": "Products", "fields": [{
+    "key": "product_name", "label": "Product name", "type": "text", "required": True,
+}]})
+published = dam.publish_metadata_schema(schema["id"], schema["revision"])
+workspace = video.workspace(asset_id)
+```
+
+Mutations carry the supplied revision in `If-Match`. Model preparation and rendering carry an idempotency key; render submission also carries the accepted maximum units. Playback renewal and events authenticate with the session credential, not the account key. Keep these clients on your backend and return grants with `Cache-Control: private, no-store`.
+
+See the [Assets SDK guide](https://docs.stackshift.cloud/assets/sdk-media-workflows) and its linked feature guides for complete language examples, inputs, permissions, review transitions and browser callbacks.

{stackshift-1.0.0 → stackshift-1.1.0}/README.md

@@ -205,3 +205,40 @@ upload = stackshift.assets.signed_upload_url(
 Then upload the browser `File` to `upload["url"]` from your frontend. Do not expose your StackShift API key to browser code.
 
 The SDK only talks to the StackShift REST API. Storage placement, replication, disks, and repair are StackShift internals.
+
+### Campaign drafts and engagement
+
+`mail.campaigns.create(content={...})` accepts a private campaign content snapshot; template/version inputs still work. Save the complete draft with `update(id, revision=revision, **draft)` (draft keys use API camelCase). `preview`, `test`, `send(id, revision=revision)`, and `schedule(id, send_at, revision=revision)` protect the reviewed content. Stale revisions return 409.
+
+Send methods accept `tracking={"opens": False, "clicks": True}`. Omitted fields inherit workspace defaults. `mail.tracking` exposes `settings`, `update_settings`, `message`, `campaign`, and branded-domain methods. Deployment capability flags control availability. Opens are approximate; detailed activity expires after 90 days. OTPs and tests never track.
+
+### Isolated testing, brands, migration, and spending
+
+Use a `sspat_test_` credential and `simulation={"scenario": "delayed"}` for a 60-second simulated delay. Delivered, bounced, and complained outcomes are also supported. Test resources are isolated; no real email is delivered.
+
+```python
+brand = client.mail.brands.create(name="Product", editable_fields=["company"])
+audience = client.mail.audiences.create(brand_id=brand["id"], name="Product news")
+```
+
+Audience creation requires an explicit `brand_id`. Shared profile fields belong to the brand; consent stays per audience. `mail.automations`, `mail.forms`, and `mail.segments` expose create/list methods; their input dictionaries use API camelCase keys.
+
+`mail.migration` supports public DNS audits/plans and authenticated checklists. `mail.billing.summary()` and `mail.campaigns.estimate(id)` expose allowance and credit. Pass `approved_max_kobo=0` (or another approved maximum) alongside `revision` when sending/scheduling campaigns. Billing remains inactive until a rate card is explicitly published and activated; funding and spending opt-in are separate owner-only dashboard actions.
+
+## Native video, governed DAM and product rendering
+
+Use the space-scoped DAM and video clients for collaborators, metadata schemas, bucket governance, reviewed publications, picker capabilities, model preparation, product rendering, galleries, version-pinned encoding, captions and playback sessions.
+
+```python
+dam = sdk.assets.dam.for_space(space_id)
+video = sdk.assets.video.for_space(space_id)
+schema = dam.create_metadata_schema({"name": "Products", "fields": [{
+    "key": "product_name", "label": "Product name", "type": "text", "required": True,
+}]})
+published = dam.publish_metadata_schema(schema["id"], schema["revision"])
+workspace = video.workspace(asset_id)
+```
+
+Mutations carry the supplied revision in `If-Match`. Model preparation and rendering carry an idempotency key; render submission also carries the accepted maximum units. Playback renewal and events authenticate with the session credential, not the account key. Keep these clients on your backend and return grants with `Cache-Control: private, no-store`.
+
+See the [Assets SDK guide](https://docs.stackshift.cloud/assets/sdk-media-workflows) and its linked feature guides for complete language examples, inputs, permissions, review transitions and browser callbacks.

{stackshift-1.0.0 → stackshift-1.1.0}/pyproject.toml

@@ -4,8 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "stackshift"
-version = "1.0.0"
+version = "1.1.0"
 description = "Official Python SDK for StackShift."
+readme = "README.md"
 requires-python = ">=3.9"
 dependencies = ["requests>=2.31"]
 

{stackshift-1.0.0 → stackshift-1.1.0}/stackshift/__init__.py

@@ -13,6 +13,7 @@ from .mail_streams import MailStreamsClient
 from .mail_campaigns import MailAudiencesClient, MailCampaignsClient
 from .mail_exports import MailExportsClient
 from .projects import ProjectsClient
+from .workload_security import WorkloadSecurityClient
 
 __all__ = [
     "StackShift",
@@ -33,6 +34,7 @@ __all__ = [
     "MailCampaignsClient",
     "MailExportsClient",
     "ProjectsClient",
+    "WorkloadSecurityClient",
     "asset_transform_options",
     "asset_transform_spec",
     "get_asset_transform_preset",

{stackshift-1.0.0 → stackshift-1.1.0}/stackshift/assets.py

@@ -6,6 +6,10 @@ from pathlib import Path
 from typing import Any, BinaryIO
 from urllib.parse import quote
 
+from .assets_workflows import AssetWorkflowsMixin
+from .assets_dam import AssetDAMClient
+from .assets_video import AssetVideoClient
+
 
 ASSET_TRANSFORM_PRESETS: list[dict[str, Any]] = [
     {"id": "web-thumbnail", "name": "web-thumbnail", "category": "responsive-web", "description": "Compact grid thumbnail for libraries and dashboards.", "width": 320, "height": 180, "crop": "fill", "format": "webp", "quality": 78},
@@ -47,9 +51,11 @@ def asset_transform_spec(**options: Any) -> str:
     return _transform_spec(options)
 
 
-class AssetsClient:
+class AssetsClient(AssetWorkflowsMixin):
     def __init__(self, client: Any) -> None:
         self._client = client
+        self.dam = AssetDAMClient(client)
+        self.video = AssetVideoClient(client)
 
     def upload(
         self,

stackshift-1.1.0/stackshift/assets_dam.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from .assets_media import AssetMediaClient
+
+
+class AssetDAMClient(AssetMediaClient):
+    def spaces(self):
+        return self._request("GET", f"/assets/spaces")
+
+    def collaborators(self):
+        return self._request("GET", f"/assets/collaborators")
+
+    def invite(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/collaborators", body=input)
+
+    def accept_invitation(self, id: str):
+        return self._request("POST", f"/assets/invitations/{quote(id, safe='')}/accept")
+
+    def update_collaborator(self, id: str, revision: int, actions: list[str]):
+        return self._request(
+            "PUT",
+            f"/assets/collaborators/{quote(id, safe='')}",
+            body={"actions": actions},
+            revision=revision,
+        )
+
+    def revoke_collaborator(self, id: str, revision: int):
+        return self._request(
+            "DELETE", f"/assets/collaborators/{quote(id, safe='')}", revision=revision
+        )
+
+    def metadata_schemas(self):
+        return self._request("GET", f"/assets/metadata-schemas")
+
+    def metadata_editor(self, asset_id: str):
+        return self._request(
+            "GET", f"/assets/{quote(asset_id, safe='')}/metadata-editor"
+        )
+
+    def create_metadata_schema(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/metadata-schemas", body=input)
+
+    def update_metadata_schema(self, id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "PUT",
+            f"/assets/metadata-schemas/{quote(id, safe='')}",
+            body=input,
+            revision=revision,
+        )
+
+    def publish_metadata_schema(self, id: str, revision: int):
+        return self._request(
+            "POST",
+            f"/assets/metadata-schemas/{quote(id, safe='')}/publish",
+            revision=revision,
+        )
+
+    def bucket_governance(self, id: str):
+        return self._request("GET", f"/assets/buckets/{quote(id, safe='')}/governance")
+
+    def save_bucket_governance(self, id: str, input: dict[str, Any]):
+        return self._request(
+            "PUT", f"/assets/buckets/{quote(id, safe='')}/governance", body=input
+        )
+
+    def migrate_bucket_governance(self, id: str, revision: int):
+        return self._request(
+            "POST",
+            f"/assets/buckets/{quote(id, safe='')}/governance/migrate",
+            revision=revision,
+        )
+
+    def publications(self, query: dict[str, Any] | None = None):
+        return self._request("GET", f"/assets/publications", query=query)
+
+    def publication_renditions(self, asset_id: str):
+        return self._request(
+            "GET", f"/assets/{quote(asset_id, safe='')}/publication-renditions"
+        )
+
+    def create_publication(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/publications", body=input)
+
+    def update_publication(self, id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "PUT",
+            f"/assets/publications/{quote(id, safe='')}",
+            body=input,
+            revision=revision,
+        )
+
+    def transition_publication(self, id: str, revision: int, action: str, note: str):
+        return self._request(
+            "POST",
+            f"/assets/publications/{quote(id, safe='')}/{quote(action, safe='')}",
+            body={"note": note},
+            revision=revision,
+        )
+
+    def resolve_publication(self, id: str):
+        return self._request(
+            "GET", f"/assets/publications/{quote(id, safe='')}/resolve"
+        )
+
+    def preview_publication(self, id: str):
+        return self._request(
+            "GET", f"/assets/publications/{quote(id, safe='')}/preview"
+        )
+
+    def resolve_publication_ar(self, id: str):
+        return self._request("POST", f"/assets/publications/{quote(id, safe='')}/ar")
+
+    def create_picker_capability(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/picker-capabilities", body=input)
+
+    def revoke_picker_capability(self, id: str):
+        return self._request(
+            "DELETE", f"/assets/picker-capabilities/{quote(id, safe='')}"
+        )
+
+    def models(self, asset_id: str):
+        return self._request("GET", f"/assets/{quote(asset_id, safe='')}/models")
+
+    def estimate_render(self, asset_id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/models",
+            body={**input, "operation": "estimate"},
+            revision=revision,
+        )
+
+    def render_product(
+        self,
+        asset_id: str,
+        revision: int,
+        idempotency_key: str,
+        input: dict[str, Any],
+        maximum_units: int,
+    ):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/models",
+            body={**input, "operation": "render", "maximum_units": maximum_units},
+            revision=revision,
+            idempotency_key=idempotency_key,
+        )
+
+    def process_model(self, asset_id: str, revision: int, idempotency_key: str):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/models",
+            revision=revision,
+            idempotency_key=idempotency_key,
+        )
+
+    def galleries(self, query: dict[str, Any] | None = None):
+        return self._request("GET", f"/assets/galleries", query=query)
+
+    def create_gallery(self, input: dict[str, Any]):
+        return self._request("POST", f"/assets/galleries", body=input)
+
+    def update_gallery(self, id: str, revision: int, input: dict[str, Any]):
+        return self._request(
+            "PUT",
+            f"/assets/galleries/{quote(id, safe='')}",
+            body=input,
+            revision=revision,
+        )
+
+    def transition_gallery(self, id: str, revision: int, action: str):
+        return self._request(
+            "POST",
+            f"/assets/galleries/{quote(id, safe='')}/{quote(action, safe='')}",
+            revision=revision,
+        )
+
+    def resolve_gallery(self, id: str):
+        return self._request("GET", f"/assets/galleries/{quote(id, safe='')}/resolve")
+
+    def preview_gallery(self, id: str):
+        return self._request(
+            "GET", f"/assets/galleries/{quote(id, safe='')}/resolve?preview=true"
+        )
+
+    def resolve_gallery_ar(self, id: str, publication_id: str):
+        return self._request(
+            "POST",
+            f"/assets/galleries/{quote(id, safe='')}/ar",
+            body={"publication_id": publication_id},
+        )

stackshift-1.1.0/stackshift/assets_media.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import urlsplit
+
+
+class AssetMediaClient:
+    def __init__(self, client: Any, space_id: str = "") -> None:
+        self._client = client
+        self._space_id = space_id
+
+    def for_space(self, space_id: str):
+        return type(self)(self._client, space_id)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body=None,
+        revision=None,
+        idempotency_key=None,
+        query=None,
+    ):
+        headers = {}
+        if self._space_id:
+            headers["X-Asset-Space-ID"] = self._space_id
+        if revision is not None:
+            headers["If-Match"] = f'"{revision}"'
+        if idempotency_key is not None:
+            headers["Idempotency-Key"] = idempotency_key
+        return self._client.request(
+            method, path, json=body, headers=headers, params=query
+        )
+
+    def _playback(self, path: str, credential: str, body: dict[str, Any]):
+        from .client import StackShift
+
+        if not credential.strip():
+            raise ValueError("Playback credential is required")
+        base = urlsplit(self._client.base_url)
+        # A separate client prevents account authentication from replacing the session credential.
+        playback = StackShift(
+            api_key=credential,
+            base_url=f"{base.scheme}://{base.netloc}",
+            session=self._client.session,
+        )
+        return playback.request("POST", "/playback" + path, json=body)

stackshift-1.1.0/stackshift/assets_video.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from typing import Any
+from urllib.parse import quote
+
+from .assets_media import AssetMediaClient
+
+
+class AssetVideoClient(AssetMediaClient):
+    def workspace(self, asset_id: str):
+        return self._request("GET", f"/assets/{quote(asset_id, safe='')}/video")
+
+    def process(self, asset_id: str, version_id: str):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video",
+        )
+
+    def create_session(self, asset_id: str):
+        return self._request(
+            "POST", f"/assets/{quote(asset_id, safe='')}/playback-sessions"
+        )
+
+    def revoke_session(self, asset_id: str, session_id: str):
+        return self._request(
+            "DELETE",
+            f"/assets/{quote(asset_id, safe='')}/playback-sessions/{quote(session_id, safe='')}",
+        )
+
+    def captions(self, asset_id: str, version_id: str):
+        return self._request(
+            "GET",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/captions",
+        )
+
+    def add_caption(self, asset_id: str, version_id: str, input: dict[str, Any]):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/captions",
+            body=input,
+        )
+
+    def remove_caption(self, asset_id: str, version_id: str, caption_id: str):
+        return self._request(
+            "DELETE",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/captions/{quote(caption_id, safe='')}",
+        )
+
+    def review(self, asset_id: str, version_id: str, decision: str, reason: str):
+        return self._request(
+            "POST",
+            f"/assets/{quote(asset_id, safe='')}/versions/{quote(version_id, safe='')}/video/review",
+            body={"decision": decision, "reason": reason},
+        )
+
+    def analytics(self, asset_id: str):
+        return self._request(
+            "GET", f"/assets/{quote(asset_id, safe='')}/video/analytics"
+        )
+
+    def renew_session(self, credential: str):
+        return self._playback("/sessions/renew", credential, {})
+
+    def events(self, credential: str, events: list[dict[str, Any]]):
+        return self._playback("/events", credential, {"events": events})