# Xovris API client for Python - generated from the public OpenAPI document version 0.1.0. MIT licence, Copyright (c) 2026 Xovris.
# Usage: xovris = Xovris()  # reads XOVRIS_API_KEY
import json
import os
import urllib.error
import urllib.parse
import urllib.request
import uuid


def _q(value):
    return urllib.parse.quote(str(value), safe="")


class XovrisError(Exception):
    def __init__(self, status, code, message, next_step):
        super().__init__(message)
        self.status, self.code, self.next_step = status, code, next_step


class Xovris:
    def __init__(self, api_key=None, base_url=None, timeout=30):
        self._key = api_key or os.environ.get("XOVRIS_API_KEY")
        if not self._key:
            raise ValueError("Set XOVRIS_API_KEY, or pass api_key. Make a key in Settings, Developers.")
        self._base = (base_url or os.environ.get("XOVRIS_BASE_URL") or "https://api.xovris.ai").rstrip("/")
        self._timeout = timeout

    def _call(self, method, path, body=None, query=None, idempotency_key=None):
        url = self._base + path
        if query:
            url += "?" + urllib.parse.urlencode({k: v for k, v in query.items() if v is not None})
        headers = {"Authorization": "Bearer " + self._key, "Accept": "application/json"}
        data = None
        if body is not None:
            data = json.dumps(body).encode("utf-8")
            headers["Content-Type"] = "application/json"
        if method != "GET":
            headers["Idempotency-Key"] = idempotency_key or str(uuid.uuid4())
        req = urllib.request.Request(url, data=data, headers=headers, method=method)
        try:
            with urllib.request.urlopen(req, timeout=self._timeout) as res:
                text = res.read().decode("utf-8")
                return json.loads(text) if text else None
        except urllib.error.HTTPError as e:
            text = e.read().decode("utf-8")
            try:
                err = json.loads(text) if text else {}
            except ValueError:
                err = {}
            inner = err.get("error") or {}
            raise XovrisError(e.code, inner.get("code"), inner.get("message") or err.get("detail") or "The API answered %d." % e.code, inner.get("nextStep") or err.get("next")) from None

    def delete_access_level_connections_by_scope(self, scope, body=None, idempotency_key=None):
        """Put one connection back on the workspace's own level of access (DELETE /v1/access/level/connections/{scope})"""
        return self._call("DELETE", f"/v1/access/level/connections/{_q(scope)}", body=body, idempotency_key=idempotency_key)

    def delete_account_sessions_by_id(self, id_, body=None, idempotency_key=None):
        """Sign one of your sessions out (DELETE /v1/account/sessions/{id})"""
        return self._call("DELETE", f"/v1/account/sessions/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_alert_actions_by_id_rules_by_rule_id(self, id_, rule_id, body=None, idempotency_key=None):
        """Stop an alert rule calling an action (DELETE /v1/alert-actions/{id}/rules/{ruleId})"""
        return self._call("DELETE", f"/v1/alert-actions/{_q(id_)}/rules/{_q(rule_id)}", body=body, idempotency_key=idempotency_key)

    def delete_alerts_mail_server(self, body=None, idempotency_key=None):
        """Alert and status email by Xovris's own path again (DELETE /v1/alerts/mail-server)"""
        return self._call("DELETE", f"/v1/alerts/mail-server", body=body, idempotency_key=idempotency_key)

    def delete_alerts_sending_domain(self, body=None, idempotency_key=None):
        """Alert and status email from Xovris's own address again (DELETE /v1/alerts/sending-domain)"""
        return self._call("DELETE", f"/v1/alerts/sending-domain", body=body, idempotency_key=idempotency_key)

    def delete_assets_by_id(self, id_, body=None, idempotency_key=None):
        """Stop watching a website, with an undo (DELETE /v1/assets/{id})"""
        return self._call("DELETE", f"/v1/assets/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_assist_memory_by_key(self, key, body=None, idempotency_key=None):
        """Make Xovris forget something (DELETE /v1/assist/memory/{key})"""
        return self._call("DELETE", f"/v1/assist/memory/{_q(key)}", body=body, idempotency_key=idempotency_key)

    def delete_assist_requests_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a conversation for good, with a signed receipt (DELETE /v1/assist/requests/{id})"""
        return self._call("DELETE", f"/v1/assist/requests/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_assist_requests_by_id_share(self, id_, body=None, idempotency_key=None):
        """Withdraw a conversation's share link, so it no longer opens (DELETE /v1/assist/requests/{id}/share)"""
        return self._call("DELETE", f"/v1/assist/requests/{_q(id_)}/share", body=body, idempotency_key=idempotency_key)

    def delete_board_tiles_by_id(self, id_, body=None, idempotency_key=None):
        """Take a tile off your dashboard (DELETE /v1/board/tiles/{id})"""
        return self._call("DELETE", f"/v1/board/tiles/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_checks_by_id_promise_alerts_by_alert_id(self, id_, alert_id, body=None, idempotency_key=None):
        """Stop one alert on a check's promise (DELETE /v1/checks/{id}/promise/alerts/{alertId})"""
        return self._call("DELETE", f"/v1/checks/{_q(id_)}/promise/alerts/{_q(alert_id)}", body=body, idempotency_key=idempotency_key)

    def delete_checks_by_id_promise_corrections_by_correction_id(self, id_, correction_id, body=None, idempotency_key=None):
        """Remove a correction from a check's promise, so the window counts again (DELETE /v1/checks/{id}/promise/corrections/{correctionId})"""
        return self._call("DELETE", f"/v1/checks/{_q(id_)}/promise/corrections/{_q(correction_id)}", body=body, idempotency_key=idempotency_key)

    def delete_cloud_connections_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect a cloud account (DELETE /v1/cloud/connections/{id})"""
        return self._call("DELETE", f"/v1/cloud/connections/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_code_previews_by_token_by_path(self, token, path, body=None, idempotency_key=None):
        """Remove something through a build's own app while it is being made (DELETE /v1/code/previews/{token}/{path})"""
        return self._call("DELETE", f"/v1/code/previews/{_q(token)}/{_q(path)}", body=body, idempotency_key=idempotency_key)

    def delete_code_projects_by_id_analytics(self, id_, body=None, idempotency_key=None):
        """Delete the visit figures Xovris kept for a build's site (DELETE /v1/code/projects/{id}/analytics)"""
        return self._call("DELETE", f"/v1/code/projects/{_q(id_)}/analytics", body=body, idempotency_key=idempotency_key)

    def delete_code_projects_by_id_domains_by_domain(self, id_, domain, body=None, idempotency_key=None):
        """Take a build's site off one of your domains (DELETE /v1/code/projects/{id}/domains/{domain})"""
        return self._call("DELETE", f"/v1/code/projects/{_q(id_)}/domains/{_q(domain)}", body=body, idempotency_key=idempotency_key)

    def delete_code_projects_by_id_resources_by_kind(self, id_, kind, body=None, idempotency_key=None):
        """Switch off a part a build runs on, and remove what it held (DELETE /v1/code/projects/{id}/resources/{kind})"""
        return self._call("DELETE", f"/v1/code/projects/{_q(id_)}/resources/{_q(kind)}", body=body, idempotency_key=idempotency_key)

    def delete_code_projects_by_id_secrets_by_name(self, id_, name, body=None, idempotency_key=None):
        """Remove a secret a build was given (DELETE /v1/code/projects/{id}/secrets/{name})"""
        return self._call("DELETE", f"/v1/code/projects/{_q(id_)}/secrets/{_q(name)}", body=body, idempotency_key=idempotency_key)

    def delete_code_shared_by_token_preview_by_path(self, token, path, body=None, idempotency_key=None):
        """Remove something through a shared build's own app (DELETE /v1/code/shared/{token}/preview/{path})"""
        return self._call("DELETE", f"/v1/code/shared/{_q(token)}/preview/{_q(path)}", body=body, idempotency_key=idempotency_key)

    def delete_code_sites_by_token_by_path(self, token, path, body=None, idempotency_key=None):
        """Remove something through the app a build deployed (DELETE /v1/code/sites/{token}/{path})"""
        return self._call("DELETE", f"/v1/code/sites/{_q(token)}/{_q(path)}", body=body, idempotency_key=idempotency_key)

    def delete_code_tasks_by_id_shares_by_share(self, id_, share, body=None, idempotency_key=None):
        """Stop a build's shared link from working (DELETE /v1/code/tasks/{id}/shares/{share})"""
        return self._call("DELETE", f"/v1/code/tasks/{_q(id_)}/shares/{_q(share)}", body=body, idempotency_key=idempotency_key)

    def delete_computers_by_id(self, id_, body=None, idempotency_key=None):
        """End a desktop and everything on it (DELETE /v1/computers/{id})"""
        return self._call("DELETE", f"/v1/computers/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_computer_schedules_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a schedule (DELETE /v1/computer/schedules/{id})"""
        return self._call("DELETE", f"/v1/computer/schedules/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_computer_sessions_by_id_files(self, id_, body=None, idempotency_key=None):
        """Every file the session downloaded, deleted in one press (DELETE /v1/computer/sessions/{id}/files)"""
        return self._call("DELETE", f"/v1/computer/sessions/{_q(id_)}/files", body=body, idempotency_key=idempotency_key)

    def delete_computer_sessions_by_id_replay(self, id_, body=None, idempotency_key=None):
        """Delete every screen kept of a session you ran - its steps and their reasons stay, and the replay says when they went (DELETE /v1/computer/sessions/{id}/replay)"""
        return self._call("DELETE", f"/v1/computer/sessions/{_q(id_)}/replay", body=body, idempotency_key=idempotency_key)

    def delete_computers_sign_ins(self, body=None, idempotency_key=None):
        """Forget the sign-ins Xovris's own computer kept for you - your next session starts signed out (DELETE /v1/computers/sign-ins)"""
        return self._call("DELETE", f"/v1/computers/sign-ins", body=body, idempotency_key=idempotency_key)

    def delete_connections_figma(self, body=None, idempotency_key=None):
        """Unlink Figma from this workspace (DELETE /v1/connections/figma)"""
        return self._call("DELETE", f"/v1/connections/figma", body=body, idempotency_key=idempotency_key)

    def delete_dashboards_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a dashboard; its address reads as not found from then on (DELETE /v1/dashboards/{id})"""
        return self._call("DELETE", f"/v1/dashboards/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_dashboards_by_id_panels_by_panel_id_silence(self, id_, panel_id, body=None, idempotency_key=None):
        """Turn a dashboard panel's alerts back on (DELETE /v1/dashboards/{id}/panels/{panelId}/silence)"""
        return self._call("DELETE", f"/v1/dashboards/{_q(id_)}/panels/{_q(panel_id)}/silence", body=body, idempotency_key=idempotency_key)

    def delete_dashboards_by_id_reports_by_report_id(self, id_, report_id, body=None, idempotency_key=None):
        """Stop a scheduled report (DELETE /v1/dashboards/{id}/reports/{reportId})"""
        return self._call("DELETE", f"/v1/dashboards/{_q(id_)}/reports/{_q(report_id)}", body=body, idempotency_key=idempotency_key)

    def delete_dashboards_by_id_shares_by_share_id(self, id_, share_id, body=None, idempotency_key=None):
        """Switch off a shared link (DELETE /v1/dashboards/{id}/shares/{shareId})"""
        return self._call("DELETE", f"/v1/dashboards/{_q(id_)}/shares/{_q(share_id)}", body=body, idempotency_key=idempotency_key)

    def delete_devices_enrolment_codes_by_code(self, code, body=None, idempotency_key=None):
        """End a device code you made and no longer want - it enrols nothing and its download stops (DELETE /v1/devices/enrolment-codes/{code})"""
        return self._call("DELETE", f"/v1/devices/enrolment-codes/{_q(code)}", body=body, idempotency_key=idempotency_key)

    def delete_devices_groups_by_group_id(self, group_id, body=None, idempotency_key=None):
        """Remove a device group - the devices in it are kept (DELETE /v1/devices/groups/{groupId})"""
        return self._call("DELETE", f"/v1/devices/groups/{_q(group_id)}", body=body, idempotency_key=idempotency_key)

    def delete_doors_extension_by_id(self, id_, body=None, idempotency_key=None):
        """Unpair a browser from the Xovris extension (DELETE /v1/doors/extension/{id})"""
        return self._call("DELETE", f"/v1/doors/extension/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_extensions_apps_by_app_id(self, app_id, body=None, idempotency_key=None):
        """Remove an app (DELETE /v1/extensions/apps/{appId})"""
        return self._call("DELETE", f"/v1/extensions/apps/{_q(app_id)}", body=body, idempotency_key=idempotency_key)

    def delete_failover_targets_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a standby target (DELETE /v1/failover-targets/{id})"""
        return self._call("DELETE", f"/v1/failover-targets/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_grants_by_id(self, id_, body=None, idempotency_key=None):
        """Take back one standing permission - Xovris stops using it at once (DELETE /v1/grants/{id})"""
        return self._call("DELETE", f"/v1/grants/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_helper_website_conversations_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a conversation carried from the website (DELETE /v1/helper/website-conversations/{id})"""
        return self._call("DELETE", f"/v1/helper/website-conversations/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_home_network_known_by_device(self, device, body=None, idempotency_key=None):
        """Watch a device you had marked as yours again (DELETE /v1/home-network/known/{device})"""
        return self._call("DELETE", f"/v1/home-network/known/{_q(device)}", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_ack(self, id_, body=None, idempotency_key=None):
        """Take back an acknowledgement (DELETE /v1/incidents/{id}/ack)"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/ack", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_merge(self, id_, body=None, idempotency_key=None):
        """Undo a merge (DELETE /v1/incidents/{id}/merge)"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/merge", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_mute(self, id_, body=None, idempotency_key=None):
        """Send an incident's messages again (DELETE /v1/incidents/{id}/mute)"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/mute", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_pin(self, id_, body=None, idempotency_key=None):
        """Take your pin off an incident (DELETE /v1/incidents/{id}/pin)"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/pin", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_snooze(self, id_, body=None, idempotency_key=None):
        """Wake a snoozed incident (DELETE /v1/incidents/{id}/snooze)"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/snooze", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_stakeholders_by_key(self, id_, key, body=None, idempotency_key=None):
        """Stop telling someone about an incident (DELETE /v1/incidents/{id}/stakeholders/{key})"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/stakeholders/{_q(key)}", body=body, idempotency_key=idempotency_key)

    def delete_incidents_by_id_watch(self, id_, body=None, idempotency_key=None):
        """Stop watching an incident (DELETE /v1/incidents/{id}/watch)"""
        return self._call("DELETE", f"/v1/incidents/{_q(id_)}/watch", body=body, idempotency_key=idempotency_key)

    def delete_issues_by_id_ask(self, id_, body=None, idempotency_key=None):
        """Withdraw a question asked on an issue, so it returns to the queue (DELETE /v1/issues/{id}/ask)"""
        return self._call("DELETE", f"/v1/issues/{_q(id_)}/ask", body=body, idempotency_key=idempotency_key)

    def delete_log_connections_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a log source, with what Xovris made at the provider deleted first (DELETE /v1/log-connections/{id})"""
        return self._call("DELETE", f"/v1/log-connections/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_mcp(self, body=None, idempotency_key=None):
        """End an MCP session (DELETE /v1/mcp)"""
        return self._call("DELETE", f"/v1/mcp", body=body, idempotency_key=idempotency_key)

    def delete_members_by_user_id(self, user_id, body=None, idempotency_key=None):
        """Remove a member (DELETE /v1/members/{userId})"""
        return self._call("DELETE", f"/v1/members/{_q(user_id)}", body=body, idempotency_key=idempotency_key)

    def delete_members_invitations_by_id(self, id_, body=None, idempotency_key=None):
        """Withdraw an open invitation before it is accepted (DELETE /v1/members/invitations/{id})"""
        return self._call("DELETE", f"/v1/members/invitations/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_models_own(self, body=None, idempotency_key=None):
        """Remove your own model; Xovris plans code fixes on its own models again (DELETE /v1/models/own)"""
        return self._call("DELETE", f"/v1/models/own", body=body, idempotency_key=idempotency_key)

    def delete_oauth_apps_by_id(self, id_, body=None, idempotency_key=None):
        """Retire an OAuth app everywhere it is allowed (DELETE /v1/oauth/apps/{id})"""
        return self._call("DELETE", f"/v1/oauth/apps/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_partners_sandbox_keys_by_id(self, id_, body=None, idempotency_key=None):
        """Revoke a provisioning sandbox key (DELETE /v1/partners/sandbox-keys/{id})"""
        return self._call("DELETE", f"/v1/partners/sandbox-keys/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_queries_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a saved query (DELETE /v1/queries/{id})"""
        return self._call("DELETE", f"/v1/queries/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_reviews_chats_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect a Discord or Google Chat app (DELETE /v1/reviews/chats/{id})"""
        return self._call("DELETE", f"/v1/reviews/chats/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_reviews_hosts_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect a Git host, with Xovris's webhooks taken off it (DELETE /v1/reviews/hosts/{id})"""
        return self._call("DELETE", f"/v1/reviews/hosts/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_reviews_preferences_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a code review preference you set (DELETE /v1/reviews/preferences/{id})"""
        return self._call("DELETE", f"/v1/reviews/preferences/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_reviews_schedules_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a scheduled coding automation; nothing more is started by it (DELETE /v1/reviews/schedules/{id})"""
        return self._call("DELETE", f"/v1/reviews/schedules/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_reviews_tracker(self, body=None, idempotency_key=None):
        """Disconnect the workspace's tracker; its sealed token is deleted (DELETE /v1/reviews/tracker)"""
        return self._call("DELETE", f"/v1/reviews/tracker", body=body, idempotency_key=idempotency_key)

    def delete_reviews_views_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a view of the code review findings you saved (DELETE /v1/reviews/views/{id})"""
        return self._call("DELETE", f"/v1/reviews/views/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_role_grants_by_id(self, id_, body=None, idempotency_key=None):
        """Take back a role given over one thing - it leaves on the person's next step (DELETE /v1/role-grants/{id})"""
        return self._call("DELETE", f"/v1/role-grants/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_roles_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a custom role, kept among the deleted roles so it can be restored (DELETE /v1/roles/{id})"""
        return self._call("DELETE", f"/v1/roles/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_rum_external_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a replay tool connection (DELETE /v1/rum/external/{id})"""
        return self._call("DELETE", f"/v1/rum/external/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_scim_v2_groups_by_id(self, id_, body=None, idempotency_key=None):
        """A group removed at the identity provider: a team it made goes with it; a team made here keeps its own people (DELETE /v1/scim/v2/Groups/{id})"""
        return self._call("DELETE", f"/v1/scim/v2/Groups/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_scim_v2_users_by_id(self, id_, body=None, idempotency_key=None):
        """A person deleted at the identity provider loses this workspace at once (DELETE /v1/scim/v2/Users/{id})"""
        return self._call("DELETE", f"/v1/scim/v2/Users/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_searches_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a saved search (DELETE /v1/searches/{id})"""
        return self._call("DELETE", f"/v1/searches/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_security_posture_fixes_by_id_state(self, id_, body=None, idempotency_key=None):
        """Undo your decision about a fix, so it returns to the security queue; the decision stays in its history (DELETE /v1/security/posture/fixes/{id}/state)"""
        return self._call("DELETE", f"/v1/security/posture/fixes/{_q(id_)}/state", body=body, idempotency_key=idempotency_key)

    def delete_security_stack_connections_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect a security tool (DELETE /v1/security-stack/connections/{id})"""
        return self._call("DELETE", f"/v1/security-stack/connections/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_sessions_activities_by_token(self, token, body=None, idempotency_key=None):
        """Stop following a session on the lock screen (DELETE /v1/sessions/activities/{token})"""
        return self._call("DELETE", f"/v1/sessions/activities/{_q(token)}", body=body, idempotency_key=idempotency_key)

    def delete_sessions_devices_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a device from following your sessions (DELETE /v1/sessions/devices/{id})"""
        return self._call("DELETE", f"/v1/sessions/devices/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_settings_busy_periods_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a busy period (DELETE /v1/settings/busy-periods/{id})"""
        return self._call("DELETE", f"/v1/settings/busy-periods/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_settings_calendars_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect a calendar (DELETE /v1/settings/calendars/{id})"""
        return self._call("DELETE", f"/v1/settings/calendars/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_settings_change_windows_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a maintenance window or freeze (DELETE /v1/settings/change-windows/{id})"""
        return self._call("DELETE", f"/v1/settings/change-windows/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_setup_grants_by_id(self, id_, body=None, idempotency_key=None):
        """Revoke a standing permission (DELETE /v1/setup/grants/{id})"""
        return self._call("DELETE", f"/v1/setup/grants/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_setup_takeovers_by_id_evidence(self, id_, body=None, idempotency_key=None):
        """Delete the recordings of a set-up (DELETE /v1/setup/takeovers/{id}/evidence)"""
        return self._call("DELETE", f"/v1/setup/takeovers/{_q(id_)}/evidence", body=body, idempotency_key=idempotency_key)

    def delete_sso_providers_by_provider_id(self, provider_id, body=None, idempotency_key=None):
        """Remove a company sign-in - nobody signs in through it again (DELETE /v1/sso/providers/{providerId})"""
        return self._call("DELETE", f"/v1/sso/providers/{_q(provider_id)}", body=body, idempotency_key=idempotency_key)

    def delete_status_page_domain(self, body=None, idempotency_key=None):
        """Take your status page off your own domain (DELETE /v1/status-page/domain)"""
        return self._call("DELETE", f"/v1/status-page/domain", body=body, idempotency_key=idempotency_key)

    def delete_status_pages_by_id(self, id_, body=None, idempotency_key=None):
        """A status page removed with its followers and its updates; one on the workspace's own hostname is taken off it first (DELETE /v1/status-pages/{id})"""
        return self._call("DELETE", f"/v1/status-pages/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_status_pages_by_id_audiences_by_audience(self, id_, audience, body=None, idempotency_key=None):
        """An audience removed from a private status page - the followers who followed through it alone are mailed no more (DELETE /v1/status-pages/{id}/audiences/{audience})"""
        return self._call("DELETE", f"/v1/status-pages/{_q(id_)}/audiences/{_q(audience)}", body=body, idempotency_key=idempotency_key)

    def delete_systems_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect one system - every reading of it stops at once (DELETE /v1/systems/{id})"""
        return self._call("DELETE", f"/v1/systems/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_systems_general_runs_jobs_by_job_record(self, job, body=None, idempotency_key=None):
        """Forget what one job Xovris did kept about why it acted and how it went about it (DELETE /v1/systems/general-runs/jobs/{job}/record)"""
        return self._call("DELETE", f"/v1/systems/general-runs/jobs/{_q(job)}/record", body=body, idempotency_key=idempotency_key)

    def delete_systems_general_runs_jobs_record(self, body=None, idempotency_key=None):
        """Forget what every job Xovris did kept about why it acted and how it went about it (DELETE /v1/systems/general-runs/jobs/record)"""
        return self._call("DELETE", f"/v1/systems/general-runs/jobs/record", body=body, idempotency_key=idempotency_key)

    def delete_systems_general_runs_learned(self, body=None, idempotency_key=None):
        """Forget what Xovris learned from past jobs on your systems (DELETE /v1/systems/general-runs/learned)"""
        return self._call("DELETE", f"/v1/systems/general-runs/learned", body=body, idempotency_key=idempotency_key)

    def delete_systems_general_runs_learned_by_id(self, id_, body=None, idempotency_key=None):
        """Forget one plan Xovris learned on your systems (DELETE /v1/systems/general-runs/learned/{id})"""
        return self._call("DELETE", f"/v1/systems/general-runs/learned/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_systems_general_runs_memory_rules_by_id(self, id_, body=None, idempotency_key=None):
        """Delete one rule Xovris kept from your corrections (DELETE /v1/systems/general-runs/memory/rules/{id})"""
        return self._call("DELETE", f"/v1/systems/general-runs/memory/rules/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_systems_general_runs_schedules_by_id(self, id_, body=None, idempotency_key=None):
        """Stop a check Xovris runs for you (DELETE /v1/systems/general-runs/schedules/{id})"""
        return self._call("DELETE", f"/v1/systems/general-runs/schedules/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_teams_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a team - its people lose its role on their next step (DELETE /v1/teams/{id})"""
        return self._call("DELETE", f"/v1/teams/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_teams_by_id_people_by_user_id(self, id_, user_id, body=None, idempotency_key=None):
        """Take a member off a team - its role leaves them on their next step (DELETE /v1/teams/{id}/people/{userId})"""
        return self._call("DELETE", f"/v1/teams/{_q(id_)}/people/{_q(user_id)}", body=body, idempotency_key=idempotency_key)

    def delete_things_by_id(self, id_, body=None, idempotency_key=None):
        """Have Xovris forget a thing (DELETE /v1/things/{id})"""
        return self._call("DELETE", f"/v1/things/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_tokens_by_id(self, id_, body=None, idempotency_key=None):
        """Revoke an API token (DELETE /v1/tokens/{id})"""
        return self._call("DELETE", f"/v1/tokens/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_tool_connections_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect a tool (DELETE /v1/tool-connections/{id})"""
        return self._call("DELETE", f"/v1/tool-connections/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_tool_servers_by_id(self, id_, body=None, idempotency_key=None):
        """Disconnect an AI tool server (DELETE /v1/tool-servers/{id})"""
        return self._call("DELETE", f"/v1/tool-servers/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_uploads_by_id(self, id_, body=None, idempotency_key=None):
        """Stop a large file's upload and remove what arrived (DELETE /v1/uploads/{id})"""
        return self._call("DELETE", f"/v1/uploads/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_vendor_fixes_by_id(self, id_, body=None, idempotency_key=None):
        """Withdraw a fix you sent that is not yet proven (DELETE /v1/vendor-fixes/{id})"""
        return self._call("DELETE", f"/v1/vendor-fixes/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_views_by_surface_by_id(self, surface, id_, body=None, idempotency_key=None):
        """Remove a saved view (DELETE /v1/views/{surface}/{id})"""
        return self._call("DELETE", f"/v1/views/{_q(surface)}/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_webhooks_by_id(self, id_, body=None, idempotency_key=None):
        """Remove a webhook (DELETE /v1/webhooks/{id})"""
        return self._call("DELETE", f"/v1/webhooks/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_what_if_by_id(self, id_, body=None, idempotency_key=None):
        """Delete a what-if report; the copy it ran on was already deleted (DELETE /v1/what-if/{id})"""
        return self._call("DELETE", f"/v1/what-if/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def delete_workspace_domains_by_hostname(self, hostname, body=None, idempotency_key=None):
        """Stop serving one of your own domains from this workspace (DELETE /v1/workspace/domains/{hostname})"""
        return self._call("DELETE", f"/v1/workspace/domains/{_q(hostname)}", body=body, idempotency_key=idempotency_key)

    def get_access_level(self, query=None):
        """Read how far Xovris may act on each connection - from observe only to acting by itself (GET /v1/access/level)"""
        return self._call("GET", f"/v1/access/level", query=query)

    def get_access_map(self, query=None):
        """Read who can reach what (GET /v1/access/map)"""
        return self._call("GET", f"/v1/access/map", query=query)

    def get_access_preview(self, query=None):
        """See what a role lets a person do before it is given - their gains, their losses and what they used recently (GET /v1/access/preview)"""
        return self._call("GET", f"/v1/access/preview", query=query)

    def get_access_review(self, query=None):
        """Review who can do what - each person's role beside what they used, with stale and unused access proposed for change (GET /v1/access/review)"""
        return self._call("GET", f"/v1/access/review", query=query)

    def get_account_passkeys(self, query=None):
        """See the passkeys that can sign in to your account (GET /v1/account/passkeys)"""
        return self._call("GET", f"/v1/account/passkeys", query=query)

    def get_account_sessions(self, query=None):
        """See every place your account is signed in (GET /v1/account/sessions)"""
        return self._call("GET", f"/v1/account/sessions", query=query)

    def get_actions(self, query=None):
        """List what Xovris did and why (GET /v1/actions)"""
        return self._call("GET", f"/v1/actions", query=query)

    def get_actions_by_seq_receipt(self, seq, query=None):
        """Take the proof receipt of one change or undo, with the checks anyone can run on it without Xovris (GET /v1/actions/{seq}/receipt)"""
        return self._call("GET", f"/v1/actions/{_q(seq)}/receipt", query=query)

    def get_actions_undos_by_id(self, id_, query=None):
        """Read where an undo is and what it found (GET /v1/actions/undos/{id})"""
        return self._call("GET", f"/v1/actions/undos/{_q(id_)}", query=query)

    def get_actions_undo_window(self, query=None):
        """See what undoing back to a moment would put back, before anything is undone (GET /v1/actions/undo-window)"""
        return self._call("GET", f"/v1/actions/undo-window", query=query)

    def get_actions_verify(self, query=None):
        """Verify the record of what Xovris did has not been altered (GET /v1/actions/verify)"""
        return self._call("GET", f"/v1/actions/verify", query=query)

    def get_ai_choices(self, query=None):
        """List the AI models and efforts an ask can be given, from the live catalogue (GET /v1/ai/choices)"""
        return self._call("GET", f"/v1/ai/choices", query=query)

    def get_alert_actions(self, query=None):
        """List the actions your alerts can call (GET /v1/alert-actions)"""
        return self._call("GET", f"/v1/alert-actions", query=query)

    def get_alert_actions_by_id_rules(self, id_, query=None):
        """List the alert rules that call an action (GET /v1/alert-actions/{id}/rules)"""
        return self._call("GET", f"/v1/alert-actions/{_q(id_)}/rules", query=query)

    def get_alerts(self, query=None):
        """List the alerts raised in your workspace (GET /v1/alerts)"""
        return self._call("GET", f"/v1/alerts", query=query)

    def get_alerts_channel_facts(self, query=None):
        """List the channels Xovris reaches people through on this server, each live because its door is configured (GET /v1/alerts/channel-facts)"""
        return self._call("GET", f"/v1/alerts/channel-facts", query=query)

    def get_alerts_channels_discord_callback(self, query=None):
        """Finish adding a Discord channel after Discord's own approval (GET /v1/alerts/channels/discord/callback)"""
        return self._call("GET", f"/v1/alerts/channels/discord/callback", query=query)

    def get_alerts_channels_pagerduty_callback(self, query=None):
        """Finish connecting PagerDuty after PagerDuty's own approval; an on-call import's approval returns here too and goes back to the on-call page to read (GET /v1/alerts/channels/pagerduty/callback)"""
        return self._call("GET", f"/v1/alerts/channels/pagerduty/callback", query=query)

    def get_alerts_delivery(self, query=None):
        """See where each alert went and whether it arrived (GET /v1/alerts/delivery)"""
        return self._call("GET", f"/v1/alerts/delivery", query=query)

    def get_alerts_limit_points(self, query=None):
        """Read the points at which you hear about AI spend, and the rule for shared channels (GET /v1/alerts/limit-points)"""
        return self._call("GET", f"/v1/alerts/limit-points", query=query)

    def get_alerts_mail_server(self, query=None):
        """The workspace's own mail server and what it last answered (GET /v1/alerts/mail-server)"""
        return self._call("GET", f"/v1/alerts/mail-server", query=query)

    def get_alerts_phrase(self, query=None):
        """Read your own alert phrase and your workspace's (GET /v1/alerts/phrase)"""
        return self._call("GET", f"/v1/alerts/phrase", query=query)

    def get_alerts_push_key(self, query=None):
        """Read the key a device subscribes to push alerts with (GET /v1/alerts/push/key)"""
        return self._call("GET", f"/v1/alerts/push/key", query=query)

    def get_alerts_reach(self, query=None):
        """See who a failure of one thing would reach now, and how (GET /v1/alerts/reach)"""
        return self._call("GET", f"/v1/alerts/reach", query=query)

    def get_alerts_rules(self, query=None):
        """List your alert rules (GET /v1/alerts/rules)"""
        return self._call("GET", f"/v1/alerts/rules", query=query)

    def get_alerts_sending_domain(self, query=None):
        """The workspace's own sending domain and each record read from outside (GET /v1/alerts/sending-domain)"""
        return self._call("GET", f"/v1/alerts/sending-domain", query=query)

    def get_alerts_status_page_door(self, query=None):
        """Read the status page Xovris posts updates to (GET /v1/alerts/status-page-door)"""
        return self._call("GET", f"/v1/alerts/status-page-door", query=query)

    def get_alerts_tuning(self, query=None):
        """See the changes Xovris proposes to make your alerts quieter and sharper (GET /v1/alerts/tuning)"""
        return self._call("GET", f"/v1/alerts/tuning", query=query)

    def get_alerts_unsubscribe(self, query=None):
        """The page that stops alerts to an address (GET /v1/alerts/unsubscribe)"""
        return self._call("GET", f"/v1/alerts/unsubscribe", query=query)

    def get_api_alerts_delivery(self, query=None):
        """Read how alert delivery is doing across every channel (GET /api/alerts/delivery)"""
        return self._call("GET", f"/api/alerts/delivery", query=query)

    def get_api_alerts_health(self, query=None):
        """Read the health of the alerting service (GET /api/alerts/health)"""
        return self._call("GET", f"/api/alerts/health", query=query)

    def get_api_by_project_id_chunk_upload_index(self, project_id, query=None):
        """Read how a large file should be sent in parts: the part size and where each one goes (GET /api/{projectId}/chunk-upload/)"""
        return self._call("GET", f"/api/{_q(project_id)}/chunk-upload/", query=query)

    def get_api_watch(self, query=None):
        """Read the changes found in the APIs you depend on (GET /v1/api-watch)"""
        return self._call("GET", f"/v1/api-watch", query=query)

    def get_apps_watch(self, query=None):
        """Read the app store and crash watch (GET /v1/apps/watch)"""
        return self._call("GET", f"/v1/apps/watch", query=query)

    def get_assets_by_id_first_look(self, id_, query=None):
        """Read the first look at a website (GET /v1/assets/{id}/first-look)"""
        return self._call("GET", f"/v1/assets/{_q(id_)}/first-look", query=query)

    def get_assets_by_id_site_quality(self, id_, query=None):
        """Read a website's quality report (GET /v1/assets/{id}/site-quality)"""
        return self._call("GET", f"/v1/assets/{_q(id_)}/site-quality", query=query)

    def get_assets_graph(self, query=None):
        """Read what Xovris believed about your assets at a moment, and what was true then (GET /v1/assets/graph)"""
        return self._call("GET", f"/v1/assets/graph", query=query)

    def get_asset_stories(self, query=None):
        """Read the story of each thing you own (GET /v1/asset-stories)"""
        return self._call("GET", f"/v1/asset-stories", query=query)

    def get_asset_stories_export(self, query=None):
        """Export the story of each thing you own (GET /v1/asset-stories/export)"""
        return self._call("GET", f"/v1/asset-stories/export", query=query)

    def get_assist_cobrowse(self, query=None):
        """List your past shared-tab help sessions (GET /v1/assist/cobrowse)"""
        return self._call("GET", f"/v1/assist/cobrowse", query=query)

    def get_assist_cobrowse_by_id(self, id_, query=None):
        """Read a shared tab's full record (GET /v1/assist/cobrowse/{id})"""
        return self._call("GET", f"/v1/assist/cobrowse/{_q(id_)}", query=query)

    def get_assist_cobrowse_guides(self, query=None):
        """List the guides Xovris can walk you through in a shared tab (GET /v1/assist/cobrowse/guides)"""
        return self._call("GET", f"/v1/assist/cobrowse/guides", query=query)

    def get_assist_completion(self, query=None):
        """See how many requests Xovris finished end to end, by kind (GET /v1/assist/completion)"""
        return self._call("GET", f"/v1/assist/completion", query=query)

    def get_assist_execution_share(self, query=None):
        """See, for each kind of request, how much Xovris finished itself with a receipt (GET /v1/assist/execution-share)"""
        return self._call("GET", f"/v1/assist/execution-share", query=query)

    def get_assist_memory(self, query=None):
        """Read what Xovris remembers about you (GET /v1/assist/memory)"""
        return self._call("GET", f"/v1/assist/memory", query=query)

    def get_assist_models(self, query=None):
        """List every AI model the Ask can answer on, with its maker and what it costs (GET /v1/assist/models)"""
        return self._call("GET", f"/v1/assist/models", query=query)

    def get_assist_now(self, query=None):
        """See everything Xovris is carrying on by itself right now, with its next step and when it looks again (GET /v1/assist/now)"""
        return self._call("GET", f"/v1/assist/now", query=query)

    def get_assist_projects(self, query=None):
        """List your projects with how many conversations each holds (GET /v1/assist/projects)"""
        return self._call("GET", f"/v1/assist/projects", query=query)

    def get_assist_requests(self, query=None):
        """List your requests to Xovris (GET /v1/assist/requests)"""
        return self._call("GET", f"/v1/assist/requests", query=query)

    def get_assist_requests_by_id(self, id_, query=None):
        """Read a request and its steps (GET /v1/assist/requests/{id})"""
        return self._call("GET", f"/v1/assist/requests/{_q(id_)}", query=query)

    def get_assist_requests_by_id_pictures_by_slot(self, id_, slot, query=None):
        """Read a picture sent with a request (GET /v1/assist/requests/{id}/pictures/{slot})"""
        return self._call("GET", f"/v1/assist/requests/{_q(id_)}/pictures/{_q(slot)}", query=query)

    def get_assist_requests_by_id_report(self, id_, query=None):
        """Read the report of one request: what was read, tried and proved (GET /v1/assist/requests/{id}/report)"""
        return self._call("GET", f"/v1/assist/requests/{_q(id_)}/report", query=query)

    def get_assist_requests_by_id_share(self, id_, query=None):
        """See whether a conversation has a share link, and how many times it was opened (GET /v1/assist/requests/{id}/share)"""
        return self._call("GET", f"/v1/assist/requests/{_q(id_)}/share", query=query)

    def get_assist_shares(self, query=None):
        """List every share link of yours that still opens, with its views, to withdraw any of them (GET /v1/assist/shares)"""
        return self._call("GET", f"/v1/assist/shares", query=query)

    def get_audit(self, query=None):
        """Read who changed what in this workspace (GET /v1/audit)"""
        return self._call("GET", f"/v1/audit", query=query)

    def get_auth_methods(self, query=None):
        """List the ways to sign in (GET /v1/auth/methods)"""
        return self._call("GET", f"/v1/auth/methods", query=query)

    def get_automation(self, query=None):
        """Read the grants, standing permissions, kill switches and approvals in force (GET /v1/automation)"""
        return self._call("GET", f"/v1/automation", query=query)

    def get_automation_rules(self, query=None):
        """Read each automation rule's runs, rates and median time over a range (GET /v1/automation/rules)"""
        return self._call("GET", f"/v1/automation/rules", query=query)

    def get_autonomy_approval_chain(self, query=None):
        """Read who Xovris asks next, in order, when the person who asked has not answered (GET /v1/autonomy/approval-chain)"""
        return self._call("GET", f"/v1/autonomy/approval-chain", query=query)

    def get_autonomy_ask_budget(self, query=None):
        """See every journey's asks against its floor of approve and sign in (GET /v1/autonomy/ask-budget)"""
        return self._call("GET", f"/v1/autonomy/ask-budget", query=query)

    def get_autonomy_digest(self, query=None):
        """Read what Xovris did for you on a day, each with its undo (GET /v1/autonomy/digest)"""
        return self._call("GET", f"/v1/autonomy/digest", query=query)

    def get_autonomy_doors(self, query=None):
        """See each browser door's nightly rehearsal and any door held after a break (GET /v1/autonomy/doors)"""
        return self._call("GET", f"/v1/autonomy/doors", query=query)

    def get_autonomy_facts(self, query=None):
        """See the facts Xovris remembers for this workspace, so it never asks twice (GET /v1/autonomy/facts)"""
        return self._call("GET", f"/v1/autonomy/facts", query=query)

    def get_autonomy_goals(self, query=None):
        """See every plan you asked for in one sentence, and where it stands (GET /v1/autonomy/goals)"""
        return self._call("GET", f"/v1/autonomy/goals", query=query)

    def get_autonomy_grants_use(self, query=None):
        """See every grant against the scopes Xovris actually needs (GET /v1/autonomy/grants/use)"""
        return self._call("GET", f"/v1/autonomy/grants/use", query=query)

    def get_autonomy_guide(self, query=None):
        """Read every route Xovris guides at the start: each tool's door, the computer's installer and your AI's address, read back live (GET /v1/autonomy/guide)"""
        return self._call("GET", f"/v1/autonomy/guide", query=query)

    def get_autonomy_guides(self, query=None):
        """List every guide made from the plan Xovris's own browser runs (GET /v1/autonomy/guides)"""
        return self._call("GET", f"/v1/autonomy/guides", query=query)

    def get_autonomy_guides_by_integration(self, integration, query=None):
        """Read one guide: Do this for me first, with Do it yourself instead beneath it (GET /v1/autonomy/guides/{integration})"""
        return self._call("GET", f"/v1/autonomy/guides/{_q(integration)}", query=query)

    def get_autonomy_immunity(self, query=None):
        """See how Xovris protects you from vendor breaks other customers met first (GET /v1/autonomy/immunity)"""
        return self._call("GET", f"/v1/autonomy/immunity", query=query)

    def get_autonomy_me(self, query=None):
        """See how Xovris works with you, read from what you do (GET /v1/autonomy/me)"""
        return self._call("GET", f"/v1/autonomy/me", query=query)

    def get_autonomy_people(self, query=None):
        """See every joiner and leaver Xovris is handling (GET /v1/autonomy/people)"""
        return self._call("GET", f"/v1/autonomy/people", query=query)

    def get_autonomy_record(self, query=None):
        """List the changes of the last days that Xovris would have made on its own, each with what it was and how it ended (GET /v1/autonomy/record)"""
        return self._call("GET", f"/v1/autonomy/record", query=query)

    def get_autonomy_renewals(self, query=None):
        """See every certificate and domain Xovris renews before it ends (GET /v1/autonomy/renewals)"""
        return self._call("GET", f"/v1/autonomy/renewals", query=query)

    def get_autonomy_sitting(self, query=None):
        """See every yes Xovris waits for, in the order that unblocks the most (GET /v1/autonomy/sitting)"""
        return self._call("GET", f"/v1/autonomy/sitting", query=query)

    def get_autonomy_spend(self, query=None):
        """See unused seats and licences, and every cut Xovris made with its undo (GET /v1/autonomy/spend)"""
        return self._call("GET", f"/v1/autonomy/spend", query=query)

    def get_autonomy_stack(self, query=None):
        """See the tools found from your domain against the tools you connected (GET /v1/autonomy/stack)"""
        return self._call("GET", f"/v1/autonomy/stack", query=query)

    def get_autonomy_tap_by_code(self, code, query=None):
        """Download the signed device app named for its enrolment code, in one tap (GET /v1/autonomy/tap/{code})"""
        return self._call("GET", f"/v1/autonomy/tap/{_q(code)}", query=query)

    def get_autonomy_undo_coverage(self, query=None):
        """See how much of what Xovris did by itself can be undone with one press (GET /v1/autonomy/undo-coverage)"""
        return self._call("GET", f"/v1/autonomy/undo-coverage", query=query)

    def get_autonomy_vendor_cases(self, query=None):
        """See every vendor case Xovris is chasing for you (GET /v1/autonomy/vendor-cases)"""
        return self._call("GET", f"/v1/autonomy/vendor-cases", query=query)

    def get_autonomy_vendor_cases_by_id(self, id_, query=None):
        """Read one vendor case with every step Xovris took (GET /v1/autonomy/vendor-cases/{id})"""
        return self._call("GET", f"/v1/autonomy/vendor-cases/{_q(id_)}", query=query)

    def get_autonomy_watches(self, query=None):
        """See everything Xovris is waiting on you for, and how long each has waited (GET /v1/autonomy/watches)"""
        return self._call("GET", f"/v1/autonomy/watches", query=query)

    def get_autonomy_watches_by_id(self, id_, query=None):
        """Read one thing Xovris is waiting on you for, and what it does the moment it has it (GET /v1/autonomy/watches/{id})"""
        return self._call("GET", f"/v1/autonomy/watches/{_q(id_)}", query=query)

    def get_backups_found(self, query=None):
        """See the backups Xovris found (GET /v1/backups/found)"""
        return self._call("GET", f"/v1/backups/found", query=query)

    def get_backups_jobs(self, query=None):
        """See every backup job Xovris knows, its runs and what Xovris fixed on it (GET /v1/backups/jobs)"""
        return self._call("GET", f"/v1/backups/jobs", query=query)

    def get_backups_plan(self, query=None):
        """See the backup plan Xovris proposes for your systems (GET /v1/backups/plan)"""
        return self._call("GET", f"/v1/backups/plan", query=query)

    def get_badges(self, query=None):
        """List your badges (GET /v1/badges)"""
        return self._call("GET", f"/v1/badges", query=query)

    def get_board(self, query=None):
        """Your own dashboard: every tile you pinned from an answer, with its place on the grid (GET /v1/board)"""
        return self._call("GET", f"/v1/board", query=query)

    def get_board_tiles_by_id_read(self, id_, query=None):
        """Draw a tile again from its own read, now (GET /v1/board/tiles/{id}/read)"""
        return self._call("GET", f"/v1/board/tiles/{_q(id_)}/read", query=query)

    def get_breach_notices(self, query=None):
        """Read every notice of a breach of Xovris itself that touched this workspace's data (GET /v1/breach-notices)"""
        return self._call("GET", f"/v1/breach-notices", query=query)

    def get_builds_size(self, query=None):
        """Read how each build's size changed and why (GET /v1/builds/size)"""
        return self._call("GET", f"/v1/builds/size", query=query)

    def get_capacity(self, query=None):
        """Read how many investigations your plan runs at once, its reserved slots for critical incidents, and what is running now (GET /v1/capacity)"""
        return self._call("GET", f"/v1/capacity", query=query)

    def get_carry_on(self, query=None):
        """See what Xovris is still carrying on with, and the next step of each (GET /v1/carry-on)"""
        return self._call("GET", f"/v1/carry-on", query=query)

    def get_changes_before(self, query=None):
        """List what changed before a moment (GET /v1/changes/before)"""
        return self._call("GET", f"/v1/changes/before", query=query)

    def get_checks(self, query=None):
        """List checks (GET /v1/checks)"""
        return self._call("GET", f"/v1/checks", query=query)

    def get_checks_added(self, query=None):
        """List the checks added in Xovris, with their latest results (GET /v1/checks/added)"""
        return self._call("GET", f"/v1/checks/added", query=query)

    def get_checks_by_id_phases(self, id_, query=None):
        """Read one check's response time from each place over a day, a week or a month - each bin's runs and failures, the mean time of the runs that answered split into its steps (name lookup, connecting, the secure handshake, the first byte, the transfer), and each place's median and slow tail (GET /v1/checks/{id}/phases)"""
        return self._call("GET", f"/v1/checks/{_q(id_)}/phases", query=query)

    def get_checks_by_id_promise(self, id_, query=None):
        """Read a check's promise and its error budget (GET /v1/checks/{id}/promise)"""
        return self._call("GET", f"/v1/checks/{_q(id_)}/promise", query=query)

    def get_checks_by_id_runs(self, id_, query=None):
        """See every run a check stored in the last hours, per place, with its response time (GET /v1/checks/{id}/runs)"""
        return self._call("GET", f"/v1/checks/{_q(id_)}/runs", query=query)

    def get_checks_by_id_teardowns(self, id_, query=None):
        """Read what a check cleaned up after itself (GET /v1/checks/{id}/teardowns)"""
        return self._call("GET", f"/v1/checks/{_q(id_)}/teardowns", query=query)

    def get_checks_by_id_timeline(self, id_, query=None):
        """Read a check's results over time (GET /v1/checks/{id}/timeline)"""
        return self._call("GET", f"/v1/checks/{_q(id_)}/timeline", query=query)

    def get_checks_by_id_versions(self, id_, query=None):
        """List a check's versions (GET /v1/checks/{id}/versions)"""
        return self._call("GET", f"/v1/checks/{_q(id_)}/versions", query=query)

    def get_checks_metrics(self, query=None):
        """Read every check's figures in Prometheus's text format, for your own Prometheus or Grafana to scrape with an API token - each place's newest run (passed, its time, when), the check's state and how often it runs (GET /v1/checks/metrics)"""
        return self._call("GET", f"/v1/checks/metrics", query=query)

    def get_checks_promises(self, query=None):
        """List every check's promise worst first - broken, at risk, not yet measured, then kept - each with its objective, the share of its error budget left, the last day's burn, the alerts firing and the day the budget runs out at that pace, grouped by what it watches, over 7, 30 or 90 days, this week or this month (GET /v1/checks/promises)"""
        return self._call("GET", f"/v1/checks/promises", query=query)

    def get_checks_secrets(self, query=None):
        """List the secrets checks use (GET /v1/checks/secrets)"""
        return self._call("GET", f"/v1/checks/secrets", query=query)

    def get_checks_timings(self, query=None):
        """Read each check's response time over the last day or week - the median of its successful runs from every place in each step (GET /v1/checks/timings)"""
        return self._call("GET", f"/v1/checks/timings", query=query)

    def get_checks_uptime(self, query=None):
        """Read every check's days as one strip: the share of each day it was up, from its own results (GET /v1/checks/uptime)"""
        return self._call("GET", f"/v1/checks/uptime", query=query)

    def get_choices_models(self, query=None):
        """List the AI models you can choose from, with what each one costs (GET /v1/choices/models)"""
        return self._call("GET", f"/v1/choices/models", query=query)

    def get_cloud_azure_template_by_oid_by_file(self, oid, file, query=None):
        """The one-press Azure grant template, filled in for your workspace, that the Azure portal fetches (GET /v1/cloud/azure/template/{oid}/{file})"""
        return self._call("GET", f"/v1/cloud/azure/template/{_q(oid)}/{_q(file)}", query=query)

    def get_cloud_connections(self, query=None):
        """List your cloud accounts and how far each connection has got (GET /v1/cloud/connections)"""
        return self._call("GET", f"/v1/cloud/connections", query=query)

    def get_cloud_connections_by_id_bill_regions_grant(self, id_, query=None):
        """Get the one approval link that lets an older AWS connection read its bill by region (GET /v1/cloud/connections/{id}/bill/regions/grant)"""
        return self._call("GET", f"/v1/cloud/connections/{_q(id_)}/bill/regions/grant", query=query)

    def get_cloud_connections_by_id_inventory(self, id_, query=None):
        """See everything a connected cloud account holds - every resource its own inventory reports, by type (GET /v1/cloud/connections/{id}/inventory)"""
        return self._call("GET", f"/v1/cloud/connections/{_q(id_)}/inventory", query=query)

    def get_cloud_permissions(self, query=None):
        """See the exact permissions Xovris asks for on each cloud before it connects to it (GET /v1/cloud/permissions)"""
        return self._call("GET", f"/v1/cloud/permissions", query=query)

    def get_code_previews_by_token(self, token, query=None):
        """Open the live preview of a build while it is being made (GET /v1/code/previews/{token})"""
        return self._call("GET", f"/v1/code/previews/{_q(token)}", query=query)

    def get_code_previews_by_token_by_path(self, token, path, query=None):
        """Open one file of a build's live preview (GET /v1/code/previews/{token}/{path})"""
        return self._call("GET", f"/v1/code/previews/{_q(token)}/{_q(path)}", query=query)

    def get_code_previews_by_token_index(self, token, query=None):
        """Open the live preview of a build while it is being made (GET /v1/code/previews/{token}/)"""
        return self._call("GET", f"/v1/code/previews/{_q(token)}/", query=query)

    def get_code_projects(self, query=None):
        """List your builds and coding projects (GET /v1/code/projects)"""
        return self._call("GET", f"/v1/code/projects", query=query)

    def get_code_projects_by_id(self, id_, query=None):
        """Read one build: what was asked, each version and its checks (GET /v1/code/projects/{id})"""
        return self._call("GET", f"/v1/code/projects/{_q(id_)}", query=query)

    def get_code_projects_by_id_analytics(self, id_, query=None):
        """Read who visits a build's site - pages, visits and where people come from (GET /v1/code/projects/{id}/analytics)"""
        return self._call("GET", f"/v1/code/projects/{_q(id_)}/analytics", query=query)

    def get_code_projects_by_id_backend(self, id_, query=None):
        """See what a build runs behind its pages - its database, sign-in, storage and the parts switched on (GET /v1/code/projects/{id}/backend)"""
        return self._call("GET", f"/v1/code/projects/{_q(id_)}/backend", query=query)

    def get_code_projects_by_id_checkpoints(self, id_, query=None):
        """List the checkpoints saved of a build's data, newest first (GET /v1/code/projects/{id}/checkpoints)"""
        return self._call("GET", f"/v1/code/projects/{_q(id_)}/checkpoints", query=query)

    def get_code_projects_by_id_data_by_table(self, id_, table, query=None):
        """Read the rows of one table in a build's database (GET /v1/code/projects/{id}/data/{table})"""
        return self._call("GET", f"/v1/code/projects/{_q(id_)}/data/{_q(table)}", query=query)

    def get_code_projects_by_id_network(self, id_, query=None):
        """Read what a project's build sessions may reach - nothing, its registries, an allowlist or everything, and whether only to read (GET /v1/code/projects/{id}/network)"""
        return self._call("GET", f"/v1/code/projects/{_q(id_)}/network", query=query)

    def get_code_shared_by_token(self, token, query=None):
        """Open a build someone shared with you (GET /v1/code/shared/{token})"""
        return self._call("GET", f"/v1/code/shared/{_q(token)}", query=query)

    def get_code_shared_by_token_events(self, token, query=None):
        """Follow a shared build's steps as they happen (GET /v1/code/shared/{token}/events)"""
        return self._call("GET", f"/v1/code/shared/{_q(token)}/events", query=query)

    def get_code_shared_by_token_files(self, token, query=None):
        """Read the files of a build someone shared with you (GET /v1/code/shared/{token}/files)"""
        return self._call("GET", f"/v1/code/shared/{_q(token)}/files", query=query)

    def get_code_shared_by_token_preview_by_path(self, token, path, query=None):
        """Open one file of a shared build's live preview (GET /v1/code/shared/{token}/preview/{path})"""
        return self._call("GET", f"/v1/code/shared/{_q(token)}/preview/{_q(path)}", query=query)

    def get_code_shared_by_token_preview_index(self, token, query=None):
        """Open the live preview of a build someone shared with you (GET /v1/code/shared/{token}/preview/)"""
        return self._call("GET", f"/v1/code/shared/{_q(token)}/preview/", query=query)

    def get_code_sites_by_token(self, token, query=None):
        """Open the site a build was deployed to (GET /v1/code/sites/{token})"""
        return self._call("GET", f"/v1/code/sites/{_q(token)}", query=query)

    def get_code_sites_by_token_by_path(self, token, path, query=None):
        """Open one file of a deployed build's site (GET /v1/code/sites/{token}/{path})"""
        return self._call("GET", f"/v1/code/sites/{_q(token)}/{_q(path)}", query=query)

    def get_code_sites_by_token_index(self, token, query=None):
        """Open the site a build was deployed to (GET /v1/code/sites/{token}/)"""
        return self._call("GET", f"/v1/code/sites/{_q(token)}/", query=query)

    def get_code_spend_limit(self, query=None):
        """Read how much your builds may spend in a month, and what is spent so far (GET /v1/code/spend-limit)"""
        return self._call("GET", f"/v1/code/spend-limit", query=query)

    def get_code_ssh_key(self, query=None):
        """Read the public half of this workspace's own key for its repositories, to add with write access so a proven fix is pushed there (GET /v1/code/ssh-key)"""
        return self._call("GET", f"/v1/code/ssh-key", query=query)

    def get_code_tasks_by_id(self, id_, query=None):
        """Read one coding job: each step it took, its proof and the pull request or change it ended with (GET /v1/code/tasks/{id})"""
        return self._call("GET", f"/v1/code/tasks/{_q(id_)}", query=query)

    def get_code_tasks_by_id_archive(self, id_, query=None):
        """Download a build's code as one zip (GET /v1/code/tasks/{id}/archive)"""
        return self._call("GET", f"/v1/code/tasks/{_q(id_)}/archive", query=query)

    def get_code_tasks_by_id_events(self, id_, query=None):
        """Follow one coding job as it happens: each step the moment it lands, then its end (GET /v1/code/tasks/{id}/events)"""
        return self._call("GET", f"/v1/code/tasks/{_q(id_)}/events", query=query)

    def get_code_tasks_by_id_inbox(self, id_, query=None):
        """Reads the events a build was handed; with take=1 its session takes what is new, each once (GET /v1/code/tasks/{id}/inbox)"""
        return self._call("GET", f"/v1/code/tasks/{_q(id_)}/inbox", query=query)

    def get_code_tasks_by_id_shares(self, id_, query=None):
        """List the links a build is shared with, and what each one may do (GET /v1/code/tasks/{id}/shares)"""
        return self._call("GET", f"/v1/code/tasks/{_q(id_)}/shares", query=query)

    def get_collectors(self, query=None):
        """List your collectors (GET /v1/collectors)"""
        return self._call("GET", f"/v1/collectors", query=query)

    def get_companies(self, query=None):
        """Read your account's companies, each one's usage and the shared pool (GET /v1/companies)"""
        return self._call("GET", f"/v1/companies", query=query)

    def get_compliance_cyber_essentials(self, query=None):
        """Read your Cyber Essentials readiness (GET /v1/compliance/cyber-essentials)"""
        return self._call("GET", f"/v1/compliance/cyber-essentials", query=query)

    def get_computer_audit_csv(self, query=None):
        """Every computer session's record, for this workspace's own audit, as one file (GET /v1/computer/audit.csv)"""
        return self._call("GET", f"/v1/computer/audit.csv", query=query)

    def get_computer_policy(self, query=None):
        """Read this workspace's rules for Xovris's computer (GET /v1/computer/policy)"""
        return self._call("GET", f"/v1/computer/policy", query=query)

    def get_computers_allowance(self, query=None):
        """See whether a job may use a computer, as part of your plan's AI use (GET /v1/computers/allowance)"""
        return self._call("GET", f"/v1/computers/allowance", query=query)

    def get_computers_by_id(self, id_, query=None):
        """Read a desktop's state - starting, ready, held by you or by the agent, or ended - with why when it is not ready (GET /v1/computers/{id})"""
        return self._call("GET", f"/v1/computers/{_q(id_)}", query=query)

    def get_computers_by_id_desk_input(self, id_, query=None):
        """The desktop's own door: it collects the input waiting for it with the key it was started with (GET /v1/computers/{id}/desk/input)"""
        return self._call("GET", f"/v1/computers/{_q(id_)}/desk/input", query=query)

    def get_computers_by_id_desk_profile(self, id_, query=None):
        """The desktop's own door: it reads back the sign-ins kept for your next session with the key it was started with (GET /v1/computers/{id}/desk/profile)"""
        return self._call("GET", f"/v1/computers/{_q(id_)}/desk/profile", query=query)

    def get_computers_by_id_desk_uploads(self, id_, query=None):
        """The desktop's own door: the files the person gave the session, taken into its Uploads folder (GET /v1/computers/{id}/desk/uploads)"""
        return self._call("GET", f"/v1/computers/{_q(id_)}/desk/uploads", query=query)

    def get_computers_by_id_frame(self, id_, query=None):
        """Read a desktop's latest screen, or wait for the next one after the one you have (GET /v1/computers/{id}/frame)"""
        return self._call("GET", f"/v1/computers/{_q(id_)}/frame", query=query)

    def get_computer_schedules(self, query=None):
        """Every goal on a schedule, its next time and its runs, each run in a conversation of its own (GET /v1/computer/schedules)"""
        return self._call("GET", f"/v1/computer/schedules", query=query)

    def get_computer_sessions(self, query=None):
        """List this workspace's computer sessions, newest first, each with its state and how it ended (GET /v1/computer/sessions)"""
        return self._call("GET", f"/v1/computer/sessions", query=query)

    def get_computer_sessions_by_id(self, id_, query=None):
        """Watch one computer session as it goes - the latest screen, the window in front, every step with the reason it was taken (GET /v1/computer/sessions/{id})"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}", query=query)

    def get_computer_sessions_by_id_files(self, id_, query=None):
        """The files a session downloaded on Xovris's own computer - their names, sizes and when (GET /v1/computer/sessions/{id}/files)"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}/files", query=query)

    def get_computer_sessions_by_id_files_by_name(self, id_, name, query=None):
        """One file the session downloaded, as the person's own download (GET /v1/computer/sessions/{id}/files/{name})"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}/files/{_q(name)}", query=query)

    def get_computer_sessions_by_id_recording(self, id_, query=None):
        """A session you ran as one moving file - every kept screen in the order it happened, a secret blacked out (GET /v1/computer/sessions/{id}/recording)"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}/recording", query=query)

    def get_computer_sessions_by_id_reel_by_seq_by_i(self, id_, seq, i, query=None):
        """One screen of a session's moving record - the screens between its looks, a second apart, as it happened (GET /v1/computer/sessions/{id}/reel/{seq}/{i})"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}/reel/{_q(seq)}/{_q(i)}", query=query)

    def get_computer_sessions_by_id_replay(self, id_, query=None):
        """Replay a computer session you ran, step by step, each step beside the screen it was chosen from (GET /v1/computer/sessions/{id}/replay)"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}/replay", query=query)

    def get_computer_sessions_by_id_replay_by_seq(self, id_, seq, query=None):
        """One screen of a session you ran, as Xovris saw it before the steps chosen from it (GET /v1/computer/sessions/{id}/replay/{seq})"""
        return self._call("GET", f"/v1/computer/sessions/{_q(id_)}/replay/{_q(seq)}", query=query)

    def get_computers_sign_ins(self, query=None):
        """See whether Xovris's own computer keeps the sign-ins you made on it for your next session, and since when (GET /v1/computers/sign-ins)"""
        return self._call("GET", f"/v1/computers/sign-ins", query=query)

    def get_connect_callback(self, query=None):
        """Where a provider's sign-in returns the person to finish a connection (GET /v1/connect/callback)"""
        return self._call("GET", f"/v1/connect/callback", query=query)

    def get_connections(self, query=None):
        """List every connection and how its last check went (GET /v1/connections)"""
        return self._call("GET", f"/v1/connections", query=query)

    def get_connections_by_id_access_delta(self, id_, query=None):
        """Compare a connection's access with what a fix needs (GET /v1/connections/{id}/access-delta)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/access-delta", query=query)

    def get_connections_by_id_canary(self, id_, query=None):
        """Read how a connection's scheduled check went (GET /v1/connections/{id}/canary)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/canary", query=query)

    def get_connections_by_id_capabilities(self, id_, query=None):
        """Read what a connection lets Xovris do (GET /v1/connections/{id}/capabilities)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/capabilities", query=query)

    def get_connections_by_id_credential(self, id_, query=None):
        """Read a connection's credential state (GET /v1/connections/{id}/credential)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/credential", query=query)

    def get_connections_by_id_domains_by_domain_renewal(self, id_, domain, query=None):
        """See what renewing a domain costs at its registrar and the one call that buys it (GET /v1/connections/{id}/domains/{domain}/renewal)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/domains/{_q(domain)}/renewal", query=query)

    def get_connections_by_id_github(self, id_, query=None):
        """See what a GitHub connection can do and what it needs (GET /v1/connections/{id}/github)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/github", query=query)

    def get_connections_by_id_remove_preview(self, id_, query=None):
        """See what stops working before you remove a connection (GET /v1/connections/{id}/remove-preview)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/remove-preview", query=query)

    def get_connections_by_id_verify(self, id_, query=None):
        """Verify a connection is working (GET /v1/connections/{id}/verify)"""
        return self._call("GET", f"/v1/connections/{_q(id_)}/verify", query=query)

    def get_connections_dns(self, query=None):
        """List DNS connections (GET /v1/connections/dns)"""
        return self._call("GET", f"/v1/connections/dns", query=query)

    def get_connections_dns_by_id(self, id_, query=None):
        """Read a DNS connection (GET /v1/connections/dns/{id})"""
        return self._call("GET", f"/v1/connections/dns/{_q(id_)}", query=query)

    def get_connections_dns_by_id_records(self, id_, query=None):
        """List the records a DNS connection reads (GET /v1/connections/dns/{id}/records)"""
        return self._call("GET", f"/v1/connections/dns/{_q(id_)}/records", query=query)

    def get_connections_figma(self, query=None):
        """See whether Figma is connected, and how (GET /v1/connections/figma)"""
        return self._call("GET", f"/v1/connections/figma", query=query)

    def get_connections_figma_callback(self, query=None):
        """Finish connecting Figma after allowing Xovris in Figma (GET /v1/connections/figma/callback)"""
        return self._call("GET", f"/v1/connections/figma/callback", query=query)

    def get_connections_figma_start(self, query=None):
        """Connect Figma in one press, allowed on Figma's own page (GET /v1/connections/figma/start)"""
        return self._call("GET", f"/v1/connections/figma/start", query=query)

    def get_connect_mcp_local(self, query=None):
        """See the MCP servers your own computers run, with the settings names each one is given (GET /v1/connect/mcp-local)"""
        return self._call("GET", f"/v1/connect/mcp-local", query=query)

    def get_conversations_by_type_by_id(self, type_, id_, query=None):
        """List the conversations a person started from one record's own page, newest first (GET /v1/conversations/{type}/{id})"""
        return self._call("GET", f"/v1/conversations/{_q(type_)}/{_q(id_)}", query=query)

    def get_dashboards(self, query=None):
        """List dashboards (GET /v1/dashboards)"""
        return self._call("GET", f"/v1/dashboards", query=query)

    def get_dashboards_by_id(self, id_, query=None):
        """Read a dashboard (GET /v1/dashboards/{id})"""
        return self._call("GET", f"/v1/dashboards/{_q(id_)}", query=query)

    def get_dashboards_by_id_reports(self, id_, query=None):
        """List a dashboard's scheduled reports (GET /v1/dashboards/{id}/reports)"""
        return self._call("GET", f"/v1/dashboards/{_q(id_)}/reports", query=query)

    def get_dashboards_by_id_reports_preview(self, id_, query=None):
        """Read what a dashboard's report would say now (GET /v1/dashboards/{id}/reports/preview)"""
        return self._call("GET", f"/v1/dashboards/{_q(id_)}/reports/preview", query=query)

    def get_dashboards_by_id_shares(self, id_, query=None):
        """List a dashboard's shared links, embeds and TVs (GET /v1/dashboards/{id}/shares)"""
        return self._call("GET", f"/v1/dashboards/{_q(id_)}/shares", query=query)

    def get_delivery_agents(self, query=None):
        """See which commits a coding agent wrote and how they did in production (GET /v1/delivery/agents)"""
        return self._call("GET", f"/v1/delivery/agents", query=query)

    def get_delivery_dora(self, query=None):
        """Read your delivery measures (DORA) (GET /v1/delivery/dora)"""
        return self._call("GET", f"/v1/delivery/dora", query=query)

    def get_deploy_guard(self, query=None):
        """Whether a release may ship, read from every promised journey's error budget (GET /v1/deploy-guard)"""
        return self._call("GET", f"/v1/deploy-guard", query=query)

    def get_device_by_code(self, code, query=None):
        """Read a device sign-in request (GET /v1/device/{code})"""
        return self._call("GET", f"/v1/device/{_q(code)}", query=query)

    def get_devices(self, query=None):
        """List devices (GET /v1/devices)"""
        return self._call("GET", f"/v1/devices", query=query)

    def get_devices_apple(self, query=None):
        """See how far Xovris goes on an iPhone or iPad, with its guides and Shortcuts link (GET /v1/devices/apple)"""
        return self._call("GET", f"/v1/devices/apple", query=query)

    def get_devices_appliances(self, query=None):
        """List the appliance doors connected to your devices (GET /v1/devices/appliances)"""
        return self._call("GET", f"/v1/devices/appliances", query=query)

    def get_devices_app_updates(self, query=None):
        """See application updates rolling out across your devices (GET /v1/devices/app-updates)"""
        return self._call("GET", f"/v1/devices/app-updates", query=query)

    def get_devices_by_id(self, id_, query=None):
        """Read a device (GET /v1/devices/{id})"""
        return self._call("GET", f"/v1/devices/{_q(id_)}", query=query)

    def get_devices_by_id_activity(self, id_, query=None):
        """Read a device's activity (GET /v1/devices/{id}/activity)"""
        return self._call("GET", f"/v1/devices/{_q(id_)}/activity", query=query)

    def get_devices_by_id_memory(self, id_, query=None):
        """See a device's model, quirks, history and what fixed it before (GET /v1/devices/{id}/memory)"""
        return self._call("GET", f"/v1/devices/{_q(id_)}/memory", query=query)

    def get_devices_by_id_reliability(self, id_, query=None):
        """Read how reliable each workload on a device is (GET /v1/devices/{id}/reliability)"""
        return self._call("GET", f"/v1/devices/{_q(id_)}/reliability", query=query)

    def get_devices_by_id_reports_by_report_id(self, id_, report_id, query=None):
        """Read a device's report (GET /v1/devices/{id}/reports/{reportId})"""
        return self._call("GET", f"/v1/devices/{_q(id_)}/reports/{_q(report_id)}", query=query)

    def get_devices_doors(self, query=None):
        """See every door Xovris reaches a device through, least asked of you first (GET /v1/devices/doors)"""
        return self._call("GET", f"/v1/devices/doors", query=query)

    def get_devices_enrolment_codes_by_code_installer(self, code, query=None):
        """Download the installer that enrols a device with this code (GET /v1/devices/enrolment-codes/{code}/installer)"""
        return self._call("GET", f"/v1/devices/enrolment-codes/{_q(code)}/installer", query=query)

    def get_devices_findings_csv(self, query=None):
        """Every device finding, as one spreadsheet (GET /v1/devices/findings.csv)"""
        return self._call("GET", f"/v1/devices/findings.csv", query=query)

    def get_devices_groups(self, query=None):
        """List your device groups (GET /v1/devices/groups)"""
        return self._call("GET", f"/v1/devices/groups", query=query)

    def get_devices_installers(self, query=None):
        """See what Xovris can hand a computer of each system - a download to open, or one line that fetches it (GET /v1/devices/installers)"""
        return self._call("GET", f"/v1/devices/installers", query=query)

    def get_devices_local_agent_control_key(self, query=None):
        """Read the public key your computers' agents verify Xovris with (GET /v1/devices/local-agent/control-key)"""
        return self._call("GET", f"/v1/devices/local-agent/control-key", query=query)

    def get_devices_remediations(self, query=None):
        """List the fixes found for your devices, and which have been made (GET /v1/devices/remediations)"""
        return self._call("GET", f"/v1/devices/remediations", query=query)

    def get_digest_week(self, query=None):
        """Read this week's letter, every figure from your own records (GET /v1/digest/week)"""
        return self._call("GET", f"/v1/digest/week", query=query)

    def get_dns_dangling(self, query=None):
        """List records pointing at something nobody owns (GET /v1/dns/dangling)"""
        return self._call("GET", f"/v1/dns/dangling", query=query)

    def get_dns_query_by_token(self, token, query=None):
        """Ask a household member's protective resolver a DNS question (RFC 8484 GET) (GET /v1/dns-query/{token})"""
        return self._call("GET", f"/v1/dns-query/{_q(token)}", query=query)

    def get_dns_restore_drills(self, query=None):
        """Read each zone's latest test restore and what it brought back (GET /v1/dns/restore-drills)"""
        return self._call("GET", f"/v1/dns/restore-drills", query=query)

    def get_dnssec_ds(self, query=None):
        """See the DNSSEC record your registrar needs (GET /v1/dnssec/ds)"""
        return self._call("GET", f"/v1/dnssec/ds", query=query)

    def get_domains_by_domain_registrar(self, domain, query=None):
        """See which of your registrar connections holds a domain, and whether its transfer lock is on (GET /v1/domains/{domain}/registrar)"""
        return self._call("GET", f"/v1/domains/{_q(domain)}/registrar", query=query)

    def get_doors_extension(self, query=None):
        """See the browsers paired with the Xovris extension (GET /v1/doors/extension)"""
        return self._call("GET", f"/v1/doors/extension", query=query)

    def get_doors_extension_next(self, query=None):
        """The paired extension asks for its next step (GET /v1/doors/extension/next)"""
        return self._call("GET", f"/v1/doors/extension/next", query=query)

    def get_doors_extension_tasks_by_id(self, id_, query=None):
        """See how an extension task went, step by step (GET /v1/doors/extension/tasks/{id})"""
        return self._call("GET", f"/v1/doors/extension/tasks/{_q(id_)}", query=query)

    def get_edge_protect(self, query=None):
        """See each zone you granted and what Xovris may put on its edge (GET /v1/edge/protect)"""
        return self._call("GET", f"/v1/edge/protect", query=query)

    def get_efficiency(self, query=None):
        """Read the weekly list of ways to be faster or cheaper (GET /v1/efficiency)"""
        return self._call("GET", f"/v1/efficiency", query=query)

    def get_efficiency_weekly(self, query=None):
        """Read the weekly faster-or-cheaper email's contents (GET /v1/efficiency/weekly)"""
        return self._call("GET", f"/v1/efficiency/weekly", query=query)

    def get_elevations(self, query=None):
        """The roles asked for a set time - who asked and why, who said yes, the time left, and every decision taken while each ran (GET /v1/elevations)"""
        return self._call("GET", f"/v1/elevations", query=query)

    def get_estate(self, query=None):
        """Read everything you run, by kind - each kind's things, what was last read, and how many wait on you (GET /v1/estate)"""
        return self._call("GET", f"/v1/estate", query=query)

    def get_estate_by_kind(self, kind, query=None):
        """Read one kind of thing you run, with its things, their readings and its open incidents (GET /v1/estate/{kind})"""
        return self._call("GET", f"/v1/estate/{_q(kind)}", query=query)

    def get_everyday_acts(self, query=None):
        """See everything Xovris did for you through these features, each with its undo (GET /v1/everyday/acts)"""
        return self._call("GET", f"/v1/everyday/acts", query=query)

    def get_everyday_figures(self, query=None):
        """See your live fix, root-cause and prevention rates, the time Xovris saved you, what you still did yourselves and its unsafe actions (which must be 0), what each is measured from, and any that got worse (GET /v1/everyday/figures)"""
        return self._call("GET", f"/v1/everyday/figures", query=query)

    def get_everyday_prevented(self, query=None):
        """See every problem Xovris dealt with before it was due, with the evidence it would have happened, and whether a prevention guarantee's figures are there yet (GET /v1/everyday/prevented)"""
        return self._call("GET", f"/v1/everyday/prevented", query=query)

    def get_export(self, query=None):
        """Export everything in this workspace (GET /v1/export)"""
        return self._call("GET", f"/v1/export", query=query)

    def get_exports(self, query=None):
        """Read where each export stands, reconciled (GET /v1/exports)"""
        return self._call("GET", f"/v1/exports", query=query)

    def get_exports_schema(self, query=None):
        """Read the export schema (GET /v1/exports/schema)"""
        return self._call("GET", f"/v1/exports/schema", query=query)

    def get_exposure(self, query=None):
        """Read what is exposed about you (GET /v1/exposure)"""
        return self._call("GET", f"/v1/exposure", query=query)

    def get_exposure_prove(self, query=None):
        """Open the link that confirms an address to watch (GET /v1/exposure/prove)"""
        return self._call("GET", f"/v1/exposure/prove", query=query)

    def get_extensions(self, query=None):
        """Read the components for a place in the command centre (GET /v1/extensions)"""
        return self._call("GET", f"/v1/extensions", query=query)

    def get_extensions_apps(self, query=None):
        """List installed apps (GET /v1/extensions/apps)"""
        return self._call("GET", f"/v1/extensions/apps", query=query)

    def get_failover_targets(self, query=None):
        """List the standby targets for failover (GET /v1/failover-targets)"""
        return self._call("GET", f"/v1/failover-targets", query=query)

    def get_fix_actions(self, query=None):
        """List the fix actions Xovris can run here (GET /v1/fix-actions)"""
        return self._call("GET", f"/v1/fix-actions", query=query)

    def get_forecasts(self, query=None):
        """Read what will fail before it does (GET /v1/forecasts)"""
        return self._call("GET", f"/v1/forecasts", query=query)

    def get_forwarders(self, query=None):
        """List the log agents you can point at Xovris (GET /v1/forwarders)"""
        return self._call("GET", f"/v1/forwarders", query=query)

    def get_forwarders_parity(self, query=None):
        """Compare your log agents' settings with Xovris's (GET /v1/forwarders/parity)"""
        return self._call("GET", f"/v1/forwarders/parity", query=query)

    def get_free_expiry_confirm(self, query=None):
        """Confirm a free expiry watch from its email (GET /v1/free/expiry/confirm)"""
        return self._call("GET", f"/v1/free/expiry/confirm", query=query)

    def get_goals_account(self, query=None):
        """See every goal Xovris has accepted - asked, kept or started by itself - with what it proved, what it is doing and what needs a yes (GET /v1/goals/account)"""
        return self._call("GET", f"/v1/goals/account", query=query)

    def get_goals_standing(self, query=None):
        """See your standing goals, what wakes each, and every time each fired (GET /v1/goals/standing)"""
        return self._call("GET", f"/v1/goals/standing", query=query)

    def get_grants(self, query=None):
        """List the standing permissions you have given Xovris to act for you (GET /v1/grants)"""
        return self._call("GET", f"/v1/grants", query=query)

    def get_health(self, query=None):
        """Read whether the API and its database are answering (GET /v1/health)"""
        return self._call("GET", f"/v1/health", query=query)

    def get_helper_website_conversations(self, query=None):
        """Read the conversations carried here from the website (GET /v1/helper/website-conversations)"""
        return self._call("GET", f"/v1/helper/website-conversations", query=query)

    def get_home_network(self, query=None):
        """Read what the weekly home-network check found (GET /v1/home-network)"""
        return self._call("GET", f"/v1/home-network", query=query)

    def get_hooks_sources_by_tenant_by_connection(self, tenant, connection, query=None):
        """Read a connected source's door (GET /v1/hooks/sources/{tenant}/{connection})"""
        return self._call("GET", f"/v1/hooks/sources/{_q(tenant)}/{_q(connection)}", query=query)

    def get_hooks_watch_by_token(self, token, query=None):
        """Report to a watch with a GET (GET /v1/hooks/watch/{token})"""
        return self._call("GET", f"/v1/hooks/watch/{_q(token)}", query=query)

    def get_household(self, query=None):
        """See your household's members, their devices and what was blocked this week (GET /v1/household)"""
        return self._call("GET", f"/v1/household", query=query)

    def get_household_members_by_id_blocked(self, id_, query=None):
        """See what was blocked for a household member, and allow it (GET /v1/household/members/{id}/blocked)"""
        return self._call("GET", f"/v1/household/members/{_q(id_)}/blocked", query=query)

    def get_household_setup_by_token_apple_mobileconfig(self, token, query=None):
        """Download the protection profile for an iPhone, iPad or Mac (GET /v1/household/setup/{token}/apple.mobileconfig)"""
        return self._call("GET", f"/v1/household/setup/{_q(token)}/apple.mobileconfig", query=query)

    def get_identity_app_risk(self, query=None):
        """Read what each app people let into your directory can read and change, with its risk (GET /v1/identity/app-risk)"""
        return self._call("GET", f"/v1/identity/app-risk", query=query)

    def get_identity_connections(self, query=None):
        """List connected directories (GET /v1/identity/connections)"""
        return self._call("GET", f"/v1/identity/connections", query=query)

    def get_identity_connections_by_id_layers(self, id_, query=None):
        """Read a directory's protection layers (GET /v1/identity/connections/{id}/layers)"""
        return self._call("GET", f"/v1/identity/connections/{_q(id_)}/layers", query=query)

    def get_identity_doors(self, query=None):
        """See each identity system Xovris connects with one approval, and exactly what it asks for (GET /v1/identity/doors)"""
        return self._call("GET", f"/v1/identity/doors", query=query)

    def get_identity_doors_callback(self, query=None):
        """Finish connecting an identity system when its approval page sends you back (GET /v1/identity/doors/callback)"""
        return self._call("GET", f"/v1/identity/doors/callback", query=query)

    def get_identity_runs(self, query=None):
        """List starter and leaver runs (GET /v1/identity/runs)"""
        return self._call("GET", f"/v1/identity/runs", query=query)

    def get_identity_runs_by_id(self, id_, query=None):
        """Read a starter or leaver run (GET /v1/identity/runs/{id})"""
        return self._call("GET", f"/v1/identity/runs/{_q(id_)}", query=query)

    def get_identity_runs_by_id_receipt(self, id_, query=None):
        """The sealed receipt of a starter or leaver run: every system's step as it read back, fingerprinted for an auditor (GET /v1/identity/runs/{id}/receipt)"""
        return self._call("GET", f"/v1/identity/runs/{_q(id_)}/receipt", query=query)

    def get_incidents(self, query=None):
        """List incidents (GET /v1/incidents)"""
        return self._call("GET", f"/v1/incidents", query=query)

    def get_incidents_by_id(self, id_, query=None):
        """Read an incident (GET /v1/incidents/{id})"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}", query=query)

    def get_incidents_by_id_audiences(self, id_, query=None):
        """Read the incident told four ways - responders, owners, support and customers - each saying what wrote it and whether a person read it (GET /v1/incidents/{id}/audiences)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/audiences", query=query)

    def get_incidents_by_id_conversations(self, id_, query=None):
        """List the conversations a person started from an incident's own page, newest first (GET /v1/incidents/{id}/conversations)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/conversations", query=query)

    def get_incidents_by_id_dependencies(self, id_, query=None):
        """Read what an incident's asset rests on, how recently each link was seen, and how that lowers the diagnosis (GET /v1/incidents/{id}/dependencies)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/dependencies", query=query)

    def get_incidents_by_id_evidence_pack(self, id_, query=None):
        """Export an incident's evidence as one notarised file anyone can check offline (GET /v1/incidents/{id}/evidence-pack)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/evidence-pack", query=query)

    def get_incidents_by_id_fix_film(self, id_, query=None):
        """Read an incident's fix film - before, each step and after - or download it as one notarised file (GET /v1/incidents/{id}/fix-film)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/fix-film", query=query)

    def get_incidents_by_id_plan(self, id_, query=None):
        """Read every cause Xovris is weighing for an incident and what tested each (GET /v1/incidents/{id}/plan)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/plan", query=query)

    def get_incidents_by_id_receipts_by_receipt_id_signed(self, id_, receipt_id, query=None):
        """Download a fix's receipt, signed so you can check it yourself (GET /v1/incidents/{id}/receipts/{receiptId}/signed)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/receipts/{_q(receipt_id)}/signed", query=query)

    def get_incidents_by_id_record(self, id_, query=None):
        """Replay every step Xovris took on an incident - what it read, changed and proved, and how each change is taken back (GET /v1/incidents/{id}/record)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/record", query=query)

    def get_incidents_by_id_record_export(self, id_, query=None):
        """Download an incident's recording as a file that proves itself - signed where signing is on (GET /v1/incidents/{id}/record/export)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/record/export", query=query)

    def get_incidents_by_id_restore_options(self, id_, query=None):
        """Read the record and versions an incident can be restored to (GET /v1/incidents/{id}/restore-options)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/restore-options", query=query)

    def get_incidents_by_id_review(self, id_, query=None):
        """Read an incident's review written from its record - its timeline, everyone told and how, the cause and the proof (GET /v1/incidents/{id}/review)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/review", query=query)

    def get_incidents_by_id_room(self, id_, query=None):
        """See who is on an incident now and who worked it today (GET /v1/incidents/{id}/room)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/room", query=query)

    def get_incidents_by_id_runs_by_run_id(self, id_, run_id, query=None):
        """Read one run of an incident's check in full - its status, headers and what it read (GET /v1/incidents/{id}/runs/{runId})"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/runs/{_q(run_id)}", query=query)

    def get_incidents_by_id_runs_by_run_id_proof(self, id_, run_id, query=None):
        """Download a fix's signed proof - the cause, the tests before and after and their verdicts (GET /v1/incidents/{id}/runs/{runId}/proof)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/runs/{_q(run_id)}/proof", query=query)

    def get_incidents_by_id_shares(self, id_, query=None):
        """List an incident's shared links (GET /v1/incidents/{id}/shares)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/shares", query=query)

    def get_incidents_by_id_similar(self, id_, query=None):
        """Read the incidents that look like this one, each with why (GET /v1/incidents/{id}/similar)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/similar", query=query)

    def get_incidents_by_id_stakeholders(self, id_, query=None):
        """See who is told about an incident, on which channel and how often, with every message sent and how it landed (GET /v1/incidents/{id}/stakeholders)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/stakeholders", query=query)

    def get_incidents_by_id_workspace(self, id_, query=None):
        """Read an incident's working notes, the same on every device (GET /v1/incidents/{id}/workspace)"""
        return self._call("GET", f"/v1/incidents/{_q(id_)}/workspace", query=query)

    def get_incident_scopes(self, query=None):
        """Read how often people here chose each window on an incident's record, for one kind or every kind (GET /v1/incident-scopes)"""
        return self._call("GET", f"/v1/incident-scopes", query=query)

    def get_incidents_shared(self, query=None):
        """Count the incidents sharing a value (GET /v1/incidents/shared)"""
        return self._call("GET", f"/v1/incidents/shared", query=query)

    def get_integrations_slack(self, query=None):
        """See whether Slack is connected, or why not (GET /v1/integrations/slack)"""
        return self._call("GET", f"/v1/integrations/slack", query=query)

    def get_issues(self, query=None):
        """List errors (GET /v1/issues)"""
        return self._call("GET", f"/v1/issues", query=query)

    def get_issues_by_id(self, id_, query=None):
        """Read an error (GET /v1/issues/{id})"""
        return self._call("GET", f"/v1/issues/{_q(id_)}", query=query)

    def get_issues_by_id_events(self, id_, query=None):
        """List an error's kept events, newest first (GET /v1/issues/{id}/events)"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/events", query=query)

    def get_issues_by_id_events_by_event_id(self, id_, event_id, query=None):
        """Read one kept event of an error (GET /v1/issues/{id}/events/{eventId})"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/events/{_q(event_id)}", query=query)

    def get_issues_by_id_fields(self, id_, query=None):
        """Read an issue's fields: status, priority, who has it, labels and the rest (GET /v1/issues/{id}/fields)"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/fields", query=query)

    def get_issues_by_id_people(self, id_, query=None):
        """See who has an issue, who opened it, who follows it and who has seen it (GET /v1/issues/{id}/people)"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/people", query=query)

    def get_issues_by_id_sessions(self, id_, query=None):
        """See the sessions an error hit: when, on which page and release, a masked replay and what the person wrote (GET /v1/issues/{id}/sessions)"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/sessions", query=query)

    def get_issues_by_id_similar(self, id_, query=None):
        """Find issues like this one (GET /v1/issues/{id}/similar)"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/similar", query=query)

    def get_issues_by_id_trend(self, id_, query=None):
        """See how often an issue has happened over time (GET /v1/issues/{id}/trend)"""
        return self._call("GET", f"/v1/issues/{_q(id_)}/trend", query=query)

    def get_issues_cycles(self, query=None):
        """See the weeks around this one, each with its issues, how many are done and what was carried in (GET /v1/issues/cycles)"""
        return self._call("GET", f"/v1/issues/cycles", query=query)

    def get_issues_insights(self, query=None):
        """See how issues are opened, taken and closed across the workspace (GET /v1/issues/insights)"""
        return self._call("GET", f"/v1/issues/insights", query=query)

    def get_issues_mine(self, query=None):
        """See the issues given to you, the ones you opened and the ones you follow, with what happened to each (GET /v1/issues/mine)"""
        return self._call("GET", f"/v1/issues/mine", query=query)

    def get_issues_said(self, query=None):
        """Read what people wrote about the workspace's errors (GET /v1/issues/said)"""
        return self._call("GET", f"/v1/issues/said", query=query)

    def get_issues_triage(self, query=None):
        """See every open issue nobody has taken yet, newest first, with who is on triage (GET /v1/issues/triage)"""
        return self._call("GET", f"/v1/issues/triage", query=query)

    def get_live(self, query=None):
        """Follow every change to this workspace's incidents and fixes as it happens, on one stream (GET /v1/live)"""
        return self._call("GET", f"/v1/live", query=query)

    def get_log_archive_destinations(self, query=None):
        """List log archive destinations (GET /v1/log-archive/destinations)"""
        return self._call("GET", f"/v1/log-archive/destinations", query=query)

    def get_log_archive_search(self, query=None):
        """Search archived logs (GET /v1/log-archive/search)"""
        return self._call("GET", f"/v1/log-archive/search", query=query)

    def get_log_connections(self, query=None):
        """List log connections (GET /v1/log-connections)"""
        return self._call("GET", f"/v1/log-connections", query=query)

    def get_log_connections_by_id(self, id_, query=None):
        """Read a log connection (GET /v1/log-connections/{id})"""
        return self._call("GET", f"/v1/log-connections/{_q(id_)}", query=query)

    def get_logs_breakdown(self, query=None):
        """Break the lines a search matched down by any field, with exact counts (GET /v1/logs/breakdown)"""
        return self._call("GET", f"/v1/logs/breakdown", query=query)

    def get_logs_compare(self, query=None):
        """Compare a window of logs with its healthy baseline (GET /v1/logs/compare)"""
        return self._call("GET", f"/v1/logs/compare", query=query)

    def get_logs_export(self, query=None):
        """Export every line a search matches, as CSV or NDJSON (GET /v1/logs/export)"""
        return self._call("GET", f"/v1/logs/export", query=query)

    def get_logs_faults(self, query=None):
        """Read the failing lines as faults, each with its root cause (GET /v1/logs/faults)"""
        return self._call("GET", f"/v1/logs/faults", query=query)

    def get_logs_lines_by_id(self, id_, query=None):
        """Read a log line with its context (GET /v1/logs/lines/{id})"""
        return self._call("GET", f"/v1/logs/lines/{_q(id_)}", query=query)

    def get_logs_patterns(self, query=None):
        """Read log patterns (GET /v1/logs/patterns)"""
        return self._call("GET", f"/v1/logs/patterns", query=query)

    def get_logs_patterns_by_template_id_inspect(self, template_id, query=None):
        """Inspect one kind of log line - each varying part's values across its lines (GET /v1/logs/patterns/{templateId}/inspect)"""
        return self._call("GET", f"/v1/logs/patterns/{_q(template_id)}/inspect", query=query)

    def get_logs_retention(self, query=None):
        """Read how long logs are kept (GET /v1/logs/retention)"""
        return self._call("GET", f"/v1/logs/retention", query=query)

    def get_logs_search(self, query=None):
        """Search logs (GET /v1/logs/search)"""
        return self._call("GET", f"/v1/logs/search", query=query)

    def get_logs_sources(self, query=None):
        """List log sources (GET /v1/logs/sources)"""
        return self._call("GET", f"/v1/logs/sources", query=query)

    def get_logs_tail(self, query=None):
        """Watch log lines arrive live, each judged as it arrives (GET /v1/logs/tail)"""
        return self._call("GET", f"/v1/logs/tail", query=query)

    def get_logs_transactions(self, query=None):
        """Follow the lines of one process - an order, a request, a job - by the field they share (GET /v1/logs/transactions)"""
        return self._call("GET", f"/v1/logs/transactions", query=query)

    def get_mail_audit(self, query=None):
        """Check a domain's mail records and see what Xovris writes for each finding (GET /v1/mail/audit)"""
        return self._call("GET", f"/v1/mail/audit", query=query)

    def get_mail_keys(self, query=None):
        """See the DKIM records Xovris holds for a domain, each with the mail service it came from (GET /v1/mail/keys)"""
        return self._call("GET", f"/v1/mail/keys", query=query)

    def get_major_comms_rules(self, query=None):
        """Read who is told when a major incident of each kind and severity is declared (GET /v1/major-comms/rules)"""
        return self._call("GET", f"/v1/major-comms/rules", query=query)

    def get_make_by_id(self, id_, query=None):
        """Read a making: where it stands, and each file it made with its own address, the file itself inside the answer where it fits (GET /v1/make/{id})"""
        return self._call("GET", f"/v1/make/{_q(id_)}", query=query)

    def get_make_by_id_files_by_name(self, id_, name, query=None):
        """Read one file a making kept, served as its own type in a sandbox so it never runs as Xovris (GET /v1/make/{id}/files/{name})"""
        return self._call("GET", f"/v1/make/{_q(id_)}/files/{_q(name)}", query=query)

    def get_mcp(self, query=None):
        """Open the stream an MCP session listens on (GET /v1/mcp)"""
        return self._call("GET", f"/v1/mcp", query=query)

    def get_me(self, query=None):
        """Read who you are and your workspaces (GET /v1/me)"""
        return self._call("GET", f"/v1/me", query=query)

    def get_me_clients(self, query=None):
        """See every client workspace your provider works in, from your side: the role it gives you, until when, and what you did there (GET /v1/me/clients)"""
        return self._call("GET", f"/v1/me/clients", query=query)

    def get_me_learned(self, query=None):
        """Read what Xovris has learned about you and your systems, and how to erase it (GET /v1/me/learned)"""
        return self._call("GET", f"/v1/me/learned", query=query)

    def get_members(self, query=None):
        """List members (GET /v1/members)"""
        return self._call("GET", f"/v1/members", query=query)

    def get_members_invitations(self, query=None):
        """See the open invitations to this workspace, each with its role and when it expires (GET /v1/members/invitations)"""
        return self._call("GET", f"/v1/members/invitations", query=query)

    def get_me_preferences(self, query=None):
        """Read your own appearance and notification choices (GET /v1/me/preferences)"""
        return self._call("GET", f"/v1/me/preferences", query=query)

    def get_metrics_alerts(self, query=None):
        """List metric alerts (GET /v1/metrics/alerts)"""
        return self._call("GET", f"/v1/metrics/alerts", query=query)

    def get_metrics_entities(self, query=None):
        """List what reports metrics (GET /v1/metrics/entities)"""
        return self._call("GET", f"/v1/metrics/entities", query=query)

    def get_metrics_findings(self, query=None):
        """List infrastructure findings (GET /v1/metrics/findings)"""
        return self._call("GET", f"/v1/metrics/findings", query=query)

    def get_metrics_gpu_idle(self, query=None):
        """Read idle GPU time and its cost (GET /v1/metrics/gpu-idle)"""
        return self._call("GET", f"/v1/metrics/gpu-idle", query=query)

    def get_metrics_inference(self, query=None):
        """Read AI model latency (GET /v1/metrics/inference)"""
        return self._call("GET", f"/v1/metrics/inference", query=query)

    def get_metrics_query(self, query=None):
        """Query metrics (GET /v1/metrics/query)"""
        return self._call("GET", f"/v1/metrics/query", query=query)

    def get_models_own(self, query=None):
        """See the model your workspace added for Xovris to plan code fixes with - its kind, where it runs and its key's fingerprint, never the key (GET /v1/models/own)"""
        return self._call("GET", f"/v1/models/own", query=query)

    def get_msp_grants(self, query=None):
        """List the MSPs you granted access (GET /v1/msp/grants)"""
        return self._call("GET", f"/v1/msp/grants", query=query)

    def get_msp_shared_causes(self, query=None):
        """Read what is failing for more than one of the workspaces that granted you access, at once (GET /v1/msp/shared-causes)"""
        return self._call("GET", f"/v1/msp/shared-causes", query=query)

    def get_msp_success_rates(self, query=None):
        """Read what Xovris fixed and proved on each system across the workspaces that granted you access (GET /v1/msp/success-rates)"""
        return self._call("GET", f"/v1/msp/success-rates", query=query)

    def get_msp_tenants(self, query=None):
        """List the workspaces that granted you access (GET /v1/msp/tenants)"""
        return self._call("GET", f"/v1/msp/tenants", query=query)

    def get_needs_you(self, query=None):
        """What waits on you - incidents, requests and stopped work, each counted once, the one count every surface draws (GET /v1/needs-you)"""
        return self._call("GET", f"/v1/needs-you", query=query)

    def get_network_defence_advisories(self, query=None):
        """Every CISA and NCSC advisory Xovris read by itself: published, hunted, how long that took, and what it found here (GET /v1/network-defence/advisories)"""
        return self._call("GET", f"/v1/network-defence/advisories", query=query)

    def get_network_defence_firewall_policy_runs(self, query=None):
        """See each machine's firewall policy run with what it proved (GET /v1/network-defence/firewall-policy/runs)"""
        return self._call("GET", f"/v1/network-defence/firewall-policy/runs", query=query)

    def get_network_defence_freshness(self, query=None):
        """See how current each threat feed and list behind your defences is (GET /v1/network-defence/freshness)"""
        return self._call("GET", f"/v1/network-defence/freshness", query=query)

    def get_network_defence_hunts(self, query=None):
        """See where your network memory matched a threat indicator (GET /v1/network-defence/hunts)"""
        return self._call("GET", f"/v1/network-defence/hunts", query=query)

    def get_network_defence_incidents(self, query=None):
        """See network incidents with their real risk and a plain explanation (GET /v1/network-defence/incidents)"""
        return self._call("GET", f"/v1/network-defence/incidents", query=query)

    def get_network_defence_incidents_by_id(self, id_, query=None):
        """See one network incident's whole record: its timeline, the devices it touched, every decision and action with its proof (GET /v1/network-defence/incidents/{id})"""
        return self._call("GET", f"/v1/network-defence/incidents/{_q(id_)}", query=query)

    def get_network_defence_incidents_by_id_contain(self, id_, query=None):
        """See the containment of the machine a network incident reached: what it keeps, what was proved, and whether it was lifted (GET /v1/network-defence/incidents/{id}/contain)"""
        return self._call("GET", f"/v1/network-defence/incidents/{_q(id_)}/contain", query=query)

    def get_network_defence_incidents_by_id_evidence(self, id_, query=None):
        """See a network incident's raw evidence, each line with the digest it was received under (GET /v1/network-defence/incidents/{id}/evidence)"""
        return self._call("GET", f"/v1/network-defence/incidents/{_q(id_)}/evidence", query=query)

    def get_network_defence_preventions(self, query=None):
        """See every block asked for, with the proof that it stops the traffic or why it was taken out (GET /v1/network-defence/preventions)"""
        return self._call("GET", f"/v1/network-defence/preventions", query=query)

    def get_network_defence_sensors(self, query=None):
        """See every network sensor's own health: reporting or stopped, the traffic it handles and the share it misses (GET /v1/network-defence/sensors)"""
        return self._call("GET", f"/v1/network-defence/sensors", query=query)

    def get_network_defence_suppressions(self, query=None):
        """List what your workspace has said is expected on its network (GET /v1/network-defence/suppressions)"""
        return self._call("GET", f"/v1/network-defence/suppressions", query=query)

    def get_network_devices_config_by_check_id(self, check_id, query=None):
        """See where a device change stands - its plan, its backup and what the device reads back (GET /v1/network/devices/config/{checkId})"""
        return self._call("GET", f"/v1/network/devices/config/{_q(check_id)}", query=query)

    def get_network_map(self, query=None):
        """See how your network is wired: every device read on it and the links between them, with their speed and traffic (GET /v1/network/map)"""
        return self._call("GET", f"/v1/network/map", query=query)

    def get_network_review_by_check_id(self, check_id, query=None):
        """See where a network device's review stands, with what it found (GET /v1/network/review/{checkId})"""
        return self._call("GET", f"/v1/network/review/{_q(check_id)}", query=query)

    def get_network_reviews(self, query=None):
        """List the network device reviews Xovris has run, newest first (GET /v1/network/reviews)"""
        return self._call("GET", f"/v1/network/reviews", query=query)

    def get_network_sources_netbox_by_check_id(self, check_id, query=None):
        """See where a NetBox read stands (GET /v1/network/sources/netbox/{checkId})"""
        return self._call("GET", f"/v1/network/sources/netbox/{_q(check_id)}", query=query)

    def get_network_troubleshoot_by_check_id(self, check_id, query=None):
        """See where a network troubleshoot stands, with each step Xovris read (GET /v1/network/troubleshoot/{checkId})"""
        return self._call("GET", f"/v1/network/troubleshoot/{_q(check_id)}", query=query)

    def get_now(self, query=None):
        """Read every figure your home draws - who needs you, security, devices, checks and today's counters (GET /v1/now)"""
        return self._call("GET", f"/v1/now", query=query)

    def get_oauth_apps(self, query=None):
        """List the OAuth apps this workspace publishes (GET /v1/oauth/apps)"""
        return self._call("GET", f"/v1/oauth/apps", query=query)

    def get_oauth_authorize(self, query=None):
        """Read what an app asks to be allowed to do (GET /v1/oauth/authorize)"""
        return self._call("GET", f"/v1/oauth/authorize", query=query)

    def get_oauth_device_by_code(self, code, query=None):
        """Read the sign-in request behind a device code (GET /v1/oauth/device/{code})"""
        return self._call("GET", f"/v1/oauth/device/{_q(code)}", query=query)

    def get_oauth_grants(self, query=None):
        """List the apps people here have allowed (GET /v1/oauth/grants)"""
        return self._call("GET", f"/v1/oauth/grants", query=query)

    def get_oncall(self, query=None):
        """See who is on call, the schedules and who is away (GET /v1/oncall)"""
        return self._call("GET", f"/v1/oncall", query=query)

    def get_oncall_drills(self, query=None):
        """Read each escalation policy's newest drill, hop by hop (GET /v1/oncall/drills)"""
        return self._call("GET", f"/v1/oncall/drills", query=query)

    def get_oncall_drills_by_id(self, id_, query=None):
        """Read one drill: every page it made and whether a person acknowledged it (GET /v1/oncall/drills/{id})"""
        return self._call("GET", f"/v1/oncall/drills/{_q(id_)}", query=query)

    def get_oncall_imports(self, query=None):
        """List your on-call imports (GET /v1/oncall/imports)"""
        return self._call("GET", f"/v1/oncall/imports", query=query)

    def get_oncall_schedules_by_id_timeline(self, id_, query=None):
        """See a schedule's timeline - who is on call when (GET /v1/oncall/schedules/{id}/timeline)"""
        return self._call("GET", f"/v1/oncall/schedules/{_q(id_)}/timeline", query=query)

    def get_openapi_json(self, query=None):
        """Read this API's OpenAPI document (GET /v1/openapi.json)"""
        return self._call("GET", f"/v1/openapi.json", query=query)

    def get_outcomes_leaders(self, query=None):
        """See how each feature compares with the leading tools in its area (GET /v1/outcomes/leaders)"""
        return self._call("GET", f"/v1/outcomes/leaders", query=query)

    def get_outcomes_learning(self, query=None):
        """See whether Xovris is getting quicker and better at each kind of problem (GET /v1/outcomes/learning)"""
        return self._call("GET", f"/v1/outcomes/learning", query=query)

    def get_outcomes_speed(self, query=None):
        """Read how quickly Xovris found causes and proved fixes in this workspace (GET /v1/outcomes/speed)"""
        return self._call("GET", f"/v1/outcomes/speed", query=query)

    def get_partners(self, query=None):
        """List your partner keys (GET /v1/partners)"""
        return self._call("GET", f"/v1/partners", query=query)

    def get_partners_accounts(self, query=None):
        """List the accounts you provisioned (GET /v1/partners/accounts)"""
        return self._call("GET", f"/v1/partners/accounts", query=query)

    def get_partners_accounts_by_id_export(self, id_, query=None):
        """Download a removed account's export (GET /v1/partners/accounts/{id}/export)"""
        return self._call("GET", f"/v1/partners/accounts/{_q(id_)}/export", query=query)

    def get_partners_sandbox_keys(self, query=None):
        """List your provisioning sandbox keys (GET /v1/partners/sandbox-keys)"""
        return self._call("GET", f"/v1/partners/sandbox-keys", query=query)

    def get_partners_statements(self, query=None):
        """List your monthly partner statements (GET /v1/partners/statements)"""
        return self._call("GET", f"/v1/partners/statements", query=query)

    def get_payments_connections(self, query=None):
        """Read every connected payment provider's sales, failed payments, disputes and payouts (GET /v1/payments/connections)"""
        return self._call("GET", f"/v1/payments/connections", query=query)

    def get_people_outside(self, query=None):
        """Everyone working here said as one of the workspace's own people or from outside its domains, with the rule for outside people and any end their access carries (GET /v1/people/outside)"""
        return self._call("GET", f"/v1/people/outside", query=query)

    def get_permissions(self, query=None):
        """Read every permission by area - what each built-in and custom role holds of it, and the groups this workspace's plan offers (GET /v1/permissions)"""
        return self._call("GET", f"/v1/permissions", query=query)

    def get_pins_incidents(self, query=None):
        """The incidents you have pinned, the last one first and every open one before a closed one (GET /v1/pins/incidents)"""
        return self._call("GET", f"/v1/pins/incidents", query=query)

    def get_pipelines_derived(self, query=None):
        """List metrics made from log lines (GET /v1/pipelines/derived)"""
        return self._call("GET", f"/v1/pipelines/derived", query=query)

    def get_pipelines_derived_by_id_series(self, id_, query=None):
        """Read a derived metric's values (GET /v1/pipelines/derived/{id}/series)"""
        return self._call("GET", f"/v1/pipelines/derived/{_q(id_)}/series", query=query)

    def get_pipelines_derived_proposals(self, query=None):
        """List metrics Xovris suggests from your logs (GET /v1/pipelines/derived/proposals)"""
        return self._call("GET", f"/v1/pipelines/derived/proposals", query=query)

    def get_pipelines_diet(self, query=None):
        """Read which log lines are kept and dropped (GET /v1/pipelines/diet)"""
        return self._call("GET", f"/v1/pipelines/diet", query=query)

    def get_pipelines_rules(self, query=None):
        """List log pipeline rules (GET /v1/pipelines/rules)"""
        return self._call("GET", f"/v1/pipelines/rules", query=query)

    def get_pipelines_rules_accuracy(self, query=None):
        """Read how accurately the rules matched (GET /v1/pipelines/rules/accuracy)"""
        return self._call("GET", f"/v1/pipelines/rules/accuracy", query=query)

    def get_procedures(self, query=None):
        """List your runbooks and their approved versions (GET /v1/procedures)"""
        return self._call("GET", f"/v1/procedures", query=query)

    def get_procedures_by_id(self, id_, query=None):
        """Read one runbook with its versions (GET /v1/procedures/{id})"""
        return self._call("GET", f"/v1/procedures/{_q(id_)}", query=query)

    def get_procedures_library(self, query=None):
        """Read your account's private library of approved procedures (GET /v1/procedures/library)"""
        return self._call("GET", f"/v1/procedures/library", query=query)

    def get_profiles(self, query=None):
        """List the profiles kept for a window, by service and kind (GET /v1/profiles)"""
        return self._call("GET", f"/v1/profiles", query=query)

    def get_profiles_diff(self, query=None):
        """Compare a service's profiles across two windows and see what moved (GET /v1/profiles/diff)"""
        return self._call("GET", f"/v1/profiles/diff", query=query)

    def get_profiles_flame(self, query=None):
        """Draw a service's flame graph for a window, with its hottest frames (GET /v1/profiles/flame)"""
        return self._call("GET", f"/v1/profiles/flame", query=query)

    def get_protocol_connections(self, query=None):
        """See every system connected by its own protocol, with what Xovris read of it (GET /v1/protocol-connections)"""
        return self._call("GET", f"/v1/protocol-connections", query=query)

    def get_provisioning_acts(self, query=None):
        """What the identity provider did here, newest first - who it invited or turned off, which group it made, changed or removed - a page at a time (GET /v1/provisioning/acts)"""
        return self._call("GET", f"/v1/provisioning/acts", query=query)

    def get_public_account(self, query=None):
        """See who is signed in on this page, and their plan and day (GET /v1/public/account)"""
        return self._call("GET", f"/v1/public/account", query=query)

    def get_public_address_by_slug(self, slug, query=None):
        """Find out whether a xovris.ai address is live or has moved (GET /v1/public/address/{slug})"""
        return self._call("GET", f"/v1/public/address/{_q(slug)}", query=query)

    def get_public_ai_activity(self, query=None):
        """What Xovris did across every workspace - never published (GET /v1/public/ai-activity)"""
        return self._call("GET", f"/v1/public/ai-activity", query=query)

    def get_public_badge_by_file(self, file, query=None):
        """Read a live badge (GET /v1/public/badge/{file})"""
        return self._call("GET", f"/v1/public/badge/{_q(file)}", query=query)

    def get_public_build_publish_by_id(self, id_, query=None):
        """Read how a page being put live is getting on (GET /v1/public/build/publish/{id})"""
        return self._call("GET", f"/v1/public/build/publish/{_q(id_)}", query=query)

    def get_public_catalogue_matrix(self, query=None):
        """Read what each service Xovris connects to can read and change, how it was verified and how fresh that is, beside each plan (GET /v1/public/catalogue/matrix)"""
        return self._call("GET", f"/v1/public/catalogue/matrix", query=query)

    def get_public_catalogue_plan(self, query=None):
        """Read where Xovris's coverage goes next across what companies and homes run on, each area's gap said plainly (GET /v1/public/catalogue/plan)"""
        return self._call("GET", f"/v1/public/catalogue/plan", query=query)

    def get_public_catalogue_scopes(self, query=None):
        """Read every permission a connection asks for, in plain words, why it is needed and what it enables (GET /v1/public/catalogue/scopes)"""
        return self._call("GET", f"/v1/public/catalogue/scopes", query=query)

    def get_public_catalogue_services(self, query=None):
        """List the services Xovris connects to (GET /v1/public/catalogue/services)"""
        return self._call("GET", f"/v1/public/catalogue/services", query=query)

    def get_public_catalogue_totals(self, query=None):
        """Read the catalogue's totals (GET /v1/public/catalogue/totals)"""
        return self._call("GET", f"/v1/public/catalogue/totals", query=query)

    def get_public_check_challenge(self, query=None):
        """Get the free check's background challenge (GET /v1/public/check/challenge)"""
        return self._call("GET", f"/v1/public/check/challenge", query=query)

    def get_public_check_proof(self, query=None):
        """Prove you own a domain for the free check (GET /v1/public/check/proof)"""
        return self._call("GET", f"/v1/public/check/proof", query=query)

    def get_public_check_rules(self, query=None):
        """Read the free check's rules (GET /v1/public/check/rules)"""
        return self._call("GET", f"/v1/public/check/rules", query=query)

    def get_public_conversations_by_token(self, token, query=None):
        """Read a conversation someone shared with a link (GET /v1/public/conversations/{token})"""
        return self._call("GET", f"/v1/public/conversations/{_q(token)}", query=query)

    def get_public_counters(self, query=None):
        """Read the live counters of Xovris's own systems (GET /v1/public/counters)"""
        return self._call("GET", f"/v1/public/counters", query=query)

    def get_public_dashboards_by_token(self, token, query=None):
        """Read a shared dashboard (GET /v1/public/dashboards/{token})"""
        return self._call("GET", f"/v1/public/dashboards/{_q(token)}", query=query)

    def get_public_demo_slots(self, query=None):
        """See the times a person from Xovris can show you Xovris (GET /v1/public/demo/slots)"""
        return self._call("GET", f"/v1/public/demo/slots", query=query)

    def get_public_device_app_by_target(self, target, query=None):
        """Download the Xovris device app for one system - the file the one-line install fetches (GET /v1/public/device-app/{target})"""
        return self._call("GET", f"/v1/public/device-app/{_q(target)}", query=query)

    def get_public_down(self, query=None):
        """Read whether popular services are up (GET /v1/public/down)"""
        return self._call("GET", f"/v1/public/down", query=query)

    def get_public_down_by_service(self, service, query=None):
        """Read a service's last day of probes (GET /v1/public/down/{service})"""
        return self._call("GET", f"/v1/public/down/{_q(service)}", query=query)

    def get_public_handoff_by_token(self, token, query=None):
        """Open a waiting job's one-press page from its notice, no sign-in needed (GET /v1/public/handoff/{token})"""
        return self._call("GET", f"/v1/public/handoff/{_q(token)}", query=query)

    def get_public_hostname_by_host(self, host, query=None):
        """Find which workspace address an attached domain serves (GET /v1/public/hostname/{host})"""
        return self._call("GET", f"/v1/public/hostname/{_q(host)}", query=query)

    def get_public_hosts(self, query=None):
        """Download every outside host Xovris has identified, so a page's scripts are matched on your own device (GET /v1/public/hosts)"""
        return self._call("GET", f"/v1/public/hosts", query=query)

    def get_public_integration_programme(self, query=None):
        """Read the integration programme (GET /v1/public/integration-programme)"""
        return self._call("GET", f"/v1/public/integration-programme", query=query)

    def get_public_integration_programme_services(self, query=None):
        """List the integration programme's services (GET /v1/public/integration-programme/services)"""
        return self._call("GET", f"/v1/public/integration-programme/services", query=query)

    def get_public_learning(self, query=None):
        """Read how Xovris's speed and first-time fixes change week by week (GET /v1/public/learning)"""
        return self._call("GET", f"/v1/public/learning", query=query)

    def get_public_live_previews_by_id(self, id_, query=None):
        """Read a shared page - its newest version, or wait for the next one (GET /v1/public/live-previews/{id})"""
        return self._call("GET", f"/v1/public/live-previews/{_q(id_)}", query=query)

    def get_public_mail_check_by_token(self, token, query=None):
        """What the message sent to an email check proved - SPF, DKIM, DMARC and its encryption (GET /v1/public/mail-check/{token})"""
        return self._call("GET", f"/v1/public/mail-check/{_q(token)}", query=query)

    def get_public_mcp(self, query=None):
        """The free MCP endpoint answers POST only (GET /v1/public/mcp)"""
        return self._call("GET", f"/v1/public/mcp", query=query)

    def get_public_memory(self, query=None):
        """Read what Xovris remembers of the signed-in person - preferences, decisions, past fixes and what they asked it to keep (GET /v1/public/memory)"""
        return self._call("GET", f"/v1/public/memory", query=query)

    def get_public_models(self, query=None):
        """List every AI model the signed-in person can choose in a chat, with its price (GET /v1/public/models)"""
        return self._call("GET", f"/v1/public/models", query=query)

    def get_public_models_count(self, query=None):
        """See how many AI models and makers you can choose from once signed in (GET /v1/public/models/count)"""
        return self._call("GET", f"/v1/public/models/count", query=query)

    def get_public_own_controls(self, query=None):
        """See the trust page's controls, each lit from Xovris's own records (GET /v1/public/own-controls)"""
        return self._call("GET", f"/v1/public/own-controls", query=query)

    def get_public_plans(self, query=None):
        """Read every plan's price in every currency, what it is priced on and what it includes, without signing in (GET /v1/public/plans)"""
        return self._call("GET", f"/v1/public/plans", query=query)

    def get_public_random_service_test(self, query=None):
        """Read a randomly drawn sample of service tests (GET /v1/public/random-service-test)"""
        return self._call("GET", f"/v1/public/random-service-test", query=query)

    def get_public_receipt_key(self, query=None):
        """Read the public key that fix receipts are signed with (GET /v1/public/receipt-key)"""
        return self._call("GET", f"/v1/public/receipt-key", query=query)

    def get_public_recipes_records(self, query=None):
        """Read each set-up method's verified record before it runs (GET /v1/public/recipes/records)"""
        return self._call("GET", f"/v1/public/recipes/records", query=query)

    def get_public_results(self, query=None):
        """Read Xovris's published results (GET /v1/public/results)"""
        return self._call("GET", f"/v1/public/results", query=query)

    def get_public_run_lessons(self, query=None):
        """Read the lessons and earlier runs of the signed-in person's workspace, for a run on their own computer (GET /v1/public/run-lessons)"""
        return self._call("GET", f"/v1/public/run-lessons", query=query)

    def get_public_sample(self, query=None):
        """A sample workspace to look around in without an account (GET /v1/public/sample)"""
        return self._call("GET", f"/v1/public/sample", query=query)

    def get_public_schemas_xos_v1_json(self, query=None):
        """The XOS schema every verdict, proof and confidence is written in (GET /v1/public/schemas/xos-v1.json)"""
        return self._call("GET", f"/v1/public/schemas/xos-v1.json", query=query)

    def get_public_scoreboard(self, query=None):
        """Read the scoreboard of verified fixes, root causes and false fixes - Xovris beside the best rival (GET /v1/public/scoreboard)"""
        return self._call("GET", f"/v1/public/scoreboard", query=query)

    def get_public_sdks(self, query=None):
        """List every SDK Xovris reads (GET /v1/public/sdks)"""
        return self._call("GET", f"/v1/public/sdks", query=query)

    def get_public_self_fixes(self, query=None):
        """Read the times Xovris healed its own service, what it did and how it was undone (GET /v1/public/self-fixes)"""
        return self._call("GET", f"/v1/public/self-fixes", query=query)

    def get_public_sign_in_by_provider(self, provider, query=None):
        """Sign in with Google, GitHub, Apple or Microsoft, and come back to the page (GET /v1/public/sign-in/{provider})"""
        return self._call("GET", f"/v1/public/sign-in/{_q(provider)}", query=query)

    def get_public_site_errors(self, query=None):
        """Read the website error reporting contract (GET /v1/public/site-errors)"""
        return self._call("GET", f"/v1/public/site-errors", query=query)

    def get_public_speed(self, query=None):
        """Read how quickly Xovris finds causes and proves fixes, by kind of problem (GET /v1/public/speed)"""
        return self._call("GET", f"/v1/public/speed", query=query)

    def get_public_sso_domain(self, query=None):
        """See whether an email address signs in through its company's own identity provider (GET /v1/public/sso/domain)"""
        return self._call("GET", f"/v1/public/sso/domain", query=query)

    def get_public_status(self, query=None):
        """Read Xovris's own status (GET /v1/public/status)"""
        return self._call("GET", f"/v1/public/status", query=query)

    def get_public_status_by_slug(self, slug, query=None):
        """Read a workspace's public status page (GET /v1/public/status/{slug})"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}", query=query)

    def get_public_status_by_slug_badge_svg(self, slug, query=None):
        """A workspace's status as one image any site shows (GET /v1/public/status/{slug}/badge.svg)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/badge.svg", query=query)

    def get_public_status_by_slug_confirm(self, slug, query=None):
        """The press that confirms a status page subscription; opening it changes nothing (GET /v1/public/status/{slug}/confirm)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/confirm", query=query)

    def get_public_status_by_slug_feed_atom(self, slug, query=None):
        """A workspace's status page as an Atom feed for any reader (GET /v1/public/status/{slug}/feed.atom)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/feed.atom", query=query)

    def get_public_status_by_slug_feed_rss(self, slug, query=None):
        """A workspace's status page as an RSS 2.0 feed for any reader (GET /v1/public/status/{slug}/feed.rss)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/feed.rss", query=query)

    def get_public_status_by_slug_incidents_by_id(self, slug, id_, query=None):
        """Read one incident on a workspace's status page, with every update (GET /v1/public/status/{slug}/incidents/{id})"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/incidents/{_q(id_)}", query=query)

    def get_public_status_by_slug_read(self, slug, query=None):
        """One view of a workspace's status page counted by the pixel it loads; nothing of the reader is kept (GET /v1/public/status/{slug}/read)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/read", query=query)

    def get_public_status_by_slug_unlock(self, slug, query=None):
        """A private status page opened for a signed-in member of its workspace - the hop back from the command centre marks that browser (GET /v1/public/status/{slug}/unlock)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/unlock", query=query)

    def get_public_status_by_slug_unsubscribe(self, slug, query=None):
        """The press that stops a status page's emails; opening it changes nothing (GET /v1/public/status/{slug}/unsubscribe)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/unsubscribe", query=query)

    def get_public_status_by_slug_widget(self, slug, query=None):
        """A workspace's live status in one frame any site shows (GET /v1/public/status/{slug}/widget)"""
        return self._call("GET", f"/v1/public/status/{_q(slug)}/widget", query=query)

    def get_public_status_feed(self, query=None):
        """Follow incidents as a feed in any reader, no email needed (GET /v1/public/status/feed)"""
        return self._call("GET", f"/v1/public/status/feed", query=query)

    def get_public_status_host_by_host(self, host, query=None):
        """Read a workspace's status page on its own hostname (GET /v1/public/status-host/{host})"""
        return self._call("GET", f"/v1/public/status-host/{_q(host)}", query=query)

    def get_public_sub_processors(self, query=None):
        """Read the companies that process customer data for Xovris, and why (GET /v1/public/sub-processors)"""
        return self._call("GET", f"/v1/public/sub-processors", query=query)

    def get_public_tv_pairings_by_pairing_id(self, pairing_id, query=None):
        """Check whether a TV has been paired (GET /v1/public/tv/pairings/{pairingId})"""
        return self._call("GET", f"/v1/public/tv/pairings/{_q(pairing_id)}", query=query)

    def get_queries(self, query=None):
        """List saved queries (GET /v1/queries)"""
        return self._call("GET", f"/v1/queries", query=query)

    def get_readings(self, query=None):
        """List what Xovris read by itself, and what it found (GET /v1/readings)"""
        return self._call("GET", f"/v1/readings", query=query)

    def get_recoveries(self, query=None):
        """List the money recovered in a month (GET /v1/recoveries)"""
        return self._call("GET", f"/v1/recoveries", query=query)

    def get_reports_owner(self, query=None):
        """Read the owner's monthly report: what broke, what was fixed and what it saved (GET /v1/reports/owner)"""
        return self._call("GET", f"/v1/reports/owner", query=query)

    def get_reviews(self, query=None):
        """See your code reviews over time - raised, fixed, proven and dismissed (GET /v1/reviews)"""
        return self._call("GET", f"/v1/reviews", query=query)

    def get_reviews_bill(self, query=None):
        """Read a repository's bill of materials, its advisories and how each package got there, or download it as CycloneDX or SPDX (GET /v1/reviews/bill)"""
        return self._call("GET", f"/v1/reviews/bill", query=query)

    def get_reviews_by_id(self, id_, query=None):
        """Read one review pass reading by reading - what it read, found and fixed (GET /v1/reviews/{id})"""
        return self._call("GET", f"/v1/reviews/{_q(id_)}", query=query)

    def get_reviews_chats(self, query=None):
        """See the Discord and Google Chat apps connected to Xovris (GET /v1/reviews/chats)"""
        return self._call("GET", f"/v1/reviews/chats", query=query)

    def get_reviews_findings(self, query=None):
        """Narrow the code review findings on every axis at once, with a count on every value (GET /v1/reviews/findings)"""
        return self._call("GET", f"/v1/reviews/findings", query=query)

    def get_reviews_hosts(self, query=None):
        """See the Git hosts connected to Xovris for reviews (GET /v1/reviews/hosts)"""
        return self._call("GET", f"/v1/reviews/hosts", query=query)

    def get_reviews_image_bill(self, query=None):
        """Read a container image's bill of materials from its own registry, or download it as CycloneDX or SPDX (GET /v1/reviews/image-bill)"""
        return self._call("GET", f"/v1/reviews/image-bill", query=query)

    def get_reviews_licence_policy(self, query=None):
        """See your workspace's licence policy and who set it (GET /v1/reviews/licence-policy)"""
        return self._call("GET", f"/v1/reviews/licence-policy", query=query)

    def get_reviews_live(self, query=None):
        """Read the whole live state a code review holds a change to, as one readings document for a local review (GET /v1/reviews/live)"""
        return self._call("GET", f"/v1/reviews/live", query=query)

    def get_reviews_live_hosts(self, query=None):
        """Read the names the workspace's checks reach, which a code review checks a change to hosting against (GET /v1/reviews/live-hosts)"""
        return self._call("GET", f"/v1/reviews/live-hosts", query=query)

    def get_reviews_live_zones(self, query=None):
        """Read the live DNS zones a code review checks a change against (GET /v1/reviews/live-zones)"""
        return self._call("GET", f"/v1/reviews/live-zones", query=query)

    def get_reviews_preferences(self, query=None):
        """Read the code review preferences that apply to a repository (GET /v1/reviews/preferences)"""
        return self._call("GET", f"/v1/reviews/preferences", query=query)

    def get_reviews_queue(self, query=None):
        """Read every open pull request ranked by what each needs next (GET /v1/reviews/queue)"""
        return self._call("GET", f"/v1/reviews/queue", query=query)

    def get_reviews_report(self, query=None):
        """Read the report of your code reviews for a period (GET /v1/reviews/report)"""
        return self._call("GET", f"/v1/reviews/report", query=query)

    def get_reviews_schedules(self, query=None):
        """The workspace's scheduled coding automations and when each runs next (GET /v1/reviews/schedules)"""
        return self._call("GET", f"/v1/reviews/schedules", query=query)

    def get_reviews_standards(self, query=None):
        """See your code reviews' security findings counted by the OWASP Top 10 or the CWE Top 25 (GET /v1/reviews/standards)"""
        return self._call("GET", f"/v1/reviews/standards", query=query)

    def get_reviews_tasks_by_id(self, id_, query=None):
        """Read one coding task: where it is, what was done and the change it made (GET /v1/reviews/tasks/{id})"""
        return self._call("GET", f"/v1/reviews/tasks/{_q(id_)}", query=query)

    def get_reviews_tracker(self, query=None):
        """The tracker the workspace's chosen findings are filed in, never its token (GET /v1/reviews/tracker)"""
        return self._call("GET", f"/v1/reviews/tracker", query=query)

    def get_reviews_views(self, query=None):
        """List the views of the code review findings you saved (GET /v1/reviews/views)"""
        return self._call("GET", f"/v1/reviews/views", query=query)

    def get_role_grants(self, query=None):
        """List the roles given over one thing each - who holds which role over which device, site, network, cloud account, repository or project (GET /v1/role-grants)"""
        return self._call("GET", f"/v1/role-grants", query=query)

    def get_roles(self, query=None):
        """List this workspace's custom roles, and the deleted ones that can still be restored (GET /v1/roles)"""
        return self._call("GET", f"/v1/roles", query=query)

    def get_rum_broken(self, query=None):
        """Screens broken after an HTTP 200 by cohort, their fault, repair and proof (GET /v1/rum/broken)"""
        return self._call("GET", f"/v1/rum/broken", query=query)

    def get_rum_external(self, query=None):
        """Replays read from Sentry, PostHog or Microsoft Clarity (GET /v1/rum/external)"""
        return self._call("GET", f"/v1/rum/external", query=query)

    def get_rum_film(self, query=None):
        """A fix's before-and-after film of what the customer saw (GET /v1/rum/film)"""
        return self._call("GET", f"/v1/rum/film", query=query)

    def get_rum_platforms(self, query=None):
        """Replay, masking, consent, limits and retention for each platform (GET /v1/rum/platforms)"""
        return self._call("GET", f"/v1/rum/platforms", query=query)

    def get_rum_replays_by_session(self, session, query=None):
        """A session's masked replay (GET /v1/rum/replays/{session})"""
        return self._call("GET", f"/v1/rum/replays/{_q(session)}", query=query)

    def get_rum_sessions(self, query=None):
        """Real-user sessions of the last day, with their cohort and broken screens (GET /v1/rum/sessions)"""
        return self._call("GET", f"/v1/rum/sessions", query=query)

    def get_rum_sessions_by_id(self, id_, query=None):
        """One session's masked signals, feedback and replay (GET /v1/rum/sessions/{id})"""
        return self._call("GET", f"/v1/rum/sessions/{_q(id_)}", query=query)

    def get_sandbox(self, query=None):
        """Read your developer sandbox (GET /v1/sandbox)"""
        return self._call("GET", f"/v1/sandbox", query=query)

    def get_scim_v2_groups(self, query=None):
        """The provider's groups, each the team it is here with the people the provider put in it - filtered by displayName, members left out on request (GET /v1/scim/v2/Groups)"""
        return self._call("GET", f"/v1/scim/v2/Groups", query=query)

    def get_scim_v2_groups_by_id(self, id_, query=None):
        """One provisioned group, the team it is here, with the people the provider put in it and the role the team gives (GET /v1/scim/v2/Groups/{id})"""
        return self._call("GET", f"/v1/scim/v2/Groups/{_q(id_)}", query=query)

    def get_scim_v2_resource_types(self, query=None):
        """The SCIM resource types this workspace provisions - people, with their Xovris role, and groups, as teams (GET /v1/scim/v2/ResourceTypes)"""
        return self._call("GET", f"/v1/scim/v2/ResourceTypes", query=query)

    def get_scim_v2_service_provider_config(self, query=None):
        """What this SCIM 2.0 service supports, for the identity provider that connects to it (GET /v1/scim/v2/ServiceProviderConfig)"""
        return self._call("GET", f"/v1/scim/v2/ServiceProviderConfig", query=query)

    def get_scim_v2_users(self, query=None):
        """Everyone the identity provider sees here - members and invitations still waiting - filtered by userName (GET /v1/scim/v2/Users)"""
        return self._call("GET", f"/v1/scim/v2/Users", query=query)

    def get_scim_v2_users_by_id(self, id_, query=None):
        """One provisioned person by their SCIM id, the same before and after their first sign-in (GET /v1/scim/v2/Users/{id})"""
        return self._call("GET", f"/v1/scim/v2/Users/{_q(id_)}", query=query)

    def get_searches(self, query=None):
        """List the searches you saved on a list, and the ones shared with your workspace (GET /v1/searches)"""
        return self._call("GET", f"/v1/searches", query=query)

    def get_security_posture(self, query=None):
        """Read your monthly security score and the fixes that raise it most (GET /v1/security/posture)"""
        return self._call("GET", f"/v1/security/posture", query=query)

    def get_security_stack_actions(self, query=None):
        """See every action Xovris took through your security tools (GET /v1/security-stack/actions)"""
        return self._call("GET", f"/v1/security-stack/actions", query=query)

    def get_security_stack_connections(self, query=None):
        """List the security tools connected to Xovris (GET /v1/security-stack/connections)"""
        return self._call("GET", f"/v1/security-stack/connections", query=query)

    def get_security_stack_devices(self, query=None):
        """List the devices your security tools see (GET /v1/security-stack/devices)"""
        return self._call("GET", f"/v1/security-stack/devices", query=query)

    def get_security_zero_days(self, query=None):
        """What Xovris read as exploited with no CVE, and each maker's report with its contact and exact words (GET /v1/security/zero-days)"""
        return self._call("GET", f"/v1/security/zero-days", query=query)

    def get_sentry_issues(self, query=None):
        """List issues from your Sentry account (GET /v1/sentry/issues)"""
        return self._call("GET", f"/v1/sentry/issues", query=query)

    def get_sessions(self, query=None):
        """List your AI work sessions running in the cloud and what each is doing now (GET /v1/sessions)"""
        return self._call("GET", f"/v1/sessions", query=query)

    def get_sessions_away(self, query=None):
        """Read what your sessions did while you were away (GET /v1/sessions/away)"""
        return self._call("GET", f"/v1/sessions/away", query=query)

    def get_sessions_devices(self, query=None):
        """List the devices that follow your sessions (GET /v1/sessions/devices)"""
        return self._call("GET", f"/v1/sessions/devices", query=query)

    def get_sessions_order(self, query=None):
        """Read the order your devices are told in when a session needs you (GET /v1/sessions/order)"""
        return self._call("GET", f"/v1/sessions/order", query=query)

    def get_settings_ai_limit(self, query=None):
        """Read your monthly limit on AI fixes (GET /v1/settings/ai-limit)"""
        return self._call("GET", f"/v1/settings/ai-limit", query=query)

    def get_settings_autonomy(self, query=None):
        """Read what Xovris may fix on its own (GET /v1/settings/autonomy)"""
        return self._call("GET", f"/v1/settings/autonomy", query=query)

    def get_settings_autonomy_preview(self, query=None):
        """Preview what Xovris would do on its own under a way of acting (GET /v1/settings/autonomy/preview)"""
        return self._call("GET", f"/v1/settings/autonomy/preview", query=query)

    def get_settings_billing(self, query=None):
        """Read your invoices, in exact amounts, and how payment is set up (GET /v1/settings/billing)"""
        return self._call("GET", f"/v1/settings/billing", query=query)

    def get_settings_billing_all(self, query=None):
        """Read one bill of fixed issues across every workspace whose billing you can read (GET /v1/settings/billing/all)"""
        return self._call("GET", f"/v1/settings/billing/all", query=query)

    def get_settings_billing_eligibility(self, query=None):
        """Read the workspace's education and non-profit standing, each with the register readings that settled it (GET /v1/settings/billing/eligibility)"""
        return self._call("GET", f"/v1/settings/billing/eligibility", query=query)

    def get_settings_change_controls(self, query=None):
        """Read when and how Xovris may change things (GET /v1/settings/change-controls)"""
        return self._call("GET", f"/v1/settings/change-controls", query=query)

    def get_settings_change_windows(self, query=None):
        """Read the maintenance windows and freezes in force (GET /v1/settings/change-windows)"""
        return self._call("GET", f"/v1/settings/change-windows", query=query)

    def get_settings_notify_rules(self, query=None):
        """Read who is told what, and on which channels (GET /v1/settings/notify-rules)"""
        return self._call("GET", f"/v1/settings/notify-rules", query=query)

    def get_settings_plan(self, query=None):
        """Read your plan and what you have used (GET /v1/settings/plan)"""
        return self._call("GET", f"/v1/settings/plan", query=query)

    def get_settings_quiet_hours(self, query=None):
        """Read your quiet hours and what a high alert does during them (GET /v1/settings/quiet-hours)"""
        return self._call("GET", f"/v1/settings/quiet-hours", query=query)

    def get_settings_sign_in(self, query=None):
        """Read whether every member must sign in with a passkey, and who has none yet (GET /v1/settings/sign-in)"""
        return self._call("GET", f"/v1/settings/sign-in", query=query)

    def get_settings_spend_limit(self, query=None):
        """Read your monthly spending limit on AI fixes (GET /v1/settings/spend-limit)"""
        return self._call("GET", f"/v1/settings/spend-limit", query=query)

    def get_setup(self, query=None):
        """Read your setup (GET /v1/setup)"""
        return self._call("GET", f"/v1/setup", query=query)

    def get_setup_beginner_report(self, query=None):
        """Read how much a person had to do to get set up (GET /v1/setup/beginner-report)"""
        return self._call("GET", f"/v1/setup/beginner-report", query=query)

    def get_setup_grants(self, query=None):
        """List standing permissions (GET /v1/setup/grants)"""
        return self._call("GET", f"/v1/setup/grants", query=query)

    def get_setup_health(self, query=None):
        """Read your setup's health (GET /v1/setup/health)"""
        return self._call("GET", f"/v1/setup/health", query=query)

    def get_setup_recipes(self, query=None):
        """List every set-up Xovris can run, with what it changes, the keys it needs and the outcome it proves (GET /v1/setup/recipes)"""
        return self._call("GET", f"/v1/setup/recipes", query=query)

    def get_setup_research(self, query=None):
        """List the providers Xovris has researched for this workspace, newest first (GET /v1/setup/research)"""
        return self._call("GET", f"/v1/setup/research", query=query)

    def get_setup_research_by_id(self, id_, query=None):
        """Read what Xovris found about a provider, and what is still unknown (GET /v1/setup/research/{id})"""
        return self._call("GET", f"/v1/setup/research/{_q(id_)}", query=query)

    def get_setup_runs(self, query=None):
        """List your set-ups on the runner (GET /v1/setup/runs)"""
        return self._call("GET", f"/v1/setup/runs", query=query)

    def get_setup_runs_by_id(self, id_, query=None):
        """Read a set-up with its diagnosis and verified outcome (GET /v1/setup/runs/{id})"""
        return self._call("GET", f"/v1/setup/runs/{_q(id_)}", query=query)

    def get_setup_takeovers(self, query=None):
        """List hand-overs and the fixes made in full control (GET /v1/setup/takeovers)"""
        return self._call("GET", f"/v1/setup/takeovers", query=query)

    def get_setup_takeovers_by_id(self, id_, query=None):
        """Read a hand-over (GET /v1/setup/takeovers/{id})"""
        return self._call("GET", f"/v1/setup/takeovers/{_q(id_)}", query=query)

    def get_setup_takeovers_by_id_evidence(self, id_, query=None):
        """See the replayed runs of Xovris's browser for a set-up (GET /v1/setup/takeovers/{id}/evidence)"""
        return self._call("GET", f"/v1/setup/takeovers/{_q(id_)}/evidence", query=query)

    def get_setup_takeovers_by_id_evidence_by_run_by_seq(self, id_, run, seq, query=None):
        """See one recorded step of a set-up, as it happened (GET /v1/setup/takeovers/{id}/evidence/{run}/{seq})"""
        return self._call("GET", f"/v1/setup/takeovers/{_q(id_)}/evidence/{_q(run)}/{_q(seq)}", query=query)

    def get_setup_takeovers_by_id_evidence_by_run_redrive(self, id_, run, query=None):
        """See how a replayed set-up went (GET /v1/setup/takeovers/{id}/evidence/{run}/redrive)"""
        return self._call("GET", f"/v1/setup/takeovers/{_q(id_)}/evidence/{_q(run)}/redrive", query=query)

    def get_setup_takeovers_by_id_frame(self, id_, query=None):
        """Read a hand-over's live view (GET /v1/setup/takeovers/{id}/frame)"""
        return self._call("GET", f"/v1/setup/takeovers/{_q(id_)}/frame", query=query)

    def get_setup_takeovers_plans(self, query=None):
        """List what Xovris can set up for you (GET /v1/setup/takeovers/plans)"""
        return self._call("GET", f"/v1/setup/takeovers/plans", query=query)

    def get_setup_test_alerts(self, query=None):
        """See the test alerts sent and whether each arrived (GET /v1/setup/test-alerts)"""
        return self._call("GET", f"/v1/setup/test-alerts", query=query)

    def get_shell(self, query=None):
        """Read the side menu's figures in one answer (GET /v1/shell)"""
        return self._call("GET", f"/v1/shell", query=query)

    def get_spend_daily(self, query=None):
        """Read this month day by day against your plan - each day's counts as the plan counted them, with its allowance beside them (GET /v1/spend/daily)"""
        return self._call("GET", f"/v1/spend/daily", query=query)

    def get_sso_providers(self, query=None):
        """See this workspace's company sign-ins - each identity provider, its email domain and whether the domain is proved (GET /v1/sso/providers)"""
        return self._call("GET", f"/v1/sso/providers", query=query)

    def get_sso_providers_by_provider_id_exchanges(self, provider_id, query=None):
        """Every earlier sign-in exchange of one company sign-in, newest first - what its identity provider answered and what Xovris did (GET /v1/sso/providers/{providerId}/exchanges)"""
        return self._call("GET", f"/v1/sso/providers/{_q(provider_id)}/exchanges", query=query)

    def get_status_page(self, query=None):
        """Read your status page, its preview and drafted updates (GET /v1/status-page)"""
        return self._call("GET", f"/v1/status-page", query=query)

    def get_status_page_domain(self, query=None):
        """See the domain your status page is served on, and what is still to set (GET /v1/status-page/domain)"""
        return self._call("GET", f"/v1/status-page/domain", query=query)

    def get_status_pages(self, query=None):
        """Every status page the workspace keeps, each with its address and whether it is published (GET /v1/status-pages)"""
        return self._call("GET", f"/v1/status-pages", query=query)

    def get_status_sentence(self, query=None):
        """Read one plain sentence on how your workspace stands right now (GET /v1/status-sentence)"""
        return self._call("GET", f"/v1/status-sentence", query=query)

    def get_storage_waste(self, query=None):
        """List storage savings planned and proved (GET /v1/storage/waste)"""
        return self._call("GET", f"/v1/storage/waste", query=query)

    def get_stripe(self, query=None):
        """Read your Stripe payments health (GET /v1/stripe)"""
        return self._call("GET", f"/v1/stripe", query=query)

    def get_stripe_connect(self, query=None):
        """Connect Stripe in one press, approved in Stripe (GET /v1/stripe/connect)"""
        return self._call("GET", f"/v1/stripe/connect", query=query)

    def get_stripe_connect_callback(self, query=None):
        """Finish connecting Stripe after approving it in Stripe (GET /v1/stripe/connect/callback)"""
        return self._call("GET", f"/v1/stripe/connect/callback", query=query)

    def get_systems(self, query=None):
        """List the systems you connected by their address (GET /v1/systems)"""
        return self._call("GET", f"/v1/systems", query=query)

    def get_systems_by_id(self, id_, query=None):
        """Read one connected system: what Xovris read of it and what it looks after (GET /v1/systems/{id})"""
        return self._call("GET", f"/v1/systems/{_q(id_)}", query=query)

    def get_systems_general_runs_jobs_by_job_record_export(self, job, query=None):
        """Download a job's signed recording (GET /v1/systems/general-runs/jobs/{job}/record/export)"""
        return self._call("GET", f"/v1/systems/general-runs/jobs/{_q(job)}/record/export", query=query)

    def get_systems_general_runs_learned(self, query=None):
        """What Xovris learned from past jobs on your systems (GET /v1/systems/general-runs/learned)"""
        return self._call("GET", f"/v1/systems/general-runs/learned", query=query)

    def get_systems_general_runs_memory(self, query=None):
        """See every rule Xovris keeps from your corrections, and your consent (GET /v1/systems/general-runs/memory)"""
        return self._call("GET", f"/v1/systems/general-runs/memory", query=query)

    def get_systems_general_runs_schedules(self, query=None):
        """See the checks Xovris runs for you unasked (GET /v1/systems/general-runs/schedules)"""
        return self._call("GET", f"/v1/systems/general-runs/schedules", query=query)

    def get_systems_general_runs_standing(self, query=None):
        """See every standing yes you gave Xovris to do a job again next time (GET /v1/systems/general-runs/standing)"""
        return self._call("GET", f"/v1/systems/general-runs/standing", query=query)

    def get_systems_profiles(self, query=None):
        """List connected systems (GET /v1/systems/profiles)"""
        return self._call("GET", f"/v1/systems/profiles", query=query)

    def get_systems_profiles_by_provider_actions(self, provider, query=None):
        """List what Xovris can do in a system (GET /v1/systems/profiles/{provider}/actions)"""
        return self._call("GET", f"/v1/systems/profiles/{_q(provider)}/actions", query=query)

    def get_systems_profiles_by_provider_changes(self, provider, query=None):
        """List the changes made in a system (GET /v1/systems/profiles/{provider}/changes)"""
        return self._call("GET", f"/v1/systems/profiles/{_q(provider)}/changes", query=query)

    def get_teams(self, query=None):
        """List this workspace's teams - each with its role, its rule and everyone in it, added or taken in by the rule (GET /v1/teams)"""
        return self._call("GET", f"/v1/teams", query=query)

    def get_telemetry_diet(self, query=None):
        """Read the telemetry diet (GET /v1/telemetry/diet)"""
        return self._call("GET", f"/v1/telemetry/diet", query=query)

    def get_things(self, query=None):
        """List the things Xovris has met (GET /v1/things)"""
        return self._call("GET", f"/v1/things", query=query)

    def get_things_by_id(self, id_, query=None):
        """Read a thing Xovris has met (GET /v1/things/{id})"""
        return self._call("GET", f"/v1/things/{_q(id_)}", query=query)

    def get_tokens(self, query=None):
        """List API tokens (GET /v1/tokens)"""
        return self._call("GET", f"/v1/tokens", query=query)

    def get_tokens_by_id_calls(self, id_, query=None):
        """See each call made with an API key, and the control that refused any it did not allow (GET /v1/tokens/{id}/calls)"""
        return self._call("GET", f"/v1/tokens/{_q(id_)}/calls", query=query)

    def get_tokens_by_id_unusual(self, id_, query=None):
        """See each unusual use of an API key Xovris found (GET /v1/tokens/{id}/unusual)"""
        return self._call("GET", f"/v1/tokens/{_q(id_)}/unusual", query=query)

    def get_tool_connections(self, query=None):
        """List tool connections (GET /v1/tool-connections)"""
        return self._call("GET", f"/v1/tool-connections", query=query)

    def get_tool_connections_by_id_deliveries(self, id_, query=None):
        """Read what was sent to a tool (GET /v1/tool-connections/{id}/deliveries)"""
        return self._call("GET", f"/v1/tool-connections/{_q(id_)}/deliveries", query=query)

    def get_tool_servers(self, query=None):
        """List the AI tool servers Xovris is connected to (GET /v1/tool-servers)"""
        return self._call("GET", f"/v1/tool-servers", query=query)

    def get_tools_security_headers(self, query=None):
        """Grade a site's security headers, with the lines that fix them (GET /v1/tools/security-headers)"""
        return self._call("GET", f"/v1/tools/security-headers", query=query)

    def get_traces(self, query=None):
        """Search the spans of kept traces (GET /v1/traces)"""
        return self._call("GET", f"/v1/traces", query=query)

    def get_traces_by_trace_id(self, trace_id, query=None):
        """Read a kept trace (GET /v1/traces/{traceId})"""
        return self._call("GET", f"/v1/traces/{_q(trace_id)}", query=query)

    def get_traces_heatmap(self, query=None):
        """Read the latency heatmap of the workspace's traces (GET /v1/traces/heatmap)"""
        return self._call("GET", f"/v1/traces/heatmap", query=query)

    def get_traces_paths(self, query=None):
        """See every endpoint's traffic, errors and speed (GET /v1/traces/paths)"""
        return self._call("GET", f"/v1/traces/paths", query=query)

    def get_traces_regression(self, query=None):
        """Find who a slowdown hit, why, and whether the average hides it (GET /v1/traces/regression)"""
        return self._call("GET", f"/v1/traces/regression", query=query)

    def get_traces_sampling(self, query=None):
        """See what trace sampling kept and removed (GET /v1/traces/sampling)"""
        return self._call("GET", f"/v1/traces/sampling", query=query)

    def get_traces_selection(self, query=None):
        """Read the traces inside a heatmap selection (GET /v1/traces/selection)"""
        return self._call("GET", f"/v1/traces/selection", query=query)

    def get_traces_service_map(self, query=None):
        """See how your services call each other (GET /v1/traces/service-map)"""
        return self._call("GET", f"/v1/traces/service-map", query=query)

    def get_traces_slo(self, query=None):
        """Have Xovris write a path's objectives from its own traffic (GET /v1/traces/slo)"""
        return self._call("GET", f"/v1/traces/slo", query=query)

    def get_uploads_by_id(self, id_, query=None):
        """Read how much of a large file has arrived (GET /v1/uploads/{id})"""
        return self._call("GET", f"/v1/uploads/{_q(id_)}", query=query)

    def get_uploads_by_id_content(self, id_, query=None):
        """A kept file, exactly as it was sent (GET /v1/uploads/{id}/content)"""
        return self._call("GET", f"/v1/uploads/{_q(id_)}/content", query=query)

    def get_value(self, query=None):
        """See what Xovris saved you this month - the time and money, at your own rate if you give one (GET /v1/value)"""
        return self._call("GET", f"/v1/value", query=query)

    def get_vendor_fixes(self, query=None):
        """See every fix you sent and whether it is waiting, being rehearsed, proven or refused (GET /v1/vendor-fixes)"""
        return self._call("GET", f"/v1/vendor-fixes", query=query)

    def get_views_by_surface(self, surface, query=None):
        """List the saved views of a page, yours and the ones shared with the workspace (GET /v1/views/{surface})"""
        return self._call("GET", f"/v1/views/{_q(surface)}", query=query)

    def get_vulnerabilities(self, query=None):
        """List software vulnerabilities that affect you (GET /v1/vulnerabilities)"""
        return self._call("GET", f"/v1/vulnerabilities", query=query)

    def get_vulnerabilities_devices(self, query=None):
        """See which of your devices have known vulnerabilities, by real risk (GET /v1/vulnerabilities/devices)"""
        return self._call("GET", f"/v1/vulnerabilities/devices", query=query)

    def get_vulnerabilities_devices_ids_blocks(self, query=None):
        """Every sensor rule Xovris switched to drop, why, its state and when (GET /v1/vulnerabilities/devices/ids-blocks)"""
        return self._call("GET", f"/v1/vulnerabilities/devices/ids-blocks", query=query)

    def get_vulnerabilities_feeds(self, query=None):
        """See how fresh each vulnerability source Xovris reads is (GET /v1/vulnerabilities/feeds)"""
        return self._call("GET", f"/v1/vulnerabilities/feeds", query=query)

    def get_vulnerabilities_feeds_early(self, query=None):
        """Read the next page of flaws a maker named before their record, after the last one you were shown (GET /v1/vulnerabilities/feeds/early)"""
        return self._call("GET", f"/v1/vulnerabilities/feeds/early", query=query)

    def get_watch_by_feature_setup(self, feature, query=None):
        """See how the app inventory or the insider risk watch is set up, and whether it may run (GET /v1/watch/{feature}/setup)"""
        return self._call("GET", f"/v1/watch/{_q(feature)}/setup", query=query)

    def get_watches(self, query=None):
        """List watches (GET /v1/watches)"""
        return self._call("GET", f"/v1/watches", query=query)

    def get_watches_by_id(self, id_, query=None):
        """Read a watch (GET /v1/watches/{id})"""
        return self._call("GET", f"/v1/watches/{_q(id_)}", query=query)

    def get_web_filter_appeals(self, query=None):
        """See the requests to allow blocked web names (GET /v1/web-filter/appeals)"""
        return self._call("GET", f"/v1/web-filter/appeals", query=query)

    def get_web_filter_categories(self, query=None):
        """List the web categories a filter policy can allow or block (GET /v1/web-filter/categories)"""
        return self._call("GET", f"/v1/web-filter/categories", query=query)

    def get_web_filter_policy(self, query=None):
        """Read your web filter policy and the version your devices run (GET /v1/web-filter/policy)"""
        return self._call("GET", f"/v1/web-filter/policy", query=query)

    def get_webhooks(self, query=None):
        """List webhooks (GET /v1/webhooks)"""
        return self._call("GET", f"/v1/webhooks", query=query)

    def get_what_if(self, query=None):
        """Read what Xovris found by playing every fault it can name on a copy of your setup, blind spots first (GET /v1/what-if)"""
        return self._call("GET", f"/v1/what-if", query=query)

    def get_workspace_address(self, query=None):
        """Read this workspace's free xovris.ai address and whether it is live (GET /v1/workspace/address)"""
        return self._call("GET", f"/v1/workspace/address", query=query)

    def get_workspace_ai_checks(self, query=None):
        """Read your AI checks: how often they run, what was looked at and what was found (GET /v1/workspace/ai-checks)"""
        return self._call("GET", f"/v1/workspace/ai-checks", query=query)

    def get_workspace_domains(self, query=None):
        """List the domains you have pointed at this workspace and the records each still needs (GET /v1/workspace/domains)"""
        return self._call("GET", f"/v1/workspace/domains", query=query)

    def get_workspace_results(self, query=None):
        """Read what Xovris fixed for you this month - fixed and held, came back, undone or left worse - and how long each fix took (GET /v1/workspace/results)"""
        return self._call("GET", f"/v1/workspace/results", query=query)

    def get_workspace_success_rates(self, query=None):
        """Read what Xovris connected, diagnosed, fixed, verified and undid and proved on each of your systems (GET /v1/workspace/success-rates)"""
        return self._call("GET", f"/v1/workspace/success-rates", query=query)

    def patch_assist_requests_by_id(self, id_, body=None, idempotency_key=None):
        """Name a conversation in your own words (PATCH /v1/assist/requests/{id})"""
        return self._call("PATCH", f"/v1/assist/requests/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_me(self, body=None, idempotency_key=None):
        """Correct your own name or email (a new email is proved by a code sent to it) (PATCH /v1/me)"""
        return self._call("PATCH", f"/v1/me", body=body, idempotency_key=idempotency_key)

    def patch_members_by_user_id(self, user_id, body=None, idempotency_key=None):
        """Change a member's role - admin, member, viewer or billing; ownership moves only by a transfer (PATCH /v1/members/{userId})"""
        return self._call("PATCH", f"/v1/members/{_q(user_id)}", body=body, idempotency_key=idempotency_key)

    def patch_roles_by_id(self, id_, body=None, idempotency_key=None):
        """Change a custom role's name, description, permissions or stage - a change made over someone else's newer one is refused, never lost (PATCH /v1/roles/{id})"""
        return self._call("PATCH", f"/v1/roles/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_scim_v2_groups_by_id(self, id_, body=None, idempotency_key=None):
        """People put in or taken out of a provisioned team, or the team renamed - the provider only ever moves the people it put there (PATCH /v1/scim/v2/Groups/{id})"""
        return self._call("PATCH", f"/v1/scim/v2/Groups/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_scim_v2_users_by_id(self, id_, body=None, idempotency_key=None):
        """A person turned off at the identity provider loses this workspace at once, their keys and waiting asks with it (PATCH /v1/scim/v2/Users/{id})"""
        return self._call("PATCH", f"/v1/scim/v2/Users/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_settings_ai_limit(self, body=None, idempotency_key=None):
        """Change your monthly limit on AI fixes (PATCH /v1/settings/ai-limit)"""
        return self._call("PATCH", f"/v1/settings/ai-limit", body=body, idempotency_key=idempotency_key)

    def patch_settings_autonomy_by_kind(self, kind, body=None, idempotency_key=None):
        """Change what Xovris may fix on its own, for one kind of change (PATCH /v1/settings/autonomy/{kind})"""
        return self._call("PATCH", f"/v1/settings/autonomy/{_q(kind)}", body=body, idempotency_key=idempotency_key)

    def patch_settings_autonomy_by_kind_budget(self, kind, body=None, idempotency_key=None):
        """Set a kind of change's monthly risk budget, in your own words (PATCH /v1/settings/autonomy/{kind}/budget)"""
        return self._call("PATCH", f"/v1/settings/autonomy/{_q(kind)}/budget", body=body, idempotency_key=idempotency_key)

    def patch_settings_autonomy_guards(self, body=None, idempotency_key=None):
        """Change the guards on fixes Xovris makes on its own (PATCH /v1/settings/autonomy/guards)"""
        return self._call("PATCH", f"/v1/settings/autonomy/guards", body=body, idempotency_key=idempotency_key)

    def patch_sso_providers_by_provider_id(self, provider_id, body=None, idempotency_key=None):
        """The role someone new joins the workspace as the first time they sign in through this company sign-in - a built-in role, a role the workspace made, or none until invited (PATCH /v1/sso/providers/{providerId})"""
        return self._call("PATCH", f"/v1/sso/providers/{_q(provider_id)}", body=body, idempotency_key=idempotency_key)

    def patch_systems_general_runs_learned_by_id(self, id_, body=None, idempotency_key=None):
        """Change the words one learned plan answers to (PATCH /v1/systems/general-runs/learned/{id})"""
        return self._call("PATCH", f"/v1/systems/general-runs/learned/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_systems_general_runs_memory_rules_by_id(self, id_, body=None, idempotency_key=None):
        """Change the words one of your rules applies to (PATCH /v1/systems/general-runs/memory/rules/{id})"""
        return self._call("PATCH", f"/v1/systems/general-runs/memory/rules/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_teams_by_id(self, id_, body=None, idempotency_key=None):
        """Change a team's name, role, rule, parent team or end date - a change made over someone else's newer one is refused (PATCH /v1/teams/{id})"""
        return self._call("PATCH", f"/v1/teams/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def patch_workspace_address(self, body=None, idempotency_key=None):
        """Change this workspace's free xovris.ai address or where it forwards (PATCH /v1/workspace/address)"""
        return self._call("PATCH", f"/v1/workspace/address", body=body, idempotency_key=idempotency_key)

    def post_a2a(self, body=None, idempotency_key=None):
        """Hand Xovris work from another AI agent (A2A SendMessage) (POST /v1/a2a)"""
        return self._call("POST", f"/v1/a2a", body=body, idempotency_key=idempotency_key)

    def post_access_admin_lines_by_id(self, id_, body=None, idempotency_key=None):
        """Hold a connected system to your own line of admins, in place of CIS's two to four (POST /v1/access/admin-lines/{id})"""
        return self._call("POST", f"/v1/access/admin-lines/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def post_access_flags_by_key_fix(self, key, body=None, idempotency_key=None):
        """Fix an access problem Xovris flagged (POST /v1/access/flags/{key}/fix)"""
        return self._call("POST", f"/v1/access/flags/{_q(key)}/fix", body=body, idempotency_key=idempotency_key)

    def post_access_owners(self, body=None, idempotency_key=None):
        """Name the owner of a system or account (POST /v1/access/owners)"""
        return self._call("POST", f"/v1/access/owners", body=body, idempotency_key=idempotency_key)

    def post_access_review(self, body=None, idempotency_key=None):
        """Keep an access review on the record, with what was acted on (POST /v1/access/review)"""
        return self._call("POST", f"/v1/access/review", body=body, idempotency_key=idempotency_key)

    def post_access_review_sign_off(self, body=None, idempotency_key=None):
        """Sign off, or decline, the access changes another person proposed - each applied through the same doors as a change by hand (POST /v1/access/review/sign-off)"""
        return self._call("POST", f"/v1/access/review/sign-off", body=body, idempotency_key=idempotency_key)

    def post_account_sessions_end_others(self, body=None, idempotency_key=None):
        """Sign out everywhere except here (POST /v1/account/sessions/end-others)"""
        return self._call("POST", f"/v1/account/sessions/end-others", body=body, idempotency_key=idempotency_key)

    def post_actions_by_seq_undo(self, seq, body=None, idempotency_key=None):
        """Undo a change Xovris made, by its own way back (POST /v1/actions/{seq}/undo)"""
        return self._call("POST", f"/v1/actions/{_q(seq)}/undo", body=body, idempotency_key=idempotency_key)

    def post_actions_undo_window(self, body=None, idempotency_key=None):
        """Undo everything Xovris changed in a window of time, in one press, each change read back (POST /v1/actions/undo-window)"""
        return self._call("POST", f"/v1/actions/undo-window", body=body, idempotency_key=idempotency_key)

    def post_agents_a2a_card(self, body=None, idempotency_key=None):
        """Read your own A2A agent's card - who it is and what it says it can do (POST /v1/agents/a2a/card)"""
        return self._call("POST", f"/v1/agents/a2a/card", body=body, idempotency_key=idempotency_key)

    def post_agents_a2a_send(self, body=None, idempotency_key=None):
        """Give your own A2A agent work in your own words, in the same conversation, and follow it to its end (POST /v1/agents/a2a/send)"""
        return self._call("POST", f"/v1/agents/a2a/send", body=body, idempotency_key=idempotency_key)

    def post_agents_a2a_task(self, body=None, idempotency_key=None):
        """Read how a task your own A2A agent is still working on stands (POST /v1/agents/a2a/task)"""
        return self._call("POST", f"/v1/agents/a2a/task", body=body, idempotency_key=idempotency_key)

    def post_alert_actions_by_id_rules(self, id_, body=None, idempotency_key=None):
        """Call an action from an alert rule (POST /v1/alert-actions/{id}/rules)"""
        return self._call("POST", f"/v1/alert-actions/{_q(id_)}/rules", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_discord_undo(self, id_, body=None, idempotency_key=None):
        """Take back a Discord channel Xovris added (POST /v1/alerts/channels/{id}/discord/undo)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/discord/undo", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_pagerduty_undo(self, id_, body=None, idempotency_key=None):
        """Take back a PagerDuty service Xovris connected (POST /v1/alerts/channels/{id}/pagerduty/undo)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/pagerduty/undo", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_teams_reply(self, id_, body=None, idempotency_key=None):
        """Let Xovris answer when someone mentions it in a Microsoft Teams channel (POST /v1/alerts/channels/{id}/teams/reply)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/teams/reply", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_test(self, id_, body=None, idempotency_key=None):
        """Send a test alert (POST /v1/alerts/channels/{id}/test)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/test", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_webhook_https(self, id_, body=None, idempotency_key=None):
        """Move a webhook channel to an https address (POST /v1/alerts/channels/{id}/webhook-https)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/webhook-https", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_webhook_https_undo(self, id_, body=None, idempotency_key=None):
        """Put a webhook channel back on its earlier address (POST /v1/alerts/channels/{id}/webhook-https/undo)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/webhook-https/undo", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_webhook_secret(self, id_, body=None, idempotency_key=None):
        """Sign a webhook channel's alerts with a secret (POST /v1/alerts/channels/{id}/webhook-secret)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/webhook-secret", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_by_id_webhook_secret_undo(self, id_, body=None, idempotency_key=None):
        """Stop signing a webhook channel's alerts (POST /v1/alerts/channels/{id}/webhook-secret/undo)"""
        return self._call("POST", f"/v1/alerts/channels/{_q(id_)}/webhook-secret/undo", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_discord_grant(self, body=None, idempotency_key=None):
        """Start adding a Discord channel through Discord's own approval (POST /v1/alerts/channels/discord/grant)"""
        return self._call("POST", f"/v1/alerts/channels/discord/grant", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_email(self, body=None, idempotency_key=None):
        """Add the built-in email channel (POST /v1/alerts/channels/email)"""
        return self._call("POST", f"/v1/alerts/channels/email", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_native(self, body=None, idempotency_key=None):
        """Turn on notifications in the Xovris app on this phone (POST /v1/alerts/channels/native)"""
        return self._call("POST", f"/v1/alerts/channels/native", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_one_step(self, body=None, idempotency_key=None):
        """One-step set-up of an alert channel (POST /v1/alerts/channels/one-step)"""
        return self._call("POST", f"/v1/alerts/channels/one-step", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_pagerduty_grant(self, body=None, idempotency_key=None):
        """Start connecting PagerDuty through PagerDuty's own approval (POST /v1/alerts/channels/pagerduty/grant)"""
        return self._call("POST", f"/v1/alerts/channels/pagerduty/grant", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_push(self, body=None, idempotency_key=None):
        """Turn on push alerts on this device (POST /v1/alerts/channels/push)"""
        return self._call("POST", f"/v1/alerts/channels/push", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_push_off(self, body=None, idempotency_key=None):
        """Turn off push alerts on this device (POST /v1/alerts/channels/push/off)"""
        return self._call("POST", f"/v1/alerts/channels/push/off", body=body, idempotency_key=idempotency_key)

    def post_alerts_channels_telegram(self, body=None, idempotency_key=None):
        """Add a Telegram chat (POST /v1/alerts/channels/telegram)"""
        return self._call("POST", f"/v1/alerts/channels/telegram", body=body, idempotency_key=idempotency_key)

    def post_alerts_delivery_by_id_retry(self, id_, body=None, idempotency_key=None):
        """Retry a delivery (POST /v1/alerts/delivery/{id}/retry)"""
        return self._call("POST", f"/v1/alerts/delivery/{_q(id_)}/retry", body=body, idempotency_key=idempotency_key)

    def post_alerts_limit_points(self, body=None, idempotency_key=None):
        """Save the points at which you hear about AI spend (POST /v1/alerts/limit-points)"""
        return self._call("POST", f"/v1/alerts/limit-points", body=body, idempotency_key=idempotency_key)

    def post_alerts_mail_server_check(self, body=None, idempotency_key=None):
        """Xovris signs in to the workspace's mail server again (POST /v1/alerts/mail-server/check)"""
        return self._call("POST", f"/v1/alerts/mail-server/check", body=body, idempotency_key=idempotency_key)

    def post_alerts_phrase(self, body=None, idempotency_key=None):
        """Save the phrase only your real alerts carry (POST /v1/alerts/phrase)"""
        return self._call("POST", f"/v1/alerts/phrase", body=body, idempotency_key=idempotency_key)

    def post_alerts_phrase_workspace(self, body=None, idempotency_key=None):
        """Save the phrase every alert in your workspace carries (POST /v1/alerts/phrase/workspace)"""
        return self._call("POST", f"/v1/alerts/phrase/workspace", body=body, idempotency_key=idempotency_key)

    def post_alerts_push_shown(self, body=None, idempotency_key=None):
        """Record that a push alert was shown on the device (POST /v1/alerts/push/shown)"""
        return self._call("POST", f"/v1/alerts/push/shown", body=body, idempotency_key=idempotency_key)

    def post_alerts_replies_canary_code(self, body=None, idempotency_key=None):
        """Read the production check's own sign-in code (POST /v1/alerts/replies/canary-code)"""
        return self._call("POST", f"/v1/alerts/replies/canary-code", body=body, idempotency_key=idempotency_key)

    def post_alerts_replies_email(self, body=None, idempotency_key=None):
        """Receive an email to Xovris and answer it by email (POST /v1/alerts/replies/email)"""
        return self._call("POST", f"/v1/alerts/replies/email", body=body, idempotency_key=idempotency_key)

    def post_alerts_replies_teams_by_tenant_id_by_channel_id(self, tenant_id, channel_id, body=None, idempotency_key=None):
        """Receive a Microsoft Teams mention of Xovris and answer it in the thread (POST /v1/alerts/replies/teams/{tenantId}/{channelId})"""
        return self._call("POST", f"/v1/alerts/replies/teams/{_q(tenant_id)}/{_q(channel_id)}", body=body, idempotency_key=idempotency_key)

    def post_alerts_replies_twilio(self, body=None, idempotency_key=None):
        """Receive a text or WhatsApp reply to an alert (POST /v1/alerts/replies/twilio)"""
        return self._call("POST", f"/v1/alerts/replies/twilio", body=body, idempotency_key=idempotency_key)

    def post_alerts_rules(self, body=None, idempotency_key=None):
        """Save an alert rule (POST /v1/alerts/rules)"""
        return self._call("POST", f"/v1/alerts/rules", body=body, idempotency_key=idempotency_key)

    def post_alerts_rules_preview(self, body=None, idempotency_key=None):
        """See what an alert rule would do before you save it (POST /v1/alerts/rules/preview)"""
        return self._call("POST", f"/v1/alerts/rules/preview", body=body, idempotency_key=idempotency_key)

    def post_alerts_sending_domain_check(self, body=None, idempotency_key=None):
        """Xovris reads the sending domain's records again (POST /v1/alerts/sending-domain/check)"""
        return self._call("POST", f"/v1/alerts/sending-domain/check", body=body, idempotency_key=idempotency_key)

    def post_alerts_status_page_door_connect(self, body=None, idempotency_key=None):
        """Connect the status page Xovris posts updates to (POST /v1/alerts/status-page-door/connect)"""
        return self._call("POST", f"/v1/alerts/status-page-door/connect", body=body, idempotency_key=idempotency_key)

    def post_alerts_status_page_door_disconnect(self, body=None, idempotency_key=None):
        """Disconnect the status page Xovris posts updates to (POST /v1/alerts/status-page-door/disconnect)"""
        return self._call("POST", f"/v1/alerts/status-page-door/disconnect", body=body, idempotency_key=idempotency_key)

    def post_alerts_status_page_door_updates(self, body=None, idempotency_key=None):
        """Post an update to your connected status page (POST /v1/alerts/status-page-door/updates)"""
        return self._call("POST", f"/v1/alerts/status-page-door/updates", body=body, idempotency_key=idempotency_key)

    def post_alerts_status_page_door_updates_by_key_withdraw(self, key, body=None, idempotency_key=None):
        """Withdraw an update from your connected status page (POST /v1/alerts/status-page-door/updates/{key}/withdraw)"""
        return self._call("POST", f"/v1/alerts/status-page-door/updates/{_q(key)}/withdraw", body=body, idempotency_key=idempotency_key)

    def post_alerts_suppressions_unsuppress(self, body=None, idempotency_key=None):
        """Let a suppressed address receive alerts (POST /v1/alerts/suppressions/unsuppress)"""
        return self._call("POST", f"/v1/alerts/suppressions/unsuppress", body=body, idempotency_key=idempotency_key)

    def post_alerts_telegram_webhook(self, body=None, idempotency_key=None):
        """Receive a Telegram message to Xovris (POST /v1/alerts/telegram/webhook)"""
        return self._call("POST", f"/v1/alerts/telegram/webhook", body=body, idempotency_key=idempotency_key)

    def post_alerts_tuning_proposals_by_id(self, id_, body=None, idempotency_key=None):
        """Accept or decline a proposed alert change (POST /v1/alerts/tuning/proposals/{id})"""
        return self._call("POST", f"/v1/alerts/tuning/proposals/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def post_alerts_tuning_restore(self, body=None, idempotency_key=None):
        """Put an alert change back as it was (POST /v1/alerts/tuning/restore)"""
        return self._call("POST", f"/v1/alerts/tuning/restore", body=body, idempotency_key=idempotency_key)

    def post_alerts_twilio_status(self, body=None, idempotency_key=None):
        """Record whether a text, call or WhatsApp alert reached the phone (POST /v1/alerts/twilio/status)"""
        return self._call("POST", f"/v1/alerts/twilio/status", body=body, idempotency_key=idempotency_key)

    def post_alerts_unsubscribe(self, body=None, idempotency_key=None):
        """Stop alerts to an address in one press (POST /v1/alerts/unsubscribe)"""
        return self._call("POST", f"/v1/alerts/unsubscribe", body=body, idempotency_key=idempotency_key)

    def post_alerts_voice_ask(self, body=None, idempotency_key=None):
        """Ask Xovris a question on a phone call (POST /v1/alerts/voice/ask)"""
        return self._call("POST", f"/v1/alerts/voice/ask", body=body, idempotency_key=idempotency_key)

    def post_alerts_voice_gather(self, body=None, idempotency_key=None):
        """Read the keys pressed on an alert call (POST /v1/alerts/voice/gather)"""
        return self._call("POST", f"/v1/alerts/voice/gather", body=body, idempotency_key=idempotency_key)

    def post_alerts_voice_inbound(self, body=None, idempotency_key=None):
        """Answer a call to Xovris's number (POST /v1/alerts/voice/inbound)"""
        return self._call("POST", f"/v1/alerts/voice/inbound", body=body, idempotency_key=idempotency_key)

    def post_api_by_project_id_attachments_assemble_index(self, project_id, body=None, idempotency_key=None):
        """Join the parts of a large attachment sent in pieces into one file, kept with its event (POST /api/{projectId}/attachments/assemble/)"""
        return self._call("POST", f"/api/{_q(project_id)}/attachments/assemble/", body=body, idempotency_key=idempotency_key)

    def post_api_by_project_id_chunk_upload_index(self, project_id, body=None, idempotency_key=None):
        """Send one part of a large file, such as a source map or debug file (POST /api/{projectId}/chunk-upload/)"""
        return self._call("POST", f"/api/{_q(project_id)}/chunk-upload/", body=body, idempotency_key=idempotency_key)

    def post_api_by_project_id_envelope_index(self, project_id, body=None, idempotency_key=None):
        """Send events from a Sentry SDK (POST /api/{projectId}/envelope/)"""
        return self._call("POST", f"/api/{_q(project_id)}/envelope/", body=body, idempotency_key=idempotency_key)

    def post_api_by_project_id_security_index(self, project_id, body=None, idempotency_key=None):
        """Send browser security reports (POST /api/{projectId}/security/)"""
        return self._call("POST", f"/api/{_q(project_id)}/security/", body=body, idempotency_key=idempotency_key)

    def post_api_by_project_id_store_index(self, project_id, body=None, idempotency_key=None):
        """Send one event from an older Sentry SDK (POST /api/{projectId}/store/)"""
        return self._call("POST", f"/api/{_q(project_id)}/store/", body=body, idempotency_key=idempotency_key)

    def post_api_v2_logs(self, body=None, idempotency_key=None):
        """Send logs in the Datadog format (POST /api/v2/logs)"""
        return self._call("POST", f"/api/v2/logs", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_access(self, body=None, idempotency_key=None):
        """Review who has access to what: leavers' accounts, stale and admin accounts, each with its decision (POST /v1/apps/ai/access)"""
        return self._call("POST", f"/v1/apps/ai/access", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_adoption(self, body=None, idempotency_key=None):
        """See AI adoption and spend month by month, and next month's spend (POST /v1/apps/ai/adoption)"""
        return self._call("POST", f"/v1/apps/ai/adoption", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_agents(self, body=None, idempotency_key=None):
        """See the AI agents and MCP servers acting in the company, what each may do and what makes it risky (POST /v1/apps/ai/agents)"""
        return self._call("POST", f"/v1/apps/ai/agents", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_breaches(self, body=None, idempotency_key=None):
        """See the breaches of vendors in use, each told once with what Xovris does (POST /v1/apps/ai/breaches)"""
        return self._call("POST", f"/v1/apps/ai/breaches", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_conversations(self, body=None, idempotency_key=None):
        """See prompts, uploads and keys pasted into each AI tool counted, and the keys to rotate - never a word written (POST /v1/apps/ai/conversations)"""
        return self._call("POST", f"/v1/apps/ai/conversations", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_flows(self, body=None, idempotency_key=None):
        """See company data flowing from each app into each AI tool, drawn (POST /v1/apps/ai/flows)"""
        return self._call("POST", f"/v1/apps/ai/flows", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_grants(self, body=None, idempotency_key=None):
        """See the risk of each app grant from what its scopes reach, with revoke, review or keep (POST /v1/apps/ai/grants)"""
        return self._call("POST", f"/v1/apps/ai/grants", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_guard(self, body=None, idempotency_key=None):
        """Decide whether data may go into an AI tool from its label and size: allow, warn, block or redirect (POST /v1/apps/ai/guard)"""
        return self._call("POST", f"/v1/apps/ai/guard", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_mail(self, body=None, idempotency_key=None):
        """Find the apps people signed up for, the past ones included, from the mail flow's senders and dates - never a word of the mail (POST /v1/apps/ai/mail)"""
        return self._call("POST", f"/v1/apps/ai/mail", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_new(self, body=None, idempotency_key=None):
        """See the new AI tools staff started using, each told once with the approved one to use instead (POST /v1/apps/ai/new)"""
        return self._call("POST", f"/v1/apps/ai/new", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_nudges(self, body=None, idempotency_key=None):
        """Nudge people on an unapproved AI tool to the approved one, at most once a week, and count who moved (POST /v1/apps/ai/nudges)"""
        return self._call("POST", f"/v1/apps/ai/nudges", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_pastes(self, body=None, idempotency_key=None):
        """See company data pasted or uploaded from each app into each app, counted - never the content (POST /v1/apps/ai/pastes)"""
        return self._call("POST", f"/v1/apps/ai/pastes", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_policy(self, body=None, idempotency_key=None):
        """See who acknowledged the AI use policy, by team, and remind the rest (POST /v1/apps/ai/policy)"""
        return self._call("POST", f"/v1/apps/ai/policy", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_posture(self, body=None, idempotency_key=None):
        """See each app's security settings checked, with the fix for each (POST /v1/apps/ai/posture)"""
        return self._call("POST", f"/v1/apps/ai/posture", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_reach(self, body=None, idempotency_key=None):
        """See every app an AI tool can reach through MCP, API and webhook links, chains included, with the data labels on the way (POST /v1/apps/ai/reach)"""
        return self._call("POST", f"/v1/apps/ai/reach", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_risk(self, body=None, idempotency_key=None):
        """See how each AI app's risk changed since the last read, with the reasons (POST /v1/apps/ai/risk)"""
        return self._call("POST", f"/v1/apps/ai/risk", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_spend(self, body=None, idempotency_key=None):
        """See unused seats and two paid tools doing one job, with the money each saves a month (POST /v1/apps/ai/spend)"""
        return self._call("POST", f"/v1/apps/ai/spend", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_supply_chain(self, body=None, idempotency_key=None):
        """See the AI services behind each app from its own sub-processor list (POST /v1/apps/ai/supply-chain)"""
        return self._call("POST", f"/v1/apps/ai/supply-chain", body=body, idempotency_key=idempotency_key)

    def post_apps_ai_vendor(self, body=None, idempotency_key=None):
        """See an AI vendor's training, retention, region and attestation policy against your own requirements (POST /v1/apps/ai/vendor)"""
        return self._call("POST", f"/v1/apps/ai/vendor", body=body, idempotency_key=idempotency_key)

    def post_apps_inventory(self, body=None, idempotency_key=None):
        """Find the apps and AI tools staff use that the business has not approved (POST /v1/apps/inventory)"""
        return self._call("POST", f"/v1/apps/inventory", body=body, idempotency_key=idempotency_key)

    def post_apps_watch(self, body=None, idempotency_key=None):
        """Watch a mobile app (POST /v1/apps/watch)"""
        return self._call("POST", f"/v1/apps/watch", body=body, idempotency_key=idempotency_key)

    def post_apps_watch_by_id_remove(self, id_, body=None, idempotency_key=None):
        """Stop watching an app (POST /v1/apps/watch/{id}/remove)"""
        return self._call("POST", f"/v1/apps/watch/{_q(id_)}/remove", body=body, idempotency_key=idempotency_key)

    def post_apps_watch_replies_by_review_id_approve(self, review_id, body=None, idempotency_key=None):
        """Approve a drafted reply to a store review (POST /v1/apps/watch/replies/{reviewId}/approve)"""
        return self._call("POST", f"/v1/apps/watch/replies/{_q(review_id)}/approve", body=body, idempotency_key=idempotency_key)

    def post_assets(self, body=None, idempotency_key=None):
        """Add a website to monitor (POST /v1/assets)"""
        return self._call("POST", f"/v1/assets", body=body, idempotency_key=idempotency_key)

    def post_assets_by_id_site_quality_run(self, id_, body=None, idempotency_key=None):
        """Check a website's quality now (POST /v1/assets/{id}/site-quality/run)"""
        return self._call("POST", f"/v1/assets/{_q(id_)}/site-quality/run", body=body, idempotency_key=idempotency_key)

    def post_assets_removals_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a website's removal (POST /v1/assets/removals/{id}/undo)"""
        return self._call("POST", f"/v1/assets/removals/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_assist_cobrowse(self, body=None, idempotency_key=None):
        """Share a browser tab with Xovris for step-by-step help (POST /v1/assist/cobrowse)"""
        return self._call("POST", f"/v1/assist/cobrowse", body=body, idempotency_key=idempotency_key)

    def post_assist_cobrowse_by_id_acted(self, id_, body=None, idempotency_key=None):
        """Report what the shared tab did (POST /v1/assist/cobrowse/{id}/acted)"""
        return self._call("POST", f"/v1/assist/cobrowse/{_q(id_)}/acted", body=body, idempotency_key=idempotency_key)

    def post_assist_cobrowse_by_id_captured(self, id_, body=None, idempotency_key=None):
        """Keep what a co-browse step captured, sealed in your vault (POST /v1/assist/cobrowse/{id}/captured)"""
        return self._call("POST", f"/v1/assist/cobrowse/{_q(id_)}/captured", body=body, idempotency_key=idempotency_key)

    def post_assist_cobrowse_by_id_consent(self, id_, body=None, idempotency_key=None):
        """Say yes or no to the step Xovris proposed (POST /v1/assist/cobrowse/{id}/consent)"""
        return self._call("POST", f"/v1/assist/cobrowse/{_q(id_)}/consent", body=body, idempotency_key=idempotency_key)

    def post_assist_cobrowse_by_id_frame(self, id_, body=None, idempotency_key=None):
        """Send the shared tab's outline and get the next step (POST /v1/assist/cobrowse/{id}/frame)"""
        return self._call("POST", f"/v1/assist/cobrowse/{_q(id_)}/frame", body=body, idempotency_key=idempotency_key)

    def post_assist_cobrowse_by_id_stop(self, id_, body=None, idempotency_key=None):
        """Stop sharing a tab (POST /v1/assist/cobrowse/{id}/stop)"""
        return self._call("POST", f"/v1/assist/cobrowse/{_q(id_)}/stop", body=body, idempotency_key=idempotency_key)

    def post_assist_design_import(self, body=None, idempotency_key=None):
        """Bring a design into a build - a picture, a Figma frame or a page - read into what the build follows (POST /v1/assist/design/import)"""
        return self._call("POST", f"/v1/assist/design/import", body=body, idempotency_key=idempotency_key)

    def post_assist_documents(self, body=None, idempotency_key=None):
        """Make an answer into a file - Word, Excel, PowerPoint or PDF - and download it (POST /v1/assist/documents)"""
        return self._call("POST", f"/v1/assist/documents", body=body, idempotency_key=idempotency_key)

    def post_assist_files_read(self, body=None, idempotency_key=None):
        """Send a file for the Ask to read - a document, a sheet, a picture or a recording - and ask about it (POST /v1/assist/files/read)"""
        return self._call("POST", f"/v1/assist/files/read", body=body, idempotency_key=idempotency_key)

    def post_assist_listen(self, body=None, idempotency_key=None):
        """Send a recording and get back the words that were said (POST /v1/assist/listen)"""
        return self._call("POST", f"/v1/assist/listen", body=body, idempotency_key=idempotency_key)

    def post_assist_requests(self, body=None, idempotency_key=None):
        """Ask Xovris to do something (POST /v1/assist/requests)"""
        return self._call("POST", f"/v1/assist/requests", body=body, idempotency_key=idempotency_key)

    def post_assist_requests_archive_all(self, body=None, idempotency_key=None):
        """Archive every conversation at once - each is kept whole and can be restored (POST /v1/assist/requests/archive-all)"""
        return self._call("POST", f"/v1/assist/requests/archive-all", body=body, idempotency_key=idempotency_key)

    def post_assist_requests_by_id_reply(self, id_, body=None, idempotency_key=None):
        """Reply to Xovris about a request (POST /v1/assist/requests/{id}/reply)"""
        return self._call("POST", f"/v1/assist/requests/{_q(id_)}/reply", body=body, idempotency_key=idempotency_key)

    def post_assist_requests_by_id_say(self, id_, body=None, idempotency_key=None):
        """Carry a conversation on in your own words, where it stopped (POST /v1/assist/requests/{id}/say)"""
        return self._call("POST", f"/v1/assist/requests/{_q(id_)}/say", body=body, idempotency_key=idempotency_key)

    def post_assist_requests_by_id_secret(self, id_, body=None, idempotency_key=None):
        """Give Xovris a secret for a request, sealed (POST /v1/assist/requests/{id}/secret)"""
        return self._call("POST", f"/v1/assist/requests/{_q(id_)}/secret", body=body, idempotency_key=idempotency_key)

    def post_assist_requests_by_id_share(self, id_, body=None, idempotency_key=None):
        """Make a link anyone can open to read a conversation (POST /v1/assist/requests/{id}/share)"""
        return self._call("POST", f"/v1/assist/requests/{_q(id_)}/share", body=body, idempotency_key=idempotency_key)

    def post_assist_speech(self, body=None, idempotency_key=None):
        """Turn written words into speech and get the recording back (POST /v1/assist/speech)"""
        return self._call("POST", f"/v1/assist/speech", body=body, idempotency_key=idempotency_key)

    def post_automation_kill_switches(self, body=None, idempotency_key=None):
        """Stop or restart what Xovris does on its own, for the workspace or one kind of action (POST /v1/automation/kill-switches)"""
        return self._call("POST", f"/v1/automation/kill-switches", body=body, idempotency_key=idempotency_key)

    def post_autonomy_asks(self, body=None, idempotency_key=None):
        """Count one thing Xovris asked a person to do against its journey's floor (POST /v1/autonomy/asks)"""
        return self._call("POST", f"/v1/autonomy/asks", body=body, idempotency_key=idempotency_key)

    def post_autonomy_dnssec(self, body=None, idempotency_key=None):
        """DNSSEC switched on for a domain by Xovris, read back from public resolvers (POST /v1/autonomy/dnssec)"""
        return self._call("POST", f"/v1/autonomy/dnssec", body=body, idempotency_key=idempotency_key)

    def post_autonomy_domains_by_domain_keep_renewing(self, domain, body=None, idempotency_key=None):
        """Keep a domain renewing at its registrar (POST /v1/autonomy/domains/{domain}/keep-renewing)"""
        return self._call("POST", f"/v1/autonomy/domains/{_q(domain)}/keep-renewing", body=body, idempotency_key=idempotency_key)

    def post_autonomy_edge_headers(self, body=None, idempotency_key=None):
        """A site's security headers set by Xovris at its edge (POST /v1/autonomy/edge/headers)"""
        return self._call("POST", f"/v1/autonomy/edge/headers", body=body, idempotency_key=idempotency_key)

    def post_autonomy_facts_ask(self, body=None, idempotency_key=None):
        """Ask the person for a fact once - a fact already given is returned instead (POST /v1/autonomy/facts/ask)"""
        return self._call("POST", f"/v1/autonomy/facts/ask", body=body, idempotency_key=idempotency_key)

    def post_autonomy_goals(self, body=None, idempotency_key=None):
        """Say what you want in one sentence; Xovris plans it, rehearses it and runs it (POST /v1/autonomy/goals)"""
        return self._call("POST", f"/v1/autonomy/goals", body=body, idempotency_key=idempotency_key)

    def post_autonomy_goals_by_id_yes(self, id_, body=None, idempotency_key=None):
        """Say yes once to a plan Xovris rehearsed (POST /v1/autonomy/goals/{id}/yes)"""
        return self._call("POST", f"/v1/autonomy/goals/{_q(id_)}/yes", body=body, idempotency_key=idempotency_key)

    def post_autonomy_grants_least(self, body=None, idempotency_key=None):
        """See the least grant a plan needs, and what it lets Xovris do (POST /v1/autonomy/grants/least)"""
        return self._call("POST", f"/v1/autonomy/grants/least", body=body, idempotency_key=idempotency_key)

    def post_autonomy_immunity_breaks(self, body=None, idempotency_key=None):
        """Share only the fix for a vendor's break, so every other customer is protected (POST /v1/autonomy/immunity/breaks)"""
        return self._call("POST", f"/v1/autonomy/immunity/breaks", body=body, idempotency_key=idempotency_key)

    def post_autonomy_imperative(self, body=None, idempotency_key=None):
        """Check words for instructions that hand the person work Xovris could do (POST /v1/autonomy/imperative)"""
        return self._call("POST", f"/v1/autonomy/imperative", body=body, idempotency_key=idempotency_key)

    def post_autonomy_keyboard_by_id_hand_over(self, id_, body=None, idempotency_key=None):
        """Hand Xovris the keyboard in a shared tab, or take it back (POST /v1/autonomy/keyboard/{id}/hand-over)"""
        return self._call("POST", f"/v1/autonomy/keyboard/{_q(id_)}/hand-over", body=body, idempotency_key=idempotency_key)

    def post_autonomy_keyboard_link(self, body=None, idempotency_key=None):
        """Make a one-tap link that installs the signed device app (POST /v1/autonomy/keyboard/link)"""
        return self._call("POST", f"/v1/autonomy/keyboard/link", body=body, idempotency_key=idempotency_key)

    def post_autonomy_me_signals(self, body=None, idempotency_key=None):
        """Tell Xovris how you prefer to work (POST /v1/autonomy/me/signals)"""
        return self._call("POST", f"/v1/autonomy/me/signals", body=body, idempotency_key=idempotency_key)

    def post_autonomy_people(self, body=None, idempotency_key=None):
        """Have a joiner made ready before day one, or a leaver's access removed on their last day (POST /v1/autonomy/people)"""
        return self._call("POST", f"/v1/autonomy/people", body=body, idempotency_key=idempotency_key)

    def post_autonomy_people_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a joiner or a leaver (POST /v1/autonomy/people/{id}/undo)"""
        return self._call("POST", f"/v1/autonomy/people/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_autonomy_renewals(self, body=None, idempotency_key=None):
        """Have Xovris renew everything inside its renewal window now (POST /v1/autonomy/renewals)"""
        return self._call("POST", f"/v1/autonomy/renewals", body=body, idempotency_key=idempotency_key)

    def post_autonomy_sitting(self, body=None, idempotency_key=None):
        """Start one sitting to say every yes at once (POST /v1/autonomy/sitting)"""
        return self._call("POST", f"/v1/autonomy/sitting", body=body, idempotency_key=idempotency_key)

    def post_autonomy_sitting_by_id_end(self, id_, body=None, idempotency_key=None):
        """End a sitting (POST /v1/autonomy/sitting/{id}/end)"""
        return self._call("POST", f"/v1/autonomy/sitting/{_q(id_)}/end", body=body, idempotency_key=idempotency_key)

    def post_autonomy_sitting_by_id_yes(self, id_, body=None, idempotency_key=None):
        """Say one yes in a sitting; Xovris carries that setup on at once (POST /v1/autonomy/sitting/{id}/yes)"""
        return self._call("POST", f"/v1/autonomy/sitting/{_q(id_)}/yes", body=body, idempotency_key=idempotency_key)

    def post_autonomy_spend_by_id_restore(self, id_, body=None, idempotency_key=None):
        """Give back what an undone spend change took (POST /v1/autonomy/spend/{id}/restore)"""
        return self._call("POST", f"/v1/autonomy/spend/{_q(id_)}/restore", body=body, idempotency_key=idempotency_key)

    def post_autonomy_spend_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a spend change (POST /v1/autonomy/spend/{id}/undo)"""
        return self._call("POST", f"/v1/autonomy/spend/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_autonomy_spend_by_id_yes(self, id_, body=None, idempotency_key=None):
        """Say yes to a spend change that waits for you (POST /v1/autonomy/spend/{id}/yes)"""
        return self._call("POST", f"/v1/autonomy/spend/{_q(id_)}/yes", body=body, idempotency_key=idempotency_key)

    def post_autonomy_spend_clean(self, body=None, idempotency_key=None):
        """Have Xovris release unused seats and licences under your policy (POST /v1/autonomy/spend/clean)"""
        return self._call("POST", f"/v1/autonomy/spend/clean", body=body, idempotency_key=idempotency_key)

    def post_autonomy_spend_purchase(self, body=None, idempotency_key=None):
        """Make a purchase under your spend policy; above it, it waits for your yes (POST /v1/autonomy/spend/purchase)"""
        return self._call("POST", f"/v1/autonomy/spend/purchase", body=body, idempotency_key=idempotency_key)

    def post_autonomy_stack_by_tool_dismiss(self, tool, body=None, idempotency_key=None):
        """Set aside a tool Xovris found that you do not use (POST /v1/autonomy/stack/{tool}/dismiss)"""
        return self._call("POST", f"/v1/autonomy/stack/{_q(tool)}/dismiss", body=body, idempotency_key=idempotency_key)

    def post_autonomy_stack_read(self, body=None, idempotency_key=None):
        """Read the tools your company uses from your domain's public records (POST /v1/autonomy/stack/read)"""
        return self._call("POST", f"/v1/autonomy/stack/read", body=body, idempotency_key=idempotency_key)

    def post_autonomy_vendor_cases(self, body=None, idempotency_key=None):
        """Have Xovris open a support case with a vendor and chase it until it is fixed (POST /v1/autonomy/vendor-cases)"""
        return self._call("POST", f"/v1/autonomy/vendor-cases", body=body, idempotency_key=idempotency_key)

    def post_autonomy_vendor_cases_by_id_reply(self, id_, body=None, idempotency_key=None):
        """Record the vendor's reply; a fix is settled with the vendor's words as proof (POST /v1/autonomy/vendor-cases/{id}/reply)"""
        return self._call("POST", f"/v1/autonomy/vendor-cases/{_q(id_)}/reply", body=body, idempotency_key=idempotency_key)

    def post_backups_find(self, body=None, idempotency_key=None):
        """Have Xovris find the backups your systems already make (POST /v1/backups/find)"""
        return self._call("POST", f"/v1/backups/find", body=body, idempotency_key=idempotency_key)

    def post_backups_unwire(self, body=None, idempotency_key=None):
        """Stop Xovris watching a backup, putting it back as it was (POST /v1/backups/unwire)"""
        return self._call("POST", f"/v1/backups/unwire", body=body, idempotency_key=idempotency_key)

    def post_backups_wire(self, body=None, idempotency_key=None):
        """Have Xovris watch a backup and prove it can be restored (POST /v1/backups/wire)"""
        return self._call("POST", f"/v1/backups/wire", body=body, idempotency_key=idempotency_key)

    def post_badges(self, body=None, idempotency_key=None):
        """Make a live badge for a site you watch (POST /v1/badges)"""
        return self._call("POST", f"/v1/badges", body=body, idempotency_key=idempotency_key)

    def post_badges_by_id_revoke(self, id_, body=None, idempotency_key=None):
        """Revoke a badge (POST /v1/badges/{id}/revoke)"""
        return self._call("POST", f"/v1/badges/{_q(id_)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_billing_stripe_events(self, body=None, idempotency_key=None):
        """Take in a billing event from the payment provider (POST /v1/billing/stripe/events)"""
        return self._call("POST", f"/v1/billing/stripe/events", body=body, idempotency_key=idempotency_key)

    def post_bills_spike(self, body=None, idempotency_key=None):
        """Check a bill for a spike against its own normal, and whether the month will pass its budget (POST /v1/bills/spike)"""
        return self._call("POST", f"/v1/bills/spike", body=body, idempotency_key=idempotency_key)

    def post_board_starter(self, body=None, idempotency_key=None):
        """Set up your dashboard from what Xovris already watches - your checks, its fixes, your cloud bill and your devices (POST /v1/board/starter)"""
        return self._call("POST", f"/v1/board/starter", body=body, idempotency_key=idempotency_key)

    def post_board_tiles(self, body=None, idempotency_key=None):
        """Pin an answer's chart or calculator to your dashboard as a live tile (POST /v1/board/tiles)"""
        return self._call("POST", f"/v1/board/tiles", body=body, idempotency_key=idempotency_key)

    def post_budget_forecast(self, body=None, idempotency_key=None):
        """See next year's IT budget from what you pay now and the contracts that renew (POST /v1/budget/forecast)"""
        return self._call("POST", f"/v1/budget/forecast", body=body, idempotency_key=idempotency_key)

    def post_builds_size(self, body=None, idempotency_key=None):
        """Record a build's size by asset and dependency (POST /v1/builds/size)"""
        return self._call("POST", f"/v1/builds/size", body=body, idempotency_key=idempotency_key)

    def post_carry_on_ask_admins(self, body=None, idempotency_key=None):
        """Ask this workspace's admins to approve a step (POST /v1/carry-on/ask-admins)"""
        return self._call("POST", f"/v1/carry-on/ask-admins", body=body, idempotency_key=idempotency_key)

    def post_carry_on_by_id_now(self, id_, body=None, idempotency_key=None):
        """Have Xovris try the next step now (POST /v1/carry-on/{id}/now)"""
        return self._call("POST", f"/v1/carry-on/{_q(id_)}/now", body=body, idempotency_key=idempotency_key)

    def post_carry_on_redeliver_key(self, body=None, idempotency_key=None):
        """Have Xovris put a fresh key into the place that sends to it (POST /v1/carry-on/redeliver-key)"""
        return self._call("POST", f"/v1/carry-on/redeliver-key", body=body, idempotency_key=idempotency_key)

    def post_changes_will_it_break(self, body=None, idempotency_key=None):
        """Ask whether a change will break anything before you make it (POST /v1/changes/will-it-break)"""
        return self._call("POST", f"/v1/changes/will-it-break", body=body, idempotency_key=idempotency_key)

    def post_checks(self, body=None, idempotency_key=None):
        """Add a check (POST /v1/checks)"""
        return self._call("POST", f"/v1/checks", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_pause(self, id_, body=None, idempotency_key=None):
        """Pause a check (POST /v1/checks/{id}/pause)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/pause", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_promise_alerts(self, id_, body=None, idempotency_key=None):
        """Be told when a check's promise is at risk of being missed (POST /v1/checks/{id}/promise/alerts)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/promise/alerts", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_promise_corrections(self, id_, body=None, idempotency_key=None):
        """Correct a check's promise for a window that should not count against it, with the reason (POST /v1/checks/{id}/promise/corrections)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/promise/corrections", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a check (POST /v1/checks/{id}/resume)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_rollback(self, id_, body=None, idempotency_key=None):
        """Roll a check back to an earlier version (POST /v1/checks/{id}/rollback)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/rollback", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_run_now(self, id_, body=None, idempotency_key=None):
        """Run a check now from every location (POST /v1/checks/{id}/run-now)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/run-now", body=body, idempotency_key=idempotency_key)

    def post_checks_by_id_schedule(self, id_, body=None, idempotency_key=None):
        """Change when a check runs (POST /v1/checks/{id}/schedule)"""
        return self._call("POST", f"/v1/checks/{_q(id_)}/schedule", body=body, idempotency_key=idempotency_key)

    def post_checks_deploy(self, body=None, idempotency_key=None):
        """Deploy checks from code (POST /v1/checks/deploy)"""
        return self._call("POST", f"/v1/checks/deploy", body=body, idempotency_key=idempotency_key)

    def post_checks_fix(self, body=None, idempotency_key=None):
        """Have Xovris rewrite a failing check so it passes again (POST /v1/checks/fix)"""
        return self._call("POST", f"/v1/checks/fix", body=body, idempotency_key=idempotency_key)

    def post_checks_journeys_walk(self, body=None, idempotency_key=None):
        """Have Xovris record journeys by walking your site (POST /v1/checks/journeys/walk)"""
        return self._call("POST", f"/v1/checks/journeys/walk", body=body, idempotency_key=idempotency_key)

    def post_checks_probes(self, body=None, idempotency_key=None):
        """Add a private probe (POST /v1/checks/probes)"""
        return self._call("POST", f"/v1/checks/probes", body=body, idempotency_key=idempotency_key)

    def post_checks_probes_by_id_revoke(self, id_, body=None, idempotency_key=None):
        """Revoke a private probe (POST /v1/checks/probes/{id}/revoke)"""
        return self._call("POST", f"/v1/checks/probes/{_q(id_)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_checks_secrets(self, body=None, idempotency_key=None):
        """Add a secret for checks, sealed (POST /v1/checks/secrets)"""
        return self._call("POST", f"/v1/checks/secrets", body=body, idempotency_key=idempotency_key)

    def post_checks_suggestions(self, body=None, idempotency_key=None):
        """Suggest journeys from real visits (POST /v1/checks/suggestions)"""
        return self._call("POST", f"/v1/checks/suggestions", body=body, idempotency_key=idempotency_key)

    def post_checks_test(self, body=None, idempotency_key=None):
        """Run a check once without saving it (POST /v1/checks/test)"""
        return self._call("POST", f"/v1/checks/test", body=body, idempotency_key=idempotency_key)

    def post_cloud_aws_callback(self, body=None, idempotency_key=None):
        """Receive the result of an AWS account connection from its stack (POST /v1/cloud/aws/callback)"""
        return self._call("POST", f"/v1/cloud/aws/callback", body=body, idempotency_key=idempotency_key)

    def post_cloud_connections(self, body=None, idempotency_key=None):
        """Start connecting a cloud account with one link (POST /v1/cloud/connections)"""
        return self._call("POST", f"/v1/cloud/connections", body=body, idempotency_key=idempotency_key)

    def post_cloud_connections_by_id_bill_regions(self, id_, body=None, idempotency_key=None):
        """Read an AWS account's bill by region, its Cost Explorer charge said before you accept (POST /v1/cloud/connections/{id}/bill/regions)"""
        return self._call("POST", f"/v1/cloud/connections/{_q(id_)}/bill/regions", body=body, idempotency_key=idempotency_key)

    def post_cloud_connections_by_id_check(self, id_, body=None, idempotency_key=None):
        """Check a cloud connection's access again (POST /v1/cloud/connections/{id}/check)"""
        return self._call("POST", f"/v1/cloud/connections/{_q(id_)}/check", body=body, idempotency_key=idempotency_key)

    def post_code_previews_by_token_by_path(self, token, path, body=None, idempotency_key=None):
        """Send to a build's own app while it is being made - a form, a sign-in or a call to its API (POST /v1/code/previews/{token}/{path})"""
        return self._call("POST", f"/v1/code/previews/{_q(token)}/{_q(path)}", body=body, idempotency_key=idempotency_key)

    def post_code_projects_by_id_checkpoints(self, id_, body=None, idempotency_key=None):
        """Save a checkpoint of a build's data, to go back to later (POST /v1/code/projects/{id}/checkpoints)"""
        return self._call("POST", f"/v1/code/projects/{_q(id_)}/checkpoints", body=body, idempotency_key=idempotency_key)

    def post_code_projects_by_id_checkpoints_by_checkpoint_restore(self, id_, checkpoint, body=None, idempotency_key=None):
        """Put a build's data back to how it was at one checkpoint (POST /v1/code/projects/{id}/checkpoints/{checkpoint}/restore)"""
        return self._call("POST", f"/v1/code/projects/{_q(id_)}/checkpoints/{_q(checkpoint)}/restore", body=body, idempotency_key=idempotency_key)

    def post_code_projects_by_id_domains(self, id_, body=None, idempotency_key=None):
        """Put a build's site on your own domain (POST /v1/code/projects/{id}/domains)"""
        return self._call("POST", f"/v1/code/projects/{_q(id_)}/domains", body=body, idempotency_key=idempotency_key)

    def post_code_projects_by_id_domains_by_domain_check(self, id_, domain, body=None, idempotency_key=None):
        """Check that your domain points at a build's site, and what is still to set (POST /v1/code/projects/{id}/domains/{domain}/check)"""
        return self._call("POST", f"/v1/code/projects/{_q(id_)}/domains/{_q(domain)}/check", body=body, idempotency_key=idempotency_key)

    def post_code_projects_by_id_relays(self, id_, body=None, idempotency_key=None):
        """Opens a relay from a build session to a system on the person's own network, through Xovris's app there (POST /v1/code/projects/{id}/relays)"""
        return self._call("POST", f"/v1/code/projects/{_q(id_)}/relays", body=body, idempotency_key=idempotency_key)

    def post_code_projects_by_id_resources_by_kind(self, id_, kind, body=None, idempotency_key=None):
        """Switch on a part a build runs on - a database, storage, sign-in or a schedule (POST /v1/code/projects/{id}/resources/{kind})"""
        return self._call("POST", f"/v1/code/projects/{_q(id_)}/resources/{_q(kind)}", body=body, idempotency_key=idempotency_key)

    def post_code_projects_import(self, body=None, idempotency_key=None):
        """Bring a build made elsewhere in as a project of your own (POST /v1/code/projects/import)"""
        return self._call("POST", f"/v1/code/projects/import", body=body, idempotency_key=idempotency_key)

    def post_code_shared_by_token_preview_by_path(self, token, path, body=None, idempotency_key=None):
        """Send to a shared build's own app - a form, a sign-in or a call to its API (POST /v1/code/shared/{token}/preview/{path})"""
        return self._call("POST", f"/v1/code/shared/{_q(token)}/preview/{_q(path)}", body=body, idempotency_key=idempotency_key)

    def post_code_sites_by_token_by_path(self, token, path, body=None, idempotency_key=None):
        """Send to the app a build deployed - a form, a sign-in or a call to its API (POST /v1/code/sites/{token}/{path})"""
        return self._call("POST", f"/v1/code/sites/{_q(token)}/{_q(path)}", body=body, idempotency_key=idempotency_key)

    def post_code_tasks(self, body=None, idempotency_key=None):
        """Hand Xovris any coding job in words - in your repository, a public one or none - and follow it to a proven change (POST /v1/code/tasks)"""
        return self._call("POST", f"/v1/code/tasks", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_answer(self, id_, body=None, idempotency_key=None):
        """Answer a waiting coding job - it carries on in the same job, nothing redone (POST /v1/code/tasks/{id}/answer)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/answer", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_cancel(self, id_, body=None, idempotency_key=None):
        """Stop a build that is running - nothing more is written or charged (POST /v1/code/tasks/{id}/cancel)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/cancel", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_deploy(self, id_, body=None, idempotency_key=None):
        """Deploy a build that passed its checks to a live address (POST /v1/code/tasks/{id}/deploy)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/deploy", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_inbox(self, id_, body=None, idempotency_key=None):
        """Hands an event to a running build - a failing run, an error, a message - which it works on at once and answers where it came from (POST /v1/code/tasks/{id}/inbox)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/inbox", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_inbox_by_event_answer(self, id_, event, body=None, idempotency_key=None):
        """Answers one event a build was handed, sent back where it came from and kept on it (POST /v1/code/tasks/{id}/inbox/{event}/answer)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/inbox/{_q(event)}/answer", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_push(self, id_, body=None, idempotency_key=None):
        """Push a build's code to your own repository (POST /v1/code/tasks/{id}/push)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/push", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_restore(self, id_, body=None, idempotency_key=None):
        """Put a build back to one of its earlier versions (POST /v1/code/tasks/{id}/restore)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/restore", body=body, idempotency_key=idempotency_key)

    def post_code_tasks_by_id_shares(self, id_, body=None, idempotency_key=None):
        """Share a build with a link - to watch it, read its files or open its preview, for as long as you choose (POST /v1/code/tasks/{id}/shares)"""
        return self._call("POST", f"/v1/code/tasks/{_q(id_)}/shares", body=body, idempotency_key=idempotency_key)

    def post_collectors_by_uid_doors_by_door(self, uid, door, body=None, idempotency_key=None):
        """Have Xovris change one of your collectors' configuration, read it back and keep the way back (POST /v1/collectors/{uid}/doors/{door})"""
        return self._call("POST", f"/v1/collectors/{_q(uid)}/doors/{_q(door)}", body=body, idempotency_key=idempotency_key)

    def post_collectors_by_uid_doors_by_door_undo(self, uid, door, body=None, idempotency_key=None):
        """Put a collector's configuration back exactly as it was before Xovris changed it (POST /v1/collectors/{uid}/doors/{door}/undo)"""
        return self._call("POST", f"/v1/collectors/{_q(uid)}/doors/{_q(door)}/undo", body=body, idempotency_key=idempotency_key)

    def post_collectors_by_uid_repair(self, uid, body=None, idempotency_key=None):
        """Put back the configuration that last worked (POST /v1/collectors/{uid}/repair)"""
        return self._call("POST", f"/v1/collectors/{_q(uid)}/repair", body=body, idempotency_key=idempotency_key)

    def post_collectors_config(self, body=None, idempotency_key=None):
        """Send a configuration to your collectors (POST /v1/collectors/config)"""
        return self._call("POST", f"/v1/collectors/config", body=body, idempotency_key=idempotency_key)

    def post_collectors_connect(self, body=None, idempotency_key=None):
        """Connect a telemetry collector you already run (POST /v1/collectors/connect)"""
        return self._call("POST", f"/v1/collectors/connect", body=body, idempotency_key=idempotency_key)

    def post_companies(self, body=None, idempotency_key=None):
        """Add a company under your account that shares its plan (POST /v1/companies)"""
        return self._call("POST", f"/v1/companies", body=body, idempotency_key=idempotency_key)

    def post_compliance_frameworks(self, body=None, idempotency_key=None):
        """Read any compliance framework you name against your live evidence (POST /v1/compliance/frameworks)"""
        return self._call("POST", f"/v1/compliance/frameworks", body=body, idempotency_key=idempotency_key)

    def post_computers(self, body=None, idempotency_key=None):
        """Start a desktop on Xovris's own cloud computer, joined to this workspace as one more of your computers (POST /v1/computers)"""
        return self._call("POST", f"/v1/computers", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_desk_answer(self, id_, body=None, idempotency_key=None):
        """The desktop's own door: what one terminal step printed, for the step that ran it (POST /v1/computers/{id}/desk/answer)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/desk/answer", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_desk_file(self, id_, body=None, idempotency_key=None):
        """The desktop's own door: a file the session downloaded on Xovris's own computer, kept under that session for the person (POST /v1/computers/{id}/desk/file)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/desk/file", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_desk_frame(self, id_, body=None, idempotency_key=None):
        """The desktop's own door: it sends its latest screen with the key it was started with (POST /v1/computers/{id}/desk/frame)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/desk/frame", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_desk_region(self, id_, body=None, idempotency_key=None):
        """The desktop's own door: one region of its screen captured at the screen's own resolution, lossless, for the closer look that asked for it (POST /v1/computers/{id}/desk/region)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/desk/region", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_desk_tree(self, id_, body=None, idempotency_key=None):
        """The desktop's own door: the page in front - its address and controls, each with its place on the screen - read on the desktop just before the screen it sends next (POST /v1/computers/{id}/desk/tree)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/desk/tree", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_hold(self, id_, body=None, idempotency_key=None):
        """Take a desktop from the agent to use it yourself (POST /v1/computers/{id}/hold)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/hold", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_input(self, id_, body=None, idempotency_key=None):
        """Send your own clicks, typing and keys to a desktop you hold (POST /v1/computers/{id}/input)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/input", body=body, idempotency_key=idempotency_key)

    def post_computers_by_id_release(self, id_, body=None, idempotency_key=None):
        """Hand a desktop you hold back to the agent (POST /v1/computers/{id}/release)"""
        return self._call("POST", f"/v1/computers/{_q(id_)}/release", body=body, idempotency_key=idempotency_key)

    def post_computer_schedules(self, body=None, idempotency_key=None):
        """Give Xovris's own computer a goal for a time you set, and again on your cadence - your own computer may be off (POST /v1/computer/schedules)"""
        return self._call("POST", f"/v1/computer/schedules", body=body, idempotency_key=idempotency_key)

    def post_computer_schedules_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Turn a stopped schedule back on - its next run one cadence from now, its runs kept (POST /v1/computer/schedules/{id}/resume)"""
        return self._call("POST", f"/v1/computer/schedules/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_computer_schedules_by_id_run(self, id_, body=None, idempotency_key=None):
        """Xovris carries out a scheduled goal at once on its own computer, its own times kept (POST /v1/computer/schedules/{id}/run)"""
        return self._call("POST", f"/v1/computer/schedules/{_q(id_)}/run", body=body, idempotency_key=idempotency_key)

    def post_computer_schedules_by_id_stop(self, id_, body=None, idempotency_key=None):
        """Stop a schedule - it runs no more, and its runs stay (POST /v1/computer/schedules/{id}/stop)"""
        return self._call("POST", f"/v1/computer/schedules/{_q(id_)}/stop", body=body, idempotency_key=idempotency_key)

    def post_computer_sessions(self, body=None, idempotency_key=None):
        """Give Xovris a goal to carry out on a computer - its own cloud computer, or one of yours you have given it access to - one step at a time from what is on the screen (POST /v1/computer/sessions)"""
        return self._call("POST", f"/v1/computer/sessions", body=body, idempotency_key=idempotency_key)

    def post_computer_sessions_by_id_confirm(self, id_, body=None, idempotency_key=None):
        """Say yes or no to the step a computer session is about to take that commits something in the world - it waits for your answer and goes on as you said (POST /v1/computer/sessions/{id}/confirm)"""
        return self._call("POST", f"/v1/computer/sessions/{_q(id_)}/confirm", body=body, idempotency_key=idempotency_key)

    def post_computer_sessions_by_id_handback(self, id_, body=None, idempotency_key=None):
        """Hand a computer back to the session after doing a step yourself - it carries on from what the screen shows (POST /v1/computer/sessions/{id}/handback)"""
        return self._call("POST", f"/v1/computer/sessions/{_q(id_)}/handback", body=body, idempotency_key=idempotency_key)

    def post_computer_sessions_by_id_steer(self, id_, body=None, idempotency_key=None):
        """Steer a computer session while it works, by your own words said or typed - its next step reads them; Esc alone takes it back (POST /v1/computer/sessions/{id}/steer)"""
        return self._call("POST", f"/v1/computer/sessions/{_q(id_)}/steer", body=body, idempotency_key=idempotency_key)

    def post_computer_sessions_by_id_stop(self, id_, body=None, idempotency_key=None):
        """Take a computer session back before its next step - the same as pressing Esc while it works (POST /v1/computer/sessions/{id}/stop)"""
        return self._call("POST", f"/v1/computer/sessions/{_q(id_)}/stop", body=body, idempotency_key=idempotency_key)

    def post_computer_sessions_by_id_upload(self, id_, body=None, idempotency_key=None):
        """Give a working session a file - it lands in the Uploads folder of Xovris's own computer (POST /v1/computer/sessions/{id}/upload)"""
        return self._call("POST", f"/v1/computer/sessions/{_q(id_)}/upload", body=body, idempotency_key=idempotency_key)

    def post_connect(self, body=None, idempotency_key=None):
        """Connect Xovris to anything you name: a web address, an API, a database, a device, a serial line, a webhook source or a service's name (POST /v1/connect)"""
        return self._call("POST", f"/v1/connect", body=body, idempotency_key=idempotency_key)

    def post_connect_find(self, body=None, idempotency_key=None):
        """Say what you need in your own words and see every service that serves it, and why - read by meaning, never by a category (POST /v1/connect/find)"""
        return self._call("POST", f"/v1/connect/find", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_domains_by_domain_lock(self, id_, domain, body=None, idempotency_key=None):
        """Turn a domain's transfer lock on or off at its registrar, read back after (POST /v1/connections/{id}/domains/{domain}/lock)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/domains/{_q(domain)}/lock", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_domains_by_domain_transfer_code(self, id_, domain, body=None, idempotency_key=None):
        """Read a domain's transfer code from its registrar, for the registrar it moves to - handed over, never kept (POST /v1/connections/{id}/domains/{domain}/transfer-code)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/domains/{_q(domain)}/transfer-code", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_github_door(self, id_, body=None, idempotency_key=None):
        """Have Xovris open the GitHub step it needs, with you there (POST /v1/connections/{id}/github/door)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/github/door", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_github_install(self, id_, body=None, idempotency_key=None):
        """Install Xovris on your GitHub repositories (POST /v1/connections/{id}/github/install)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/github/install", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_github_pull_request(self, id_, body=None, idempotency_key=None):
        """Have Xovris open a proven pull request on GitHub (POST /v1/connections/{id}/github/pull-request)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/github/pull-request", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_reassign(self, id_, body=None, idempotency_key=None):
        """Move a connection to another person (POST /v1/connections/{id}/reassign)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/reassign", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_remove(self, id_, body=None, idempotency_key=None):
        """Remove a connection (POST /v1/connections/{id}/remove)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/remove", body=body, idempotency_key=idempotency_key)

    def post_connections_by_id_rotate_key(self, id_, body=None, idempotency_key=None):
        """Rotate a connection's key (POST /v1/connections/{id}/rotate-key)"""
        return self._call("POST", f"/v1/connections/{_q(id_)}/rotate-key", body=body, idempotency_key=idempotency_key)

    def post_connections_dns_by_id_disconnect(self, id_, body=None, idempotency_key=None):
        """Disconnect a DNS provider (POST /v1/connections/dns/{id}/disconnect)"""
        return self._call("POST", f"/v1/connections/dns/{_q(id_)}/disconnect", body=body, idempotency_key=idempotency_key)

    def post_connections_dns_by_id_token_check(self, id_, body=None, idempotency_key=None):
        """Check what a DNS connection's token may read and change (POST /v1/connections/dns/{id}/token/check)"""
        return self._call("POST", f"/v1/connections/dns/{_q(id_)}/token/check", body=body, idempotency_key=idempotency_key)

    def post_connections_dns_cloudflare_oauth(self, body=None, idempotency_key=None):
        """Connect Cloudflare by signing in (POST /v1/connections/dns/cloudflare/oauth)"""
        return self._call("POST", f"/v1/connections/dns/cloudflare/oauth", body=body, idempotency_key=idempotency_key)

    def post_connections_dns_cloudflare_preview(self, body=None, idempotency_key=None):
        """Preview what a Cloudflare connection would allow (POST /v1/connections/dns/cloudflare/preview)"""
        return self._call("POST", f"/v1/connections/dns/cloudflare/preview", body=body, idempotency_key=idempotency_key)

    def post_connections_dns_cloudflare_token(self, body=None, idempotency_key=None):
        """Connect Cloudflare with an API token (POST /v1/connections/dns/cloudflare/token)"""
        return self._call("POST", f"/v1/connections/dns/cloudflare/token", body=body, idempotency_key=idempotency_key)

    def post_connections_dns_route53(self, body=None, idempotency_key=None):
        """Connect a Route 53 hosted zone through the workspace's AWS role (POST /v1/connections/dns/route53)"""
        return self._call("POST", f"/v1/connections/dns/route53", body=body, idempotency_key=idempotency_key)

    def post_connections_sentry(self, body=None, idempotency_key=None):
        """Connect Sentry (POST /v1/connections/sentry)"""
        return self._call("POST", f"/v1/connections/sentry", body=body, idempotency_key=idempotency_key)

    def post_connect_plan(self, body=None, idempotency_key=None):
        """See how Xovris would connect what you name, before anything changes (POST /v1/connect/plan)"""
        return self._call("POST", f"/v1/connect/plan", body=body, idempotency_key=idempotency_key)

    def post_continuity(self, body=None, idempotency_key=None):
        """See who and what the business depends on, so nothing stops when one person is away (POST /v1/continuity)"""
        return self._call("POST", f"/v1/continuity", body=body, idempotency_key=idempotency_key)

    def post_crypto_post_quantum(self, body=None, idempotency_key=None):
        """See what still has to move to encryption that holds against quantum computers (POST /v1/crypto/post-quantum)"""
        return self._call("POST", f"/v1/crypto/post-quantum", body=body, idempotency_key=idempotency_key)

    def post_dashboards(self, body=None, idempotency_key=None):
        """Build a dashboard from a question (POST /v1/dashboards)"""
        return self._call("POST", f"/v1/dashboards", body=body, idempotency_key=idempotency_key)

    def post_dashboards_by_id_embeds(self, id_, body=None, idempotency_key=None):
        """Embed one dashboard panel (POST /v1/dashboards/{id}/embeds)"""
        return self._call("POST", f"/v1/dashboards/{_q(id_)}/embeds", body=body, idempotency_key=idempotency_key)

    def post_dashboards_by_id_panels_by_panel_id_silence(self, id_, panel_id, body=None, idempotency_key=None):
        """Silence a dashboard panel's alerts (POST /v1/dashboards/{id}/panels/{panelId}/silence)"""
        return self._call("POST", f"/v1/dashboards/{_q(id_)}/panels/{_q(panel_id)}/silence", body=body, idempotency_key=idempotency_key)

    def post_dashboards_by_id_reports(self, id_, body=None, idempotency_key=None):
        """Send a dashboard as a daily or weekly report (POST /v1/dashboards/{id}/reports)"""
        return self._call("POST", f"/v1/dashboards/{_q(id_)}/reports", body=body, idempotency_key=idempotency_key)

    def post_dashboards_by_id_shares(self, id_, body=None, idempotency_key=None):
        """Share a dashboard by an expiring link (POST /v1/dashboards/{id}/shares)"""
        return self._call("POST", f"/v1/dashboards/{_q(id_)}/shares", body=body, idempotency_key=idempotency_key)

    def post_dashboards_by_id_tv(self, id_, body=None, idempotency_key=None):
        """Show a dashboard on a TV by its code (POST /v1/dashboards/{id}/tv)"""
        return self._call("POST", f"/v1/dashboards/{_q(id_)}/tv", body=body, idempotency_key=idempotency_key)

    def post_data_scan(self, body=None, idempotency_key=None):
        """Check text for sensitive data; Xovris answers with masked findings and keeps nothing (POST /v1/data/scan)"""
        return self._call("POST", f"/v1/data/scan", body=body, idempotency_key=idempotency_key)

    def post_decisions_by_id(self, id_, body=None, idempotency_key=None):
        """Approve or decline a change waiting for you (POST /v1/decisions/{id})"""
        return self._call("POST", f"/v1/decisions/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def post_decoys(self, body=None, idempotency_key=None):
        """Place decoys that open a security incident the moment anyone touches one (POST /v1/decoys)"""
        return self._call("POST", f"/v1/decoys", body=body, idempotency_key=idempotency_key)

    def post_decoys_trips(self, body=None, idempotency_key=None):
        """Check whether anyone touched one of your decoys (POST /v1/decoys/trips)"""
        return self._call("POST", f"/v1/decoys/trips", body=body, idempotency_key=idempotency_key)

    def post_delivery_deployments(self, body=None, idempotency_key=None):
        """Record a deployment (POST /v1/delivery/deployments)"""
        return self._call("POST", f"/v1/delivery/deployments", body=body, idempotency_key=idempotency_key)

    def post_device_by_code_approve(self, code, body=None, idempotency_key=None):
        """Approve a device sign-in (POST /v1/device/{code}/approve)"""
        return self._call("POST", f"/v1/device/{_q(code)}/approve", body=body, idempotency_key=idempotency_key)

    def post_device_by_code_deny(self, code, body=None, idempotency_key=None):
        """Deny a device sign-in (POST /v1/device/{code}/deny)"""
        return self._call("POST", f"/v1/device/{_q(code)}/deny", body=body, idempotency_key=idempotency_key)

    def post_device_code(self, body=None, idempotency_key=None):
        """Start a device sign-in (POST /v1/device/code)"""
        return self._call("POST", f"/v1/device/code", body=body, idempotency_key=idempotency_key)

    def post_devices_apple_profiles(self, body=None, idempotency_key=None):
        """Have Xovris make a configuration profile for an iPhone or iPad (POST /v1/devices/apple/profiles)"""
        return self._call("POST", f"/v1/devices/apple/profiles", body=body, idempotency_key=idempotency_key)

    def post_devices_app_updates_by_id_halt(self, id_, body=None, idempotency_key=None):
        """Halt an application update's rollout (POST /v1/devices/app-updates/{id}/halt)"""
        return self._call("POST", f"/v1/devices/app-updates/{_q(id_)}/halt", body=body, idempotency_key=idempotency_key)

    def post_devices_app_updates_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a halted application update (POST /v1/devices/app-updates/{id}/resume)"""
        return self._call("POST", f"/v1/devices/app-updates/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_appliances(self, id_, body=None, idempotency_key=None):
        """Connect a device's appliance door so Xovris can read and patch it (POST /v1/devices/{id}/appliances)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/appliances", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_checks(self, id_, body=None, idempotency_key=None):
        """Ask a device to run a check (POST /v1/devices/{id}/checks)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/checks", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_doors_by_door_by_op(self, id_, door, op, body=None, idempotency_key=None):
        """Have a computer's Xovris agent change a thing through its own system's door, read back, with its way back kept (POST /v1/devices/{id}/doors/{door}/{op})"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/doors/{_q(door)}/{_q(op)}", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_fixes_by_report_id_undo(self, id_, report_id, body=None, idempotency_key=None):
        """Put back a change Xovris made on a device, exactly as it was before (POST /v1/devices/{id}/fixes/{reportId}/undo)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/fixes/{_q(report_id)}/undo", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_local_tasks(self, id_, body=None, idempotency_key=None):
        """Give a computer's Xovris agent a task to run through the one gate it answers to (POST /v1/devices/{id}/local-tasks)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/local-tasks", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_provider_status(self, id_, body=None, idempotency_key=None):
        """Read a device's provider status through its agent (POST /v1/devices/{id}/provider-status)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/provider-status", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_push_install(self, id_, body=None, idempotency_key=None):
        """Have one computer install the Xovris agent on another (POST /v1/devices/{id}/push-install)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/push-install", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_revoke(self, id_, body=None, idempotency_key=None):
        """Revoke a device (POST /v1/devices/{id}/revoke)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_settings(self, id_, body=None, idempotency_key=None):
        """Change a device's settings (POST /v1/devices/{id}/settings)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/settings", body=body, idempotency_key=idempotency_key)

    def post_devices_by_id_technician_brief(self, id_, body=None, idempotency_key=None):
        """See the brief a technician would get for a job only a person's hand can do (POST /v1/devices/{id}/technician/brief)"""
        return self._call("POST", f"/v1/devices/{_q(id_)}/technician/brief", body=body, idempotency_key=idempotency_key)

    def post_devices_enrolment_codes(self, body=None, idempotency_key=None):
        """Make a code to add a device (POST /v1/devices/enrolment-codes)"""
        return self._call("POST", f"/v1/devices/enrolment-codes", body=body, idempotency_key=idempotency_key)

    def post_devices_groups(self, body=None, idempotency_key=None):
        """Make a group of devices to watch and manage together (POST /v1/devices/groups)"""
        return self._call("POST", f"/v1/devices/groups", body=body, idempotency_key=idempotency_key)

    def post_devices_groups_by_group_id_admins(self, group_id, body=None, idempotency_key=None):
        """The people who may manage a device group (POST /v1/devices/groups/{groupId}/admins)"""
        return self._call("POST", f"/v1/devices/groups/{_q(group_id)}/admins", body=body, idempotency_key=idempotency_key)

    def post_devices_groups_by_group_id_checks(self, group_id, body=None, idempotency_key=None):
        """Checks that run on every device in a group (POST /v1/devices/groups/{groupId}/checks)"""
        return self._call("POST", f"/v1/devices/groups/{_q(group_id)}/checks", body=body, idempotency_key=idempotency_key)

    def post_devices_pair_fixes(self, body=None, idempotency_key=None):
        """Start a fix that needs two devices, its first step signed for its device (POST /v1/devices/pair-fixes)"""
        return self._call("POST", f"/v1/devices/pair-fixes", body=body, idempotency_key=idempotency_key)

    def post_devices_pair_fixes_next(self, body=None, idempotency_key=None):
        """Get the next step of a fix across devices, with the value the step before handed on (POST /v1/devices/pair-fixes/next)"""
        return self._call("POST", f"/v1/devices/pair-fixes/next", body=body, idempotency_key=idempotency_key)

    def post_device_token(self, body=None, idempotency_key=None):
        """Finish a device sign-in (POST /v1/device/token)"""
        return self._call("POST", f"/v1/device/token", body=body, idempotency_key=idempotency_key)

    def post_disposal_certificate(self, body=None, idempotency_key=None):
        """Get a certificate that a device was wiped, once its check proves it (POST /v1/disposal/certificate)"""
        return self._call("POST", f"/v1/disposal/certificate", body=body, idempotency_key=idempotency_key)

    def post_disposal_plan(self, body=None, idempotency_key=None):
        """Plan how a device is wiped and disposed of safely (POST /v1/disposal/plan)"""
        return self._call("POST", f"/v1/disposal/plan", body=body, idempotency_key=idempotency_key)

    def post_dns_dangling_repoint(self, body=None, idempotency_key=None):
        """Point a record that points at something nobody owns where its host expects it (POST /v1/dns/dangling/repoint)"""
        return self._call("POST", f"/v1/dns/dangling/repoint", body=body, idempotency_key=idempotency_key)

    def post_dns_dangling_retire(self, body=None, idempotency_key=None):
        """Remove a record that points at something nobody owns (POST /v1/dns/dangling/retire)"""
        return self._call("POST", f"/v1/dns/dangling/retire", body=body, idempotency_key=idempotency_key)

    def post_dns_query_by_token(self, token, body=None, idempotency_key=None):
        """Ask a household member's protective resolver a DNS question (RFC 8484 POST) (POST /v1/dns-query/{token})"""
        return self._call("POST", f"/v1/dns-query/{_q(token)}", body=body, idempotency_key=idempotency_key)

    def post_dnssec_ds(self, body=None, idempotency_key=None):
        """Have Xovris give your registrar its DNSSEC record (POST /v1/dnssec/ds)"""
        return self._call("POST", f"/v1/dnssec/ds", body=body, idempotency_key=idempotency_key)

    def post_doors_extension_catch_by_id(self, id_, body=None, idempotency_key=None):
        """Catch a key a set-up page shows, once, into Xovris (POST /v1/doors/extension/catch/{id})"""
        return self._call("POST", f"/v1/doors/extension/catch/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def post_doors_extension_pair(self, body=None, idempotency_key=None):
        """Pair the Xovris extension in this browser (POST /v1/doors/extension/pair)"""
        return self._call("POST", f"/v1/doors/extension/pair", body=body, idempotency_key=idempotency_key)

    def post_doors_extension_pairings(self, body=None, idempotency_key=None):
        """Start pairing a browser with the Xovris extension (POST /v1/doors/extension/pairings)"""
        return self._call("POST", f"/v1/doors/extension/pairings", body=body, idempotency_key=idempotency_key)

    def post_doors_extension_results_by_id(self, id_, body=None, idempotency_key=None):
        """The paired extension reports a step it ran (POST /v1/doors/extension/results/{id})"""
        return self._call("POST", f"/v1/doors/extension/results/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def post_doors_extension_tasks(self, body=None, idempotency_key=None):
        """Give the paired extension a task to run with you there (POST /v1/doors/extension/tasks)"""
        return self._call("POST", f"/v1/doors/extension/tasks", body=body, idempotency_key=idempotency_key)

    def post_edge_protect(self, body=None, idempotency_key=None):
        """Put a virtual patch, a rate limit, an address block, Under Attack or Bot Fight on your own edge for a set time (POST /v1/edge/protect)"""
        return self._call("POST", f"/v1/edge/protect", body=body, idempotency_key=idempotency_key)

    def post_efficiency_applied(self, body=None, idempotency_key=None):
        """Say an efficiency change was made (POST /v1/efficiency/applied)"""
        return self._call("POST", f"/v1/efficiency/applied", body=body, idempotency_key=idempotency_key)

    def post_elevations(self, body=None, idempotency_key=None):
        """A role asked for a set time with its reason - given at once where the role needs no yes, else waiting for an administrator (POST /v1/elevations)"""
        return self._call("POST", f"/v1/elevations", body=body, idempotency_key=idempotency_key)

    def post_elevations_by_id_decide(self, id_, body=None, idempotency_key=None):
        """An administrator's yes or no to a role asked for - never to their own ask, never beyond what they hold (POST /v1/elevations/{id}/decide)"""
        return self._call("POST", f"/v1/elevations/{_q(id_)}/decide", body=body, idempotency_key=idempotency_key)

    def post_elevations_by_id_end(self, id_, body=None, idempotency_key=None):
        """A role given for a time ended before its end - from that second it grants nothing (POST /v1/elevations/{id}/end)"""
        return self._call("POST", f"/v1/elevations/{_q(id_)}/end", body=body, idempotency_key=idempotency_key)

    def post_everyday_acts_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo something Xovris did, with what was put back read again (POST /v1/everyday/acts/{id}/undo)"""
        return self._call("POST", f"/v1/everyday/acts/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_exports(self, body=None, idempotency_key=None):
        """Export incidents, fixes and traces to your own bucket (POST /v1/exports)"""
        return self._call("POST", f"/v1/exports", body=body, idempotency_key=idempotency_key)

    def post_exposure_check(self, body=None, idempotency_key=None):
        """Check for exposure now (POST /v1/exposure/check)"""
        return self._call("POST", f"/v1/exposure/check", body=body, idempotency_key=idempotency_key)

    def post_exposure_findings_by_id_dismiss(self, id_, body=None, idempotency_key=None):
        """Dismiss an exposure finding (POST /v1/exposure/findings/{id}/dismiss)"""
        return self._call("POST", f"/v1/exposure/findings/{_q(id_)}/dismiss", body=body, idempotency_key=idempotency_key)

    def post_exposure_findings_by_id_respond(self, id_, body=None, idempotency_key=None):
        """Respond to an exposure finding (POST /v1/exposure/findings/{id}/respond)"""
        return self._call("POST", f"/v1/exposure/findings/{_q(id_)}/respond", body=body, idempotency_key=idempotency_key)

    def post_exposure_prove(self, body=None, idempotency_key=None):
        """Confirm an address to watch for data breaches (POST /v1/exposure/prove)"""
        return self._call("POST", f"/v1/exposure/prove", body=body, idempotency_key=idempotency_key)

    def post_exposure_responses_by_id_steps_by_step_done(self, id_, step, body=None, idempotency_key=None):
        """Mark a response step done (POST /v1/exposure/responses/{id}/steps/{step}/done)"""
        return self._call("POST", f"/v1/exposure/responses/{_q(id_)}/steps/{_q(step)}/done", body=body, idempotency_key=idempotency_key)

    def post_exposure_watch(self, body=None, idempotency_key=None):
        """Watch an address, domain or brand (POST /v1/exposure/watch)"""
        return self._call("POST", f"/v1/exposure/watch", body=body, idempotency_key=idempotency_key)

    def post_exposure_watch_by_id_remove(self, id_, body=None, idempotency_key=None):
        """Stop watching for exposure (POST /v1/exposure/watch/{id}/remove)"""
        return self._call("POST", f"/v1/exposure/watch/{_q(id_)}/remove", body=body, idempotency_key=idempotency_key)

    def post_exposure_watch_by_id_verify(self, id_, body=None, idempotency_key=None):
        """Verify an exposure watch (POST /v1/exposure/watch/{id}/verify)"""
        return self._call("POST", f"/v1/exposure/watch/{_q(id_)}/verify", body=body, idempotency_key=idempotency_key)

    def post_extensions_apps(self, body=None, idempotency_key=None):
        """Install or update an app (POST /v1/extensions/apps)"""
        return self._call("POST", f"/v1/extensions/apps", body=body, idempotency_key=idempotency_key)

    def post_extensions_apps_by_app_id_test(self, app_id, body=None, idempotency_key=None):
        """Test that Xovris can reach an app (POST /v1/extensions/apps/{appId}/test)"""
        return self._call("POST", f"/v1/extensions/apps/{_q(app_id)}/test", body=body, idempotency_key=idempotency_key)

    def post_extensions_by_component_id_settings(self, component_id, body=None, idempotency_key=None):
        """Save an app's settings page (POST /v1/extensions/{componentId}/settings)"""
        return self._call("POST", f"/v1/extensions/{_q(component_id)}/settings", body=body, idempotency_key=idempotency_key)

    def post_extensions_by_component_id_submit(self, component_id, body=None, idempotency_key=None):
        """Answer an app's alert action (POST /v1/extensions/{componentId}/submit)"""
        return self._call("POST", f"/v1/extensions/{_q(component_id)}/submit", body=body, idempotency_key=idempotency_key)

    def post_failover_targets(self, body=None, idempotency_key=None):
        """Name a standby target for failover (POST /v1/failover-targets)"""
        return self._call("POST", f"/v1/failover-targets", body=body, idempotency_key=idempotency_key)

    def post_footprint(self, body=None, idempotency_key=None):
        """Read what a domain runs on and every host its certificates name (POST /v1/footprint)"""
        return self._call("POST", f"/v1/footprint", body=body, idempotency_key=idempotency_key)

    def post_forecasts_renewal_caa(self, body=None, idempotency_key=None):
        """See whether a certificate renewal will be refused by your CAA records (POST /v1/forecasts/renewal-caa)"""
        return self._call("POST", f"/v1/forecasts/renewal-caa", body=body, idempotency_key=idempotency_key)

    def post_free_expiry(self, body=None, idempotency_key=None):
        """Watch a domain or certificate for its expiry, free (POST /v1/free/expiry)"""
        return self._call("POST", f"/v1/free/expiry", body=body, idempotency_key=idempotency_key)

    def post_free_expiry_run(self, body=None, idempotency_key=None):
        """Check every confirmed free expiry watch (POST /v1/free/expiry/run)"""
        return self._call("POST", f"/v1/free/expiry/run", body=body, idempotency_key=idempotency_key)

    def post_goals_standing(self, body=None, idempotency_key=None):
        """State a standing goal in your own words - Xovris sets up what wakes it and holds it until it is met (POST /v1/goals/standing)"""
        return self._call("POST", f"/v1/goals/standing", body=body, idempotency_key=idempotency_key)

    def post_goals_standing_by_id_fire(self, id_, body=None, idempotency_key=None):
        """Fire a standing goal now - an API call is one of its triggers (POST /v1/goals/standing/{id}/fire)"""
        return self._call("POST", f"/v1/goals/standing/{_q(id_)}/fire", body=body, idempotency_key=idempotency_key)

    def post_goals_standing_by_id_retire(self, id_, body=None, idempotency_key=None):
        """Stop holding a standing goal (POST /v1/goals/standing/{id}/retire)"""
        return self._call("POST", f"/v1/goals/standing/{_q(id_)}/retire", body=body, idempotency_key=idempotency_key)

    def post_grants(self, body=None, idempotency_key=None):
        """Give Xovris a standing permission to act for you, within the limits you set (POST /v1/grants)"""
        return self._call("POST", f"/v1/grants", body=body, idempotency_key=idempotency_key)

    def post_helper_handoff_claim(self, body=None, idempotency_key=None):
        """Bring a conversation from the website into this workspace (POST /v1/helper/handoff/claim)"""
        return self._call("POST", f"/v1/helper/handoff/claim", body=body, idempotency_key=idempotency_key)

    def post_history_compare(self, body=None, idempotency_key=None):
        """See how a system looked at another moment beside how it looks now (POST /v1/history/compare)"""
        return self._call("POST", f"/v1/history/compare", body=body, idempotency_key=idempotency_key)

    def post_home_network_known(self, body=None, idempotency_key=None):
        """Mark a device on your home network as yours (POST /v1/home-network/known)"""
        return self._call("POST", f"/v1/home-network/known", body=body, idempotency_key=idempotency_key)

    def post_hooks_alerts_by_tenant_by_connection(self, tenant, connection, body=None, idempotency_key=None):
        """Send alerts from another tool (POST /v1/hooks/alerts/{tenant}/{connection})"""
        return self._call("POST", f"/v1/hooks/alerts/{_q(tenant)}/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_hooks_email(self, body=None, idempotency_key=None):
        """Receive email sent to Xovris (POST /v1/hooks/email)"""
        return self._call("POST", f"/v1/hooks/email", body=body, idempotency_key=idempotency_key)

    def post_hooks_sources_by_tenant_by_connection(self, tenant, connection, body=None, idempotency_key=None):
        """Send events from a connected source (POST /v1/hooks/sources/{tenant}/{connection})"""
        return self._call("POST", f"/v1/hooks/sources/{_q(tenant)}/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_hooks_sources_by_tenant_by_connection_enroll(self, tenant, connection, body=None, idempotency_key=None):
        """Enrol a connected source (POST /v1/hooks/sources/{tenant}/{connection}/enroll)"""
        return self._call("POST", f"/v1/hooks/sources/{_q(tenant)}/{_q(connection)}/enroll", body=body, idempotency_key=idempotency_key)

    def post_hooks_sources_by_tenant_by_connection_log(self, tenant, connection, body=None, idempotency_key=None):
        """Send log lines from a connected source (POST /v1/hooks/sources/{tenant}/{connection}/log)"""
        return self._call("POST", f"/v1/hooks/sources/{_q(tenant)}/{_q(connection)}/log", body=body, idempotency_key=idempotency_key)

    def post_hooks_tools_by_tenant_by_connection(self, tenant, connection, body=None, idempotency_key=None):
        """Send events from a connected tool (POST /v1/hooks/tools/{tenant}/{connection})"""
        return self._call("POST", f"/v1/hooks/tools/{_q(tenant)}/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_hooks_watch_by_token(self, token, body=None, idempotency_key=None):
        """Report to a watch (POST /v1/hooks/watch/{token})"""
        return self._call("POST", f"/v1/hooks/watch/{_q(token)}", body=body, idempotency_key=idempotency_key)

    def post_household_devices_by_id_off(self, id_, body=None, idempotency_key=None):
        """Switch off one household device's protected address (POST /v1/household/devices/{id}/off)"""
        return self._call("POST", f"/v1/household/devices/{_q(id_)}/off", body=body, idempotency_key=idempotency_key)

    def post_household_members(self, body=None, idempotency_key=None):
        """Add a member to your household's protection (POST /v1/household/members)"""
        return self._call("POST", f"/v1/household/members", body=body, idempotency_key=idempotency_key)

    def post_household_members_by_id_devices(self, id_, body=None, idempotency_key=None):
        """Give a member's device its own protected address (POST /v1/household/members/{id}/devices)"""
        return self._call("POST", f"/v1/household/members/{_q(id_)}/devices", body=body, idempotency_key=idempotency_key)

    def post_household_members_by_id_remove(self, id_, body=None, idempotency_key=None):
        """Remove a household member (one press brings them back) (POST /v1/household/members/{id}/remove)"""
        return self._call("POST", f"/v1/household/members/{_q(id_)}/remove", body=body, idempotency_key=idempotency_key)

    def post_household_members_by_id_restore(self, id_, body=None, idempotency_key=None):
        """Bring back a removed household member (POST /v1/household/members/{id}/restore)"""
        return self._call("POST", f"/v1/household/members/{_q(id_)}/restore", body=body, idempotency_key=idempotency_key)

    def post_identity_connections(self, body=None, idempotency_key=None):
        """Connect a sign-in directory (POST /v1/identity/connections)"""
        return self._call("POST", f"/v1/identity/connections", body=body, idempotency_key=idempotency_key)

    def post_identity_connections_by_id_backup_by_policy_activate(self, id_, policy, body=None, idempotency_key=None):
        """Turn on a backup policy (POST /v1/identity/connections/{id}/backup/{policy}/activate)"""
        return self._call("POST", f"/v1/identity/connections/{_q(id_)}/backup/{_q(policy)}/activate", body=body, idempotency_key=idempotency_key)

    def post_identity_connections_by_id_devices_by_device_approve(self, id_, device, body=None, idempotency_key=None):
        """Approve a phone or tablet waiting in Google Workspace, read back once it can reach the company's mail (POST /v1/identity/connections/{id}/devices/{device}/approve)"""
        return self._call("POST", f"/v1/identity/connections/{_q(id_)}/devices/{_q(device)}/approve", body=body, idempotency_key=idempotency_key)

    def post_identity_connections_by_id_devices_by_device_sync(self, id_, device, body=None, idempotency_key=None):
        """Sync a device from a directory (POST /v1/identity/connections/{id}/devices/{device}/sync)"""
        return self._call("POST", f"/v1/identity/connections/{_q(id_)}/devices/{_q(device)}/sync", body=body, idempotency_key=idempotency_key)

    def post_identity_connections_by_id_remove(self, id_, body=None, idempotency_key=None):
        """Remove a directory connection (POST /v1/identity/connections/{id}/remove)"""
        return self._call("POST", f"/v1/identity/connections/{_q(id_)}/remove", body=body, idempotency_key=idempotency_key)

    def post_identity_doors_by_kind_start(self, kind, body=None, idempotency_key=None):
        """Start connecting an identity system on its own approval page (send wants to narrow the grant) (POST /v1/identity/doors/{kind}/start)"""
        return self._call("POST", f"/v1/identity/doors/{_q(kind)}/start", body=body, idempotency_key=idempotency_key)

    def post_identity_leavers(self, body=None, idempotency_key=None):
        """Start a leaver's offboarding (POST /v1/identity/leavers)"""
        return self._call("POST", f"/v1/identity/leavers", body=body, idempotency_key=idempotency_key)

    def post_identity_refresh(self, body=None, idempotency_key=None):
        """Read the directories again now (POST /v1/identity/refresh)"""
        return self._call("POST", f"/v1/identity/refresh", body=body, idempotency_key=idempotency_key)

    def post_identity_runs_by_id_first_password(self, id_, body=None, idempotency_key=None):
        """Hand over a starter's first password (POST /v1/identity/runs/{id}/first-password)"""
        return self._call("POST", f"/v1/identity/runs/{_q(id_)}/first-password", body=body, idempotency_key=idempotency_key)

    def post_identity_runs_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a starter or leaver run (POST /v1/identity/runs/{id}/resume)"""
        return self._call("POST", f"/v1/identity/runs/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_identity_sign_everyone_out(self, body=None, idempotency_key=None):
        """Sign every person in your workspace out at once (POST /v1/identity/sign-everyone-out)"""
        return self._call("POST", f"/v1/identity/sign-everyone-out", body=body, idempotency_key=idempotency_key)

    def post_identity_starters(self, body=None, idempotency_key=None):
        """Start a starter's onboarding (POST /v1/identity/starters)"""
        return self._call("POST", f"/v1/identity/starters", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_ack(self, id_, body=None, idempotency_key=None):
        """Acknowledge an incident from wherever its alert reached you (the place is written to its record) (POST /v1/incidents/{id}/ack)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/ack", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_audiences_by_audience_reviewed(self, id_, audience, body=None, idempotency_key=None):
        """Mark Xovris's draft for one reader as read by a person (POST /v1/incidents/{id}/audiences/{audience}/reviewed)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/audiences/{_q(audience)}/reviewed", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_audiences_write(self, id_, body=None, idempotency_key=None):
        """Have Xovris's AI write the incident for each reader from its record (paid plans), each draft marked as written by Xovris (POST /v1/incidents/{id}/audiences/write)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/audiences/write", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_choice(self, id_, body=None, idempotency_key=None):
        """Choose what happens next on an incident (POST /v1/incidents/{id}/choice)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/choice", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_grouping_by_proposal_reject(self, id_, proposal, body=None, idempotency_key=None):
        """Keeps two incidents apart - Xovris's proposal to join them is declined, recorded, and never offered again for the pair (POST /v1/incidents/{id}/grouping/{proposal}/reject)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/grouping/{_q(proposal)}/reject", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_here(self, id_, body=None, idempotency_key=None):
        """Say you are on an incident's page, so others working it can see you (POST /v1/incidents/{id}/here)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/here", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_major(self, id_, body=None, idempotency_key=None):
        """Declare an incident major in one press, kept once on its own timeline (POST /v1/incidents/{id}/major)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/major", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_merge(self, id_, body=None, idempotency_key=None):
        """Merge an incident into the one it duplicates, keeping both records; sent with a proposal, Xovris's suggestion to join them is accepted and recorded (POST /v1/incidents/{id}/merge)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/merge", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_mute(self, id_, body=None, idempotency_key=None):
        """Hold an incident's messages for a time (POST /v1/incidents/{id}/mute)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/mute", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_notes(self, id_, body=None, idempotency_key=None):
        """Add a note to an incident (a paused investigation wakes on it) (POST /v1/incidents/{id}/notes)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/notes", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_pin(self, id_, body=None, idempotency_key=None):
        """Pin the incident you are working on, so your own coding agent reads it first (POST /v1/incidents/{id}/pin)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/pin", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_record_check(self, id_, body=None, idempotency_key=None):
        """Check a recording Xovris exported: whether it is the file Xovris made, and whether each outcome it claims still stands (POST /v1/incidents/{id}/record/check)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/record/check", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_repairs(self, id_, body=None, idempotency_key=None):
        """Ask Xovris to fix an incident (POST /v1/incidents/{id}/repairs)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/repairs", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_severity(self, id_, body=None, idempotency_key=None):
        """Change an incident's severity in one press, saying why, the rating Xovris first stated kept on its record (POST /v1/incidents/{id}/severity)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/severity", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_share(self, id_, body=None, idempotency_key=None):
        """Share an incident's story by link (POST /v1/incidents/{id}/share)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/share", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_share_by_ref_revoke(self, id_, ref, body=None, idempotency_key=None):
        """Revoke a shared link (POST /v1/incidents/{id}/share/{ref}/revoke)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/share/{_q(ref)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_snooze(self, id_, body=None, idempotency_key=None):
        """Snooze an incident until a time, until it gets worse or until something new happens (POST /v1/incidents/{id}/snooze)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/snooze", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_stakeholders(self, id_, body=None, idempotency_key=None):
        """Tell someone about an incident - yourself, a person outside the workspace or a connected channel - at the cadence they choose (POST /v1/incidents/{id}/stakeholders)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/stakeholders", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_stakeholders_tell(self, id_, body=None, idempotency_key=None):
        """Send an update about a major incident now, to everyone who hears every update (POST /v1/incidents/{id}/stakeholders/tell)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/stakeholders/tell", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_top_up(self, id_, body=None, idempotency_key=None):
        """Add credit so the work on one incident carries on past your plan's edge, the cost shown first (POST /v1/incidents/{id}/top-up)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/top-up", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_waiting_steps_approve(self, id_, body=None, idempotency_key=None):
        """Say yes to the steps with no undo waiting on an incident: checked again as a whole, then sent in order, each read back, the first that does not verify stopping the rest (POST /v1/incidents/{id}/waiting-steps/approve)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/waiting-steps/approve", body=body, idempotency_key=idempotency_key)

    def post_incidents_by_id_watch(self, id_, body=None, idempotency_key=None):
        """Watch an incident (POST /v1/incidents/{id}/watch)"""
        return self._call("POST", f"/v1/incidents/{_q(id_)}/watch", body=body, idempotency_key=idempotency_key)

    def post_incident_scopes(self, body=None, idempotency_key=None):
        """Count a window chosen on an incident’s record for its kind (POST /v1/incident-scopes)"""
        return self._call("POST", f"/v1/incident-scopes", body=body, idempotency_key=idempotency_key)

    def post_incidents_replay(self, body=None, idempotency_key=None):
        """Replay an incident moment by moment: every system's state, the first sign, and the minutes to detect, mitigate and verify (POST /v1/incidents/replay)"""
        return self._call("POST", f"/v1/incidents/replay", body=body, idempotency_key=idempotency_key)

    def post_ingestion_keys_end(self, body=None, idempotency_key=None):
        """End a project's ingestion keys, or list the projects that have live ones (POST /v1/ingestion-keys/end)"""
        return self._call("POST", f"/v1/ingestion-keys/end", body=body, idempotency_key=idempotency_key)

    def post_insider_detail(self, body=None, idempotency_key=None):
        """Open one person's detail inside an open security incident, with your reason kept (POST /v1/insider/detail)"""
        return self._call("POST", f"/v1/insider/detail", body=body, idempotency_key=idempotency_key)

    def post_insider_reading(self, body=None, idempotency_key=None):
        """See signs of company data leaving or access being misused, each against the person's own usual (POST /v1/insider/reading)"""
        return self._call("POST", f"/v1/insider/reading", body=body, idempotency_key=idempotency_key)

    def post_install_runs(self, body=None, idempotency_key=None):
        """Record an install run (POST /v1/install-runs)"""
        return self._call("POST", f"/v1/install-runs", body=body, idempotency_key=idempotency_key)

    def post_install_runs_by_run_id_stage(self, run_id, body=None, idempotency_key=None):
        """Record an install run's stage (POST /v1/install-runs/{runId}/stage)"""
        return self._call("POST", f"/v1/install-runs/{_q(run_id)}/stage", body=body, idempotency_key=idempotency_key)

    def post_install_runs_by_run_id_stops(self, run_id, body=None, idempotency_key=None):
        """Read an installer stop no named rule knows (POST /v1/install-runs/{runId}/stops)"""
        return self._call("POST", f"/v1/install-runs/{_q(run_id)}/stops", body=body, idempotency_key=idempotency_key)

    def post_integrations_chat_any_by_tenant_by_connection_by_secret(self, tenant, connection, secret, body=None, idempotency_key=None):
        """Receive what a person asks Xovris from any chat's outgoing webhook - their words read from the delivery itself (POST /v1/integrations/chat/any/{tenant}/{connection}/{secret})"""
        return self._call("POST", f"/v1/integrations/chat/any/{_q(tenant)}/{_q(connection)}/{_q(secret)}", body=body, idempotency_key=idempotency_key)

    def post_integrations_chat_discord_by_connection(self, connection, body=None, idempotency_key=None):
        """Receive what a person asks Xovris in your Discord, checked by Discord's own signature first (POST /v1/integrations/chat/discord/{connection})"""
        return self._call("POST", f"/v1/integrations/chat/discord/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_integrations_chat_google_chat_by_connection(self, connection, body=None, idempotency_key=None):
        """Receive what a person asks Xovris in your Google Chat, checked by Google's own token first (POST /v1/integrations/chat/google-chat/{connection})"""
        return self._call("POST", f"/v1/integrations/chat/google-chat/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_integrations_github_webhook(self, body=None, idempotency_key=None):
        """GitHub's deliveries to the Xovris GitHub App (POST /v1/integrations/github/webhook)"""
        return self._call("POST", f"/v1/integrations/github/webhook", body=body, idempotency_key=idempotency_key)

    def post_integrations_review_azure_devops_by_connection(self, connection, body=None, idempotency_key=None):
        """Receive Azure DevOps's pull request events for a connected repository, so the change is reviewed (POST /v1/integrations/review/azure-devops/{connection})"""
        return self._call("POST", f"/v1/integrations/review/azure-devops/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_integrations_review_bitbucket_cloud_by_connection(self, connection, body=None, idempotency_key=None):
        """Receive Bitbucket Cloud's pull request events for a connected repository, so the change is reviewed (POST /v1/integrations/review/bitbucket-cloud/{connection})"""
        return self._call("POST", f"/v1/integrations/review/bitbucket-cloud/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_integrations_review_bitbucket_dc_by_connection(self, connection, body=None, idempotency_key=None):
        """Receive Bitbucket Data Center's pull request events for a connected repository, so the change is reviewed (POST /v1/integrations/review/bitbucket-dc/{connection})"""
        return self._call("POST", f"/v1/integrations/review/bitbucket-dc/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_integrations_review_gitlab_by_connection(self, connection, body=None, idempotency_key=None):
        """Receive GitLab's merge request events for a connected project, so the change is reviewed (POST /v1/integrations/review/gitlab/{connection})"""
        return self._call("POST", f"/v1/integrations/review/gitlab/{_q(connection)}", body=body, idempotency_key=idempotency_key)

    def post_invitations_accept(self, body=None, idempotency_key=None):
        """Accept an invitation as the address it was sent to and join the workspace in its role (POST /v1/invitations/accept)"""
        return self._call("POST", f"/v1/invitations/accept", body=body, idempotency_key=idempotency_key)

    def post_invitations_decline(self, body=None, idempotency_key=None):
        """Decline an invitation from its own link, so it is no longer open (POST /v1/invitations/decline)"""
        return self._call("POST", f"/v1/invitations/decline", body=body, idempotency_key=idempotency_key)

    def post_invitations_read(self, body=None, idempotency_key=None):
        """See an invitation from its own link before signing in: the workspace, who invited you, every permission the role holds and when access ends (POST /v1/invitations/read)"""
        return self._call("POST", f"/v1/invitations/read", body=body, idempotency_key=idempotency_key)

    def post_issues(self, body=None, idempotency_key=None):
        """A new issue, opened by hand: what is wrong, where, what was seen, how urgent and who has it (POST /v1/issues)"""
        return self._call("POST", f"/v1/issues", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_ask(self, id_, body=None, idempotency_key=None):
        """Ask whoever opened an issue for more, and keep it out of the queue until they answer (POST /v1/issues/{id}/ask)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/ask", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_comments(self, id_, body=None, idempotency_key=None):
        """A comment on an issue (POST /v1/issues/{id}/comments)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/comments", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_fields(self, id_, body=None, idempotency_key=None):
        """Change an issue's fields, each change kept on its history (POST /v1/issues/{id}/fields)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/fields", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_follow(self, id_, body=None, idempotency_key=None):
        """Follow an issue to be told about every change to it, or stop following it (POST /v1/issues/{id}/follow)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/follow", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_relations(self, id_, body=None, idempotency_key=None):
        """Link an issue to another: blocks, blocked by, related or duplicate of (POST /v1/issues/{id}/relations)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/relations", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_seen(self, id_, body=None, idempotency_key=None):
        """Record that you opened an issue (POST /v1/issues/{id}/seen)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/seen", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_status(self, id_, body=None, idempotency_key=None):
        """Resolve, ignore or reopen an error (POST /v1/issues/{id}/status)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/status", body=body, idempotency_key=idempotency_key)

    def post_issues_by_id_triage(self, id_, body=None, idempotency_key=None):
        """Set who an error is with and how urgent it is (POST /v1/issues/{id}/triage)"""
        return self._call("POST", f"/v1/issues/{_q(id_)}/triage", body=body, idempotency_key=idempotency_key)

    def post_laws(self, body=None, idempotency_key=None):
        """See the laws that apply to your business and what each asks of you (POST /v1/laws)"""
        return self._call("POST", f"/v1/laws", body=body, idempotency_key=idempotency_key)

    def post_live_fresh(self, body=None, idempotency_key=None):
        """Send how fresh the live updates read on your screen (POST /v1/live/fresh)"""
        return self._call("POST", f"/v1/live/fresh", body=body, idempotency_key=idempotency_key)

    def post_log_archive_destinations(self, body=None, idempotency_key=None):
        """Add a log archive destination (POST /v1/log-archive/destinations)"""
        return self._call("POST", f"/v1/log-archive/destinations", body=body, idempotency_key=idempotency_key)

    def post_log_archive_destinations_by_id_lifecycle(self, id_, body=None, idempotency_key=None):
        """Have Xovris set how long archived logs are kept (POST /v1/log-archive/destinations/{id}/lifecycle)"""
        return self._call("POST", f"/v1/log-archive/destinations/{_q(id_)}/lifecycle", body=body, idempotency_key=idempotency_key)

    def post_log_archive_destinations_by_id_lifecycle_undo(self, id_, body=None, idempotency_key=None):
        """Put an archive's keeping rules back as they were (POST /v1/log-archive/destinations/{id}/lifecycle/undo)"""
        return self._call("POST", f"/v1/log-archive/destinations/{_q(id_)}/lifecycle/undo", body=body, idempotency_key=idempotency_key)

    def post_log_connections(self, body=None, idempotency_key=None):
        """Connect a log source (POST /v1/log-connections)"""
        return self._call("POST", f"/v1/log-connections", body=body, idempotency_key=idempotency_key)

    def post_log_connections_by_id_doors_by_door(self, id_, door, body=None, idempotency_key=None):
        """Have Xovris set up a log source through its door (POST /v1/log-connections/{id}/doors/{door})"""
        return self._call("POST", f"/v1/log-connections/{_q(id_)}/doors/{_q(door)}", body=body, idempotency_key=idempotency_key)

    def post_log_connections_by_id_doors_by_door_undo(self, id_, door, body=None, idempotency_key=None):
        """Undo a log source Xovris set up (POST /v1/log-connections/{id}/doors/{door}/undo)"""
        return self._call("POST", f"/v1/log-connections/{_q(id_)}/doors/{_q(door)}/undo", body=body, idempotency_key=idempotency_key)

    def post_log_connections_by_id_pause(self, id_, body=None, idempotency_key=None):
        """Pause a log connection (POST /v1/log-connections/{id}/pause)"""
        return self._call("POST", f"/v1/log-connections/{_q(id_)}/pause", body=body, idempotency_key=idempotency_key)

    def post_log_connections_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a log connection (POST /v1/log-connections/{id}/resume)"""
        return self._call("POST", f"/v1/log-connections/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_log_connections_by_id_rewire(self, id_, body=None, idempotency_key=None):
        """Have Xovris put a fresh endpoint and secret into a log source's sender (POST /v1/log-connections/{id}/rewire)"""
        return self._call("POST", f"/v1/log-connections/{_q(id_)}/rewire", body=body, idempotency_key=idempotency_key)

    def post_logs_explain(self, body=None, idempotency_key=None):
        """Explain an error or log line (POST /v1/logs/explain)"""
        return self._call("POST", f"/v1/logs/explain", body=body, idempotency_key=idempotency_key)

    def post_logs_explain_door(self, body=None, idempotency_key=None):
        """Do an explained step on the computer that saw the error (POST /v1/logs/explain/door)"""
        return self._call("POST", f"/v1/logs/explain/door", body=body, idempotency_key=idempotency_key)

    def post_mail_authenticate(self, body=None, idempotency_key=None):
        """Have Xovris write the next mail authentication record (POST /v1/mail/authenticate)"""
        return self._call("POST", f"/v1/mail/authenticate", body=body, idempotency_key=idempotency_key)

    def post_mail_keys(self, body=None, idempotency_key=None):
        """Hand over a DKIM record from a mail service Xovris has no door into yet, and see the change it allows (POST /v1/mail/keys)"""
        return self._call("POST", f"/v1/mail/keys", body=body, idempotency_key=idempotency_key)

    def post_mail_plan(self, body=None, idempotency_key=None):
        """Plan your mail authentication (POST /v1/mail/plan)"""
        return self._call("POST", f"/v1/mail/plan", body=body, idempotency_key=idempotency_key)

    def post_mail_repair(self, body=None, idempotency_key=None):
        """See the exact change for one finding, or have Xovris write it (POST /v1/mail/repair)"""
        return self._call("POST", f"/v1/mail/repair", body=body, idempotency_key=idempotency_key)

    def post_make(self, body=None, idempotency_key=None):
        """Ask Xovris to make whatever you describe, by the maker that fits it – the job starts at once and answers with its record (POST /v1/make)"""
        return self._call("POST", f"/v1/make", body=body, idempotency_key=idempotency_key)

    def post_mcp(self, body=None, idempotency_key=None):
        """Connect an AI coding agent to Xovris over MCP and call its tools (POST /v1/mcp)"""
        return self._call("POST", f"/v1/mcp", body=body, idempotency_key=idempotency_key)

    def post_me_learned_forget(self, body=None, idempotency_key=None):
        """Erase what Xovris learned about you - or, as an owner, what it learned across the workspace (POST /v1/me/learned/forget)"""
        return self._call("POST", f"/v1/me/learned/forget", body=body, idempotency_key=idempotency_key)

    def post_members_invitations(self, body=None, idempotency_key=None):
        """Invite a person by their email address with a role - the email leaves at once, and asking again for the same address sends it again with a new link (POST /v1/members/invitations)"""
        return self._call("POST", f"/v1/members/invitations", body=body, idempotency_key=idempotency_key)

    def post_models_own(self, body=None, idempotency_key=None):
        """Add or replace your own model - Xovris proves it answers before keeping it, and seals its key (POST /v1/models/own)"""
        return self._call("POST", f"/v1/models/own", body=body, idempotency_key=idempotency_key)

    def post_msp_grants(self, body=None, idempotency_key=None):
        """Grant your MSP access (POST /v1/msp/grants)"""
        return self._call("POST", f"/v1/msp/grants", body=body, idempotency_key=idempotency_key)

    def post_msp_grants_by_id_revoke(self, id_, body=None, idempotency_key=None):
        """Withdraw an MSP's access (POST /v1/msp/grants/{id}/revoke)"""
        return self._call("POST", f"/v1/msp/grants/{_q(id_)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_network_defence_events(self, body=None, idempotency_key=None):
        """Send your network sensor's events so Xovris can group them into incidents (POST /v1/network-defence/events)"""
        return self._call("POST", f"/v1/network-defence/events", body=body, idempotency_key=idempotency_key)

    def post_network_defence_firewall_policy(self, body=None, idempotency_key=None):
        """Write one firewall policy: see it compiled for every make as a dry run, or put it on a machine with each rule proved (POST /v1/network-defence/firewall-policy)"""
        return self._call("POST", f"/v1/network-defence/firewall-policy", body=body, idempotency_key=idempotency_key)

    def post_network_defence_incidents_by_id_contain(self, id_, body=None, idempotency_key=None):
        """Contain the machine a network incident reached, keeping what it needs: read its plan from the machine, say yes to that plan, or lift it (POST /v1/network-defence/incidents/{id}/contain)"""
        return self._call("POST", f"/v1/network-defence/incidents/{_q(id_)}/contain", body=body, idempotency_key=idempotency_key)

    def post_network_defence_incidents_by_id_prevent(self, id_, body=None, idempotency_key=None):
        """Plan a block for a network incident as a dry run, with its expiry and undo (POST /v1/network-defence/incidents/{id}/prevent)"""
        return self._call("POST", f"/v1/network-defence/incidents/{_q(id_)}/prevent", body=body, idempotency_key=idempotency_key)

    def post_network_defence_indicators(self, body=None, idempotency_key=None):
        """Add threat indicators for Xovris to hunt for across your network memory (POST /v1/network-defence/indicators)"""
        return self._call("POST", f"/v1/network-defence/indicators", body=body, idempotency_key=idempotency_key)

    def post_network_defence_preventions_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a block Xovris put on one of your machines, read gone there (POST /v1/network-defence/preventions/{id}/undo)"""
        return self._call("POST", f"/v1/network-defence/preventions/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_network_defence_suppressions(self, body=None, idempotency_key=None):
        """Tell Xovris a kind of network event is expected, so it stops raising incidents for it (POST /v1/network-defence/suppressions)"""
        return self._call("POST", f"/v1/network-defence/suppressions", body=body, idempotency_key=idempotency_key)

    def post_network_defence_suppressions_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo an expected-traffic rule so its events raise incidents again (POST /v1/network-defence/suppressions/{id}/undo)"""
        return self._call("POST", f"/v1/network-defence/suppressions/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_network_devices_config(self, body=None, idempotency_key=None):
        """Change a network device's setting through its own model's door - backed up, rehearsed, read back and undoable (POST /v1/network/devices/config)"""
        return self._call("POST", f"/v1/network/devices/config", body=body, idempotency_key=idempotency_key)

    def post_network_devices_config_by_check_id_apply(self, check_id, body=None, idempotency_key=None):
        """Make the planned change to the device, against the very value the plan read (POST /v1/network/devices/config/{checkId}/apply)"""
        return self._call("POST", f"/v1/network/devices/config/{_q(check_id)}/apply", body=body, idempotency_key=idempotency_key)

    def post_network_devices_config_by_check_id_undo(self, check_id, body=None, idempotency_key=None):
        """Put the device's setting back from the backup Xovris took, and read it back (POST /v1/network/devices/config/{checkId}/undo)"""
        return self._call("POST", f"/v1/network/devices/config/{_q(check_id)}/undo", body=body, idempotency_key=idempotency_key)

    def post_network_devices_read(self, body=None, idempotency_key=None):
        """Read a switch, router or firewall you authorised by SNMP - its model, firmware, ports and settings (POST /v1/network/devices/read)"""
        return self._call("POST", f"/v1/network/devices/read", body=body, idempotency_key=idempotency_key)

    def post_network_firewall_policy(self, body=None, idempotency_key=None):
        """Put one firewall policy on a gateway's own firewall through its sign-in, each rule proved from the gateway and the way back kept (POST /v1/network/firewall-policy)"""
        return self._call("POST", f"/v1/network/firewall-policy", body=body, idempotency_key=idempotency_key)

    def post_network_review(self, body=None, idempotency_key=None):
        """Have Xovris review a network device's configuration against what its own model expects (POST /v1/network/review)"""
        return self._call("POST", f"/v1/network/review", body=body, idempotency_key=idempotency_key)

    def post_network_review_by_check_id_fix(self, check_id, body=None, idempotency_key=None):
        """Have Xovris put right what a network device's review found, read back with its way back kept (POST /v1/network/review/{checkId}/fix)"""
        return self._call("POST", f"/v1/network/review/{_q(check_id)}/fix", body=body, idempotency_key=idempotency_key)

    def post_network_sources_netbox(self, body=None, idempotency_key=None):
        """Have Xovris read your NetBox - its devices, ports, cables and ranges - through NetBox's own API (POST /v1/network/sources/netbox)"""
        return self._call("POST", f"/v1/network/sources/netbox", body=body, idempotency_key=idempotency_key)

    def post_network_sources_netbox_write(self, body=None, idempotency_key=None):
        """Have Xovris write what it found on your network back into your NetBox, each change read back (POST /v1/network/sources/netbox/write)"""
        return self._call("POST", f"/v1/network/sources/netbox/write", body=body, idempotency_key=idempotency_key)

    def post_network_troubleshoot(self, body=None, idempotency_key=None):
        """Have Xovris troubleshoot a network device from a computer on its network - the path, its ports and its configuration (POST /v1/network/troubleshoot)"""
        return self._call("POST", f"/v1/network/troubleshoot", body=body, idempotency_key=idempotency_key)

    def post_network_troubleshoot_by_check_id_again(self, check_id, body=None, idempotency_key=None):
        """Run a network troubleshoot again, from the same computer, and see what changed (POST /v1/network/troubleshoot/{checkId}/again)"""
        return self._call("POST", f"/v1/network/troubleshoot/{_q(check_id)}/again", body=body, idempotency_key=idempotency_key)

    def post_network_troubleshoot_by_check_id_fix(self, check_id, body=None, idempotency_key=None):
        """Have Xovris make the fix a network troubleshoot found, then read the device again to prove it (POST /v1/network/troubleshoot/{checkId}/fix)"""
        return self._call("POST", f"/v1/network/troubleshoot/{_q(check_id)}/fix", body=body, idempotency_key=idempotency_key)

    def post_oauth_apps(self, body=None, idempotency_key=None):
        """Publish an OAuth app (POST /v1/oauth/apps)"""
        return self._call("POST", f"/v1/oauth/apps", body=body, idempotency_key=idempotency_key)

    def post_oauth_apps_by_id_secret(self, id_, body=None, idempotency_key=None):
        """Make a new client secret for an OAuth app (POST /v1/oauth/apps/{id}/secret)"""
        return self._call("POST", f"/v1/oauth/apps/{_q(id_)}/secret", body=body, idempotency_key=idempotency_key)

    def post_oauth_authorize(self, body=None, idempotency_key=None):
        """Allow or decline an app (POST /v1/oauth/authorize)"""
        return self._call("POST", f"/v1/oauth/authorize", body=body, idempotency_key=idempotency_key)

    def post_oauth_device_authorization(self, body=None, idempotency_key=None):
        """Start a sign-in on a device with no browser (POST /v1/oauth/device_authorization)"""
        return self._call("POST", f"/v1/oauth/device_authorization", body=body, idempotency_key=idempotency_key)

    def post_oauth_device_by_code_approve(self, code, body=None, idempotency_key=None):
        """Approve a device's sign-in (POST /v1/oauth/device/{code}/approve)"""
        return self._call("POST", f"/v1/oauth/device/{_q(code)}/approve", body=body, idempotency_key=idempotency_key)

    def post_oauth_device_by_code_deny(self, code, body=None, idempotency_key=None):
        """Decline a device's sign-in (POST /v1/oauth/device/{code}/deny)"""
        return self._call("POST", f"/v1/oauth/device/{_q(code)}/deny", body=body, idempotency_key=idempotency_key)

    def post_oauth_grants_by_id_revoke(self, id_, body=None, idempotency_key=None):
        """Unlink an app (POST /v1/oauth/grants/{id}/revoke)"""
        return self._call("POST", f"/v1/oauth/grants/{_q(id_)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_oauth_register(self, body=None, idempotency_key=None):
        """Register an app or an AI client that signs in with Xovris (POST /v1/oauth/register)"""
        return self._call("POST", f"/v1/oauth/register", body=body, idempotency_key=idempotency_key)

    def post_oauth_revoke(self, body=None, idempotency_key=None):
        """Revoke an OAuth token (POST /v1/oauth/revoke)"""
        return self._call("POST", f"/v1/oauth/revoke", body=body, idempotency_key=idempotency_key)

    def post_oauth_token(self, body=None, idempotency_key=None):
        """Exchange a code, a refresh token, a device code or a client secret for an access token (POST /v1/oauth/token)"""
        return self._call("POST", f"/v1/oauth/token", body=body, idempotency_key=idempotency_key)

    def post_oncall_assign(self, body=None, idempotency_key=None):
        """Hand an alert to the right person on call (POST /v1/oncall/assign)"""
        return self._call("POST", f"/v1/oncall/assign", body=body, idempotency_key=idempotency_key)

    def post_oncall_away(self, body=None, idempotency_key=None):
        """Bring in who is away, so nobody is paged on leave (POST /v1/oncall/away)"""
        return self._call("POST", f"/v1/oncall/away", body=body, idempotency_key=idempotency_key)

    def post_oncall_codeowners(self, body=None, idempotency_key=None):
        """Route alerts by a repository's code owners (POST /v1/oncall/codeowners)"""
        return self._call("POST", f"/v1/oncall/codeowners", body=body, idempotency_key=idempotency_key)

    def post_oncall_cover(self, body=None, idempotency_key=None):
        """Ask for someone to cover your on-call time (POST /v1/oncall/cover)"""
        return self._call("POST", f"/v1/oncall/cover", body=body, idempotency_key=idempotency_key)

    def post_oncall_cover_by_id_answer(self, id_, body=None, idempotency_key=None):
        """Answer a request to cover on-call time (POST /v1/oncall/cover/{id}/answer)"""
        return self._call("POST", f"/v1/oncall/cover/{_q(id_)}/answer", body=body, idempotency_key=idempotency_key)

    def post_oncall_drills(self, body=None, idempotency_key=None):
        """Rehearse an escalation policy with a drill that pages its people, hop by hop (POST /v1/oncall/drills)"""
        return self._call("POST", f"/v1/oncall/drills", body=body, idempotency_key=idempotency_key)

    def post_oncall_escalations(self, body=None, idempotency_key=None):
        """Save an escalation policy (POST /v1/oncall/escalations)"""
        return self._call("POST", f"/v1/oncall/escalations", body=body, idempotency_key=idempotency_key)

    def post_oncall_import_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo an on-call import (POST /v1/oncall/import/{id}/undo)"""
        return self._call("POST", f"/v1/oncall/import/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_oncall_import_opsgenie(self, body=None, idempotency_key=None):
        """Import your Opsgenie on-call set-up (POST /v1/oncall/import/opsgenie)"""
        return self._call("POST", f"/v1/oncall/import/opsgenie", body=body, idempotency_key=idempotency_key)

    def post_oncall_import_pagerduty(self, body=None, idempotency_key=None):
        """Read, set beside Xovris and import your PagerDuty on-call set-up - with the read-only access PagerDuty's approval grants, or a read-only key (POST /v1/oncall/import/pagerduty)"""
        return self._call("POST", f"/v1/oncall/import/pagerduty", body=body, idempotency_key=idempotency_key)

    def post_oncall_import_pagerduty_grant(self, body=None, idempotency_key=None):
        """Start reading PagerDuty for an on-call import: the link to PagerDuty's own page, where read-only access is approved once (POST /v1/oncall/import/pagerduty/grant)"""
        return self._call("POST", f"/v1/oncall/import/pagerduty/grant", body=body, idempotency_key=idempotency_key)

    def post_oncall_import_splunk_oncall(self, body=None, idempotency_key=None):
        """Read, review and import your Splunk On-Call on-call set-up with the organisation's API ID and key, used once and never kept (POST /v1/oncall/import/splunk-oncall)"""
        return self._call("POST", f"/v1/oncall/import/splunk-oncall", body=body, idempotency_key=idempotency_key)

    def post_oncall_members_by_member_id(self, member_id, body=None, idempotency_key=None):
        """Save an on-call member's country, hours, skills and teams (POST /v1/oncall/members/{memberId})"""
        return self._call("POST", f"/v1/oncall/members/{_q(member_id)}", body=body, idempotency_key=idempotency_key)

    def post_oncall_opsgenie_import(self, body=None, idempotency_key=None):
        """Import an Opsgenie export, matched to your members (POST /v1/oncall/opsgenie/import)"""
        return self._call("POST", f"/v1/oncall/opsgenie/import", body=body, idempotency_key=idempotency_key)

    def post_oncall_opsgenie_plan(self, body=None, idempotency_key=None):
        """See what an Opsgenie export would bring in before importing it (POST /v1/oncall/opsgenie/plan)"""
        return self._call("POST", f"/v1/oncall/opsgenie/plan", body=body, idempotency_key=idempotency_key)

    def post_oncall_schedules(self, body=None, idempotency_key=None):
        """Save an on-call schedule (POST /v1/oncall/schedules)"""
        return self._call("POST", f"/v1/oncall/schedules", body=body, idempotency_key=idempotency_key)

    def post_oncall_schedules_by_id_overrides(self, id_, body=None, idempotency_key=None):
        """Put someone else on call for a stretch of a schedule (POST /v1/oncall/schedules/{id}/overrides)"""
        return self._call("POST", f"/v1/oncall/schedules/{_q(id_)}/overrides", body=body, idempotency_key=idempotency_key)

    def post_oncall_schedules_by_id_shadows(self, id_, body=None, idempotency_key=None):
        """Let someone shadow a schedule to learn it (POST /v1/oncall/schedules/{id}/shadows)"""
        return self._call("POST", f"/v1/oncall/schedules/{_q(id_)}/shadows", body=body, idempotency_key=idempotency_key)

    def post_oncall_schedules_preview(self, body=None, idempotency_key=None):
        """See the rota a draft schedule would make over the next fortnight, before it is saved (POST /v1/oncall/schedules/preview)"""
        return self._call("POST", f"/v1/oncall/schedules/preview", body=body, idempotency_key=idempotency_key)

    def post_opamp(self, body=None, idempotency_key=None):
        """OpAMP for your collectors (POST /v1/opamp)"""
        return self._call("POST", f"/v1/opamp", body=body, idempotency_key=idempotency_key)

    def post_otlp_v1_logs(self, body=None, idempotency_key=None):
        """Send OpenTelemetry logs (POST /v1/otlp/v1/logs)"""
        return self._call("POST", f"/v1/otlp/v1/logs", body=body, idempotency_key=idempotency_key)

    def post_otlp_v1_metrics(self, body=None, idempotency_key=None):
        """Send OpenTelemetry metrics (POST /v1/otlp/v1/metrics)"""
        return self._call("POST", f"/v1/otlp/v1/metrics", body=body, idempotency_key=idempotency_key)

    def post_otlp_v1_traces(self, body=None, idempotency_key=None):
        """Send OpenTelemetry traces (POST /v1/otlp/v1/traces)"""
        return self._call("POST", f"/v1/otlp/v1/traces", body=body, idempotency_key=idempotency_key)

    def post_partners(self, body=None, idempotency_key=None):
        """Make a partner key for the embedded check (POST /v1/partners)"""
        return self._call("POST", f"/v1/partners", body=body, idempotency_key=idempotency_key)

    def post_partners_accounts(self, body=None, idempotency_key=None):
        """Provision an account for your customer, in one signed call (POST /v1/partners/accounts)"""
        return self._call("POST", f"/v1/partners/accounts", body=body, idempotency_key=idempotency_key)

    def post_partners_accounts_by_id_deprovision(self, id_, body=None, idempotency_key=None):
        """Remove an account you provisioned, its export made ready first (POST /v1/partners/accounts/{id}/deprovision)"""
        return self._call("POST", f"/v1/partners/accounts/{_q(id_)}/deprovision", body=body, idempotency_key=idempotency_key)

    def post_partners_accounts_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume an account you suspended (POST /v1/partners/accounts/{id}/resume)"""
        return self._call("POST", f"/v1/partners/accounts/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_partners_accounts_by_id_suspend(self, id_, body=None, idempotency_key=None):
        """Suspend an account you provisioned (POST /v1/partners/accounts/{id}/suspend)"""
        return self._call("POST", f"/v1/partners/accounts/{_q(id_)}/suspend", body=body, idempotency_key=idempotency_key)

    def post_partners_attribute(self, body=None, idempotency_key=None):
        """Credit the partner who sent you (POST /v1/partners/attribute)"""
        return self._call("POST", f"/v1/partners/attribute", body=body, idempotency_key=idempotency_key)

    def post_partners_by_id_revoke(self, id_, body=None, idempotency_key=None):
        """Revoke a partner key (POST /v1/partners/{id}/revoke)"""
        return self._call("POST", f"/v1/partners/{_q(id_)}/revoke", body=body, idempotency_key=idempotency_key)

    def post_partners_sandbox_keys(self, body=None, idempotency_key=None):
        """Make a provisioning sandbox key (POST /v1/partners/sandbox-keys)"""
        return self._call("POST", f"/v1/partners/sandbox-keys", body=body, idempotency_key=idempotency_key)

    def post_passwords_health(self, body=None, idempotency_key=None):
        """See the company's password health without any password being sent (POST /v1/passwords/health)"""
        return self._call("POST", f"/v1/passwords/health", body=body, idempotency_key=idempotency_key)

    def post_payments_connections(self, body=None, idempotency_key=None):
        """Connect any payment provider by its own API description (POST /v1/payments/connections)"""
        return self._call("POST", f"/v1/payments/connections", body=body, idempotency_key=idempotency_key)

    def post_payments_voice_check(self, body=None, idempotency_key=None):
        """Check a payment request for signs of a cloned voice before any money moves (POST /v1/payments/voice-check)"""
        return self._call("POST", f"/v1/payments/voice-check", body=body, idempotency_key=idempotency_key)

    def post_people_me_leave(self, body=None, idempotency_key=None):
        """The signed-in person leaves this workspace themselves - someone from outside only where its rule lets them, never the last owner (POST /v1/people/me/leave)"""
        return self._call("POST", f"/v1/people/me/leave", body=body, idempotency_key=idempotency_key)

    def post_phishing_practice(self, body=None, idempotency_key=None):
        """See what a phishing practice showed and who needs help next (POST /v1/phishing/practice)"""
        return self._call("POST", f"/v1/phishing/practice", body=body, idempotency_key=idempotency_key)

    def post_pipelines_derived(self, body=None, idempotency_key=None):
        """Make a metric from log lines (POST /v1/pipelines/derived)"""
        return self._call("POST", f"/v1/pipelines/derived", body=body, idempotency_key=idempotency_key)

    def post_pipelines_derived_by_id_monitors(self, id_, body=None, idempotency_key=None):
        """Watch a metric made from log lines (POST /v1/pipelines/derived/{id}/monitors)"""
        return self._call("POST", f"/v1/pipelines/derived/{_q(id_)}/monitors", body=body, idempotency_key=idempotency_key)

    def post_pipelines_destinations(self, body=None, idempotency_key=None):
        """Send logs on to another destination (POST /v1/pipelines/destinations)"""
        return self._call("POST", f"/v1/pipelines/destinations", body=body, idempotency_key=idempotency_key)

    def post_pipelines_rules(self, body=None, idempotency_key=None):
        """Add log pipeline rules in plain words (POST /v1/pipelines/rules)"""
        return self._call("POST", f"/v1/pipelines/rules", body=body, idempotency_key=idempotency_key)

    def post_pipelines_rules_preview(self, body=None, idempotency_key=None):
        """Preview log pipeline rules (POST /v1/pipelines/rules/preview)"""
        return self._call("POST", f"/v1/pipelines/rules/preview", body=body, idempotency_key=idempotency_key)

    def post_post_mortem(self, body=None, idempotency_key=None):
        """Draft a post-mortem of an incident from its timeline (POST /v1/post-mortem)"""
        return self._call("POST", f"/v1/post-mortem", body=body, idempotency_key=idempotency_key)

    def post_procedures_by_id_versions_by_version_approve(self, id_, version, body=None, idempotency_key=None):
        """Approve one exact version of a runbook so it may run (POST /v1/procedures/{id}/versions/{version}/approve)"""
        return self._call("POST", f"/v1/procedures/{_q(id_)}/versions/{_q(version)}/approve", body=body, idempotency_key=idempotency_key)

    def post_procedures_import(self, body=None, idempotency_key=None):
        """Import a runbook as a draft that waits for the owner's approval (POST /v1/procedures/import)"""
        return self._call("POST", f"/v1/procedures/import", body=body, idempotency_key=idempotency_key)

    def post_procedures_library_adopt(self, body=None, idempotency_key=None):
        """Adopt a procedure from your account's library as a candidate here (POST /v1/procedures/library/adopt)"""
        return self._call("POST", f"/v1/procedures/library/adopt", body=body, idempotency_key=idempotency_key)

    def post_profiles(self, body=None, idempotency_key=None):
        """Send a profile from a profiler, folded stacks or pprof, to keep for a service (POST /v1/profiles)"""
        return self._call("POST", f"/v1/profiles", body=body, idempotency_key=idempotency_key)

    def post_prometheus_write(self, body=None, idempotency_key=None):
        """Send your Prometheus's remote_write (POST /v1/prometheus/write)"""
        return self._call("POST", f"/v1/prometheus/write", body=body, idempotency_key=idempotency_key)

    def post_protocol_changes_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo one change Xovris made through a protocol door, read back from the system itself (POST /v1/protocol-changes/{id}/undo)"""
        return self._call("POST", f"/v1/protocol-changes/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_protocol_connections(self, body=None, idempotency_key=None):
        """Connect a broker, store, mailbox, calendar or directory from its address alone - its secret sealed, never shown again (POST /v1/protocol-connections)"""
        return self._call("POST", f"/v1/protocol-connections", body=body, idempotency_key=idempotency_key)

    def post_protocol_connections_by_id_change(self, id_, body=None, idempotency_key=None):
        """Change a connected system through its own protocol, with its undo kept and the result read back from the system (POST /v1/protocol-connections/{id}/change)"""
        return self._call("POST", f"/v1/protocol-connections/{_q(id_)}/change", body=body, idempotency_key=idempotency_key)

    def post_protocol_connections_by_id_read(self, id_, body=None, idempotency_key=None):
        """Read a connected system through its own protocol - messages, files, mail, events or directory entries (POST /v1/protocol-connections/{id}/read)"""
        return self._call("POST", f"/v1/protocol-connections/{_q(id_)}/read", body=body, idempotency_key=idempotency_key)

    def post_protocol_connections_by_id_reading(self, id_, body=None, idempotency_key=None):
        """Read what is wrong with a connected mailbox or system - every folder, every header of what it received, its rules and identities, judged from its own words (POST /v1/protocol-connections/{id}/reading)"""
        return self._call("POST", f"/v1/protocol-connections/{_q(id_)}/reading", body=body, idempotency_key=idempotency_key)

    def post_protocol_connections_key(self, body=None, idempotency_key=None):
        """Connect a service by its key alone - Xovris proves where the key goes on a harmless read, and a refused key leaves the vault (POST /v1/protocol-connections/key)"""
        return self._call("POST", f"/v1/protocol-connections/key", body=body, idempotency_key=idempotency_key)

    def post_public_build_host(self, body=None, idempotency_key=None):
        """Read a host's own prices page for its free allowance and first paid plan (POST /v1/public/build/host)"""
        return self._call("POST", f"/v1/public/build/host", body=body, idempotency_key=idempotency_key)

    def post_public_build_publish(self, body=None, idempotency_key=None):
        """Put a page made on /build live as a project of your own (POST /v1/public/build/publish)"""
        return self._call("POST", f"/v1/public/build/publish", body=body, idempotency_key=idempotency_key)

    def post_public_build_publish_by_id_live(self, id_, body=None, idempotency_key=None):
        """Put a built page live on Xovris's own hosting (POST /v1/public/build/publish/{id}/live)"""
        return self._call("POST", f"/v1/public/build/publish/{_q(id_)}/live", body=body, idempotency_key=idempotency_key)

    def post_public_check(self, body=None, idempotency_key=None):
        """Check a website for free (POST /v1/public/check)"""
        return self._call("POST", f"/v1/public/check", body=body, idempotency_key=idempotency_key)

    def post_public_demo_book(self, body=None, idempotency_key=None):
        """Book a demo with a person from Xovris (POST /v1/public/demo/book)"""
        return self._call("POST", f"/v1/public/demo/book", body=body, idempotency_key=idempotency_key)

    def post_public_demo_cancel(self, body=None, idempotency_key=None):
        """Cancel a demo you booked (POST /v1/public/demo/cancel)"""
        return self._call("POST", f"/v1/public/demo/cancel", body=body, idempotency_key=idempotency_key)

    def post_public_design_import(self, body=None, idempotency_key=None):
        """Bring a design into a build with no account - a picture, a Figma frame or a page (POST /v1/public/design/import)"""
        return self._call("POST", f"/v1/public/design/import", body=body, idempotency_key=idempotency_key)

    def post_public_documents(self, body=None, idempotency_key=None):
        """Make an answer into a file with no account - Word, Excel, PowerPoint or PDF (POST /v1/public/documents)"""
        return self._call("POST", f"/v1/public/documents", body=body, idempotency_key=idempotency_key)

    def post_public_explain(self, body=None, idempotency_key=None):
        """Explain an error for free (POST /v1/public/explain)"""
        return self._call("POST", f"/v1/public/explain", body=body, idempotency_key=idempotency_key)

    def post_public_files_read(self, body=None, idempotency_key=None):
        """Send a file for the site's Ask to read with no account, and ask about it (POST /v1/public/files/read)"""
        return self._call("POST", f"/v1/public/files/read", body=body, idempotency_key=idempotency_key)

    def post_public_fingerprint(self, body=None, idempotency_key=None):
        """Read a public website from outside and name the stack, host, DNS and mail provider it runs on (POST /v1/public/fingerprint)"""
        return self._call("POST", f"/v1/public/fingerprint", body=body, idempotency_key=idempotency_key)

    def post_public_handoff_by_token(self, token, body=None, idempotency_key=None):
        """Carry a waiting job on from its notice - the person who asked, or the approval chain at their turn (POST /v1/public/handoff/{token})"""
        return self._call("POST", f"/v1/public/handoff/{_q(token)}", body=body, idempotency_key=idempotency_key)

    def post_public_helper(self, body=None, idempotency_key=None):
        """Ask Xovris on the website (POST /v1/public/helper)"""
        return self._call("POST", f"/v1/public/helper", body=body, idempotency_key=idempotency_key)

    def post_public_helper_handoff(self, body=None, idempotency_key=None):
        """Carry your conversation with Xovris on the website into the account you are making, on your recorded consent (POST /v1/public/helper/handoff)"""
        return self._call("POST", f"/v1/public/helper/handoff", body=body, idempotency_key=idempotency_key)

    def post_public_hosts_identify(self, body=None, idempotency_key=None):
        """Ask who runs the outside scripts no list names yet - addresses only, never their query (POST /v1/public/hosts/identify)"""
        return self._call("POST", f"/v1/public/hosts/identify", body=body, idempotency_key=idempotency_key)

    def post_public_keys_revoke(self, body=None, idempotency_key=None):
        """End an ingestion key with the key itself, no sign-in needed (POST /v1/public/keys/revoke)"""
        return self._call("POST", f"/v1/public/keys/revoke", body=body, idempotency_key=idempotency_key)

    def post_public_live_previews(self, body=None, idempotency_key=None):
        """Share the page a build shows as a live link - it opens on any phone and follows every new version (POST /v1/public/live-previews)"""
        return self._call("POST", f"/v1/public/live-previews", body=body, idempotency_key=idempotency_key)

    def post_public_live_previews_by_id(self, id_, body=None, idempotency_key=None):
        """Send the next version of a shared page - every phone on its link shows it within a second (POST /v1/public/live-previews/{id})"""
        return self._call("POST", f"/v1/public/live-previews/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def post_public_live_previews_by_id_end(self, id_, body=None, idempotency_key=None):
        """End a shared page's link - the page is deleted at once (POST /v1/public/live-previews/{id}/end)"""
        return self._call("POST", f"/v1/public/live-previews/{_q(id_)}/end", body=body, idempotency_key=idempotency_key)

    def post_public_mail_check(self, body=None, idempotency_key=None):
        """An email check: an address of your own for a day, which reads the message you send to it (POST /v1/public/mail-check)"""
        return self._call("POST", f"/v1/public/mail-check", body=body, idempotency_key=idempotency_key)

    def post_public_mcp(self, body=None, idempotency_key=None):
        """Run the free website check from an MCP client (POST /v1/public/mcp)"""
        return self._call("POST", f"/v1/public/mcp", body=body, idempotency_key=idempotency_key)

    def post_public_router_exposure(self, body=None, idempotency_key=None):
        """Check which router doors are open to the internet on the address you are connecting from - never any other address (POST /v1/public/router-exposure)"""
        return self._call("POST", f"/v1/public/router-exposure", body=body, idempotency_key=idempotency_key)

    def post_public_run_lessons(self, body=None, idempotency_key=None):
        """Keep what a run on the signed-in person's own computer learned, in their workspace (POST /v1/public/run-lessons)"""
        return self._call("POST", f"/v1/public/run-lessons", body=body, idempotency_key=idempotency_key)

    def post_public_sample(self, body=None, idempotency_key=None):
        """Open the sample workspace with no sign-up (POST /v1/public/sample)"""
        return self._call("POST", f"/v1/public/sample", body=body, idempotency_key=idempotency_key)

    def post_public_sample_end(self, body=None, idempotency_key=None):
        """Leave the sample workspace (POST /v1/public/sample/end)"""
        return self._call("POST", f"/v1/public/sample/end", body=body, idempotency_key=idempotency_key)

    def post_public_scam_check(self, body=None, idempotency_key=None):
        """Check a message for a scam, free (POST /v1/public/scam-check)"""
        return self._call("POST", f"/v1/public/scam-check", body=body, idempotency_key=idempotency_key)

    def post_public_sign_in_code(self, body=None, idempotency_key=None):
        """Send a sign-in code to an email address (POST /v1/public/sign-in/code)"""
        return self._call("POST", f"/v1/public/sign-in/code", body=body, idempotency_key=idempotency_key)

    def post_public_sign_in_code_check(self, body=None, idempotency_key=None):
        """Check a sign-in code and start the session (POST /v1/public/sign-in/code/check)"""
        return self._call("POST", f"/v1/public/sign-in/code/check", body=body, idempotency_key=idempotency_key)

    def post_public_sign_out(self, body=None, idempotency_key=None):
        """Sign out of this page's session (POST /v1/public/sign-out)"""
        return self._call("POST", f"/v1/public/sign-out", body=body, idempotency_key=idempotency_key)

    def post_public_site_errors(self, body=None, idempotency_key=None):
        """Report the website's own browser errors (POST /v1/public/site-errors)"""
        return self._call("POST", f"/v1/public/site-errors", body=body, idempotency_key=idempotency_key)

    def post_public_site_reports(self, body=None, idempotency_key=None):
        """Receive the browser's reports for the website (POST /v1/public/site-reports)"""
        return self._call("POST", f"/v1/public/site-reports", body=body, idempotency_key=idempotency_key)

    def post_public_status_by_slug_confirm(self, slug, body=None, idempotency_key=None):
        """Confirm a subscription to a workspace's status page (POST /v1/public/status/{slug}/confirm)"""
        return self._call("POST", f"/v1/public/status/{_q(slug)}/confirm", body=body, idempotency_key=idempotency_key)

    def post_public_status_by_slug_subscribe(self, slug, body=None, idempotency_key=None):
        """Subscribe to a workspace's status page (POST /v1/public/status/{slug}/subscribe)"""
        return self._call("POST", f"/v1/public/status/{_q(slug)}/subscribe", body=body, idempotency_key=idempotency_key)

    def post_public_status_by_slug_unlock(self, slug, body=None, idempotency_key=None):
        """A private status page opened by its password - that browser keeps it open for thirty days, or until the password changes (POST /v1/public/status/{slug}/unlock)"""
        return self._call("POST", f"/v1/public/status/{_q(slug)}/unlock", body=body, idempotency_key=idempotency_key)

    def post_public_status_by_slug_unsubscribe(self, slug, body=None, idempotency_key=None):
        """Unsubscribe from a workspace's status page (POST /v1/public/status/{slug}/unsubscribe)"""
        return self._call("POST", f"/v1/public/status/{_q(slug)}/unsubscribe", body=body, idempotency_key=idempotency_key)

    def post_public_status_confirm(self, body=None, idempotency_key=None):
        """Confirm a status subscription (POST /v1/public/status/confirm)"""
        return self._call("POST", f"/v1/public/status/confirm", body=body, idempotency_key=idempotency_key)

    def post_public_status_subscribe(self, body=None, idempotency_key=None):
        """Subscribe to Xovris's status (POST /v1/public/status/subscribe)"""
        return self._call("POST", f"/v1/public/status/subscribe", body=body, idempotency_key=idempotency_key)

    def post_public_status_unsubscribe(self, body=None, idempotency_key=None):
        """Unsubscribe from Xovris's status (POST /v1/public/status/unsubscribe)"""
        return self._call("POST", f"/v1/public/status/unsubscribe", body=body, idempotency_key=idempotency_key)

    def post_public_tv_pairings(self, body=None, idempotency_key=None):
        """Ask for a code to pair a TV (POST /v1/public/tv/pairings)"""
        return self._call("POST", f"/v1/public/tv/pairings", body=body, idempotency_key=idempotency_key)

    def post_public_tv_pairings_by_pairing_id_sign_in(self, pairing_id, body=None, idempotency_key=None):
        """Send a TV's sign-in to its account's email or phone (POST /v1/public/tv/pairings/{pairingId}/sign-in)"""
        return self._call("POST", f"/v1/public/tv/pairings/{_q(pairing_id)}/sign-in", body=body, idempotency_key=idempotency_key)

    def post_public_tv_pairings_by_pairing_id_sign_in_code(self, pairing_id, body=None, idempotency_key=None):
        """Sign a TV in with the code from its message (POST /v1/public/tv/pairings/{pairingId}/sign-in/code)"""
        return self._call("POST", f"/v1/public/tv/pairings/{_q(pairing_id)}/sign-in/code", body=body, idempotency_key=idempotency_key)

    def post_qr_check(self, body=None, idempotency_key=None):
        """Check a QR code before anyone scans it (POST /v1/qr/check)"""
        return self._call("POST", f"/v1/qr/check", body=body, idempotency_key=idempotency_key)

    def post_queries(self, body=None, idempotency_key=None):
        """Save a query (POST /v1/queries)"""
        return self._call("POST", f"/v1/queries", body=body, idempotency_key=idempotency_key)

    def post_queries_by_id_run(self, id_, body=None, idempotency_key=None):
        """Run a saved query (POST /v1/queries/{id}/run)"""
        return self._call("POST", f"/v1/queries/{_q(id_)}/run", body=body, idempotency_key=idempotency_key)

    def post_query(self, body=None, idempotency_key=None):
        """Run a query over logs, metrics or traces (POST /v1/query)"""
        return self._call("POST", f"/v1/query", body=body, idempotency_key=idempotency_key)

    def post_query_check(self, body=None, idempotency_key=None):
        """Explain a query and check it for mistakes (POST /v1/query/check)"""
        return self._call("POST", f"/v1/query/check", body=body, idempotency_key=idempotency_key)

    def post_readings(self, body=None, idempotency_key=None):
        """Ask Xovris to read a subject now (POST /v1/readings)"""
        return self._call("POST", f"/v1/readings", body=body, idempotency_key=idempotency_key)

    def post_recoveries(self, body=None, idempotency_key=None):
        """Record money that came back for an incident, with its proof (POST /v1/recoveries)"""
        return self._call("POST", f"/v1/recoveries", body=body, idempotency_key=idempotency_key)

    def post_repairs_by_id_approve(self, id_, body=None, idempotency_key=None):
        """Approve a fix (POST /v1/repairs/{id}/approve)"""
        return self._call("POST", f"/v1/repairs/{_q(id_)}/approve", body=body, idempotency_key=idempotency_key)

    def post_repairs_by_id_reject(self, id_, body=None, idempotency_key=None):
        """Decline a fix (POST /v1/repairs/{id}/reject)"""
        return self._call("POST", f"/v1/repairs/{_q(id_)}/reject", body=body, idempotency_key=idempotency_key)

    def post_repairs_by_id_revise(self, id_, body=None, idempotency_key=None):
        """Ask for a fix to be changed (POST /v1/repairs/{id}/revise)"""
        return self._call("POST", f"/v1/repairs/{_q(id_)}/revise", body=body, idempotency_key=idempotency_key)

    def post_rescue_kit(self, body=None, idempotency_key=None):
        """Get the steps that rescue a device from what it is doing wrong (POST /v1/rescue-kit)"""
        return self._call("POST", f"/v1/rescue-kit", body=body, idempotency_key=idempotency_key)

    def post_reviews_ask(self, body=None, idempotency_key=None):
        """Ask about a change and get an answer from the change, its code and what is failing now, each line cited (POST /v1/reviews/ask)"""
        return self._call("POST", f"/v1/reviews/ask", body=body, idempotency_key=idempotency_key)

    def post_reviews_bill_import(self, body=None, idempotency_key=None):
        """Xovris reads a CycloneDX or SPDX bill you already have as your own - licences, policy and exports included (POST /v1/reviews/bill/import)"""
        return self._call("POST", f"/v1/reviews/bill/import", body=body, idempotency_key=idempotency_key)

    def post_reviews_conflicts(self, body=None, idempotency_key=None):
        """Hand Xovris a pull request's merge conflicts: resolved with both sides kept, proved by the tests and build, one merge commit on its branch (POST /v1/reviews/conflicts)"""
        return self._call("POST", f"/v1/reviews/conflicts", body=body, idempotency_key=idempotency_key)

    def post_reviews_issues(self, body=None, idempotency_key=None):
        """File a finding from a review as an issue in the workspace's tracker, or the repository's GitHub Issues, carrying its lines and what was seen (POST /v1/reviews/issues)"""
        return self._call("POST", f"/v1/reviews/issues", body=body, idempotency_key=idempotency_key)

    def post_reviews_licence_policy(self, body=None, idempotency_key=None):
        """Xovris keeps the licences your workspace allows, reviews or refuses, with who chose them (POST /v1/reviews/licence-policy)"""
        return self._call("POST", f"/v1/reviews/licence-policy", body=body, idempotency_key=idempotency_key)

    def post_reviews_merge_queue(self, body=None, idempotency_key=None):
        """Merge pull requests in order, each tested on top of the ones ahead before the base branch moves; it answers with the task to follow (POST /v1/reviews/merge-queue)"""
        return self._call("POST", f"/v1/reviews/merge-queue", body=body, idempotency_key=idempotency_key)

    def post_reviews_preferences(self, body=None, idempotency_key=None):
        """Set a code review preference for a repository, or for every repository (POST /v1/reviews/preferences)"""
        return self._call("POST", f"/v1/reviews/preferences", body=body, idempotency_key=idempotency_key)

    def post_reviews_preferences_import(self, body=None, idempotency_key=None):
        """Bring in the review rules a repository already writes down, as preferences (POST /v1/reviews/preferences/import)"""
        return self._call("POST", f"/v1/reviews/preferences/import", body=body, idempotency_key=idempotency_key)

    def post_reviews_run(self, body=None, idempotency_key=None):
        """Have Xovris review everything you connected now (POST /v1/reviews/run)"""
        return self._call("POST", f"/v1/reviews/run", body=body, idempotency_key=idempotency_key)

    def post_reviews_schedules(self, body=None, idempotency_key=None):
        """Schedule a coding automation on a connected repository - hourly, daily or weekly - each run proved and answered with its pull request in the channel named (POST /v1/reviews/schedules)"""
        return self._call("POST", f"/v1/reviews/schedules", body=body, idempotency_key=idempotency_key)

    def post_reviews_tasks(self, body=None, idempotency_key=None):
        """Hand Xovris a coding task on a connected repository; it answers with the task to follow (POST /v1/reviews/tasks)"""
        return self._call("POST", f"/v1/reviews/tasks", body=body, idempotency_key=idempotency_key)

    def post_reviews_views(self, body=None, idempotency_key=None):
        """Save a view of the code review findings under a name (POST /v1/reviews/views)"""
        return self._call("POST", f"/v1/reviews/views", body=body, idempotency_key=idempotency_key)

    def post_role_grants(self, body=None, idempotency_key=None):
        """Give a role made here to one person or one team over one thing - never more than the person giving it holds (POST /v1/role-grants)"""
        return self._call("POST", f"/v1/role-grants", body=body, idempotency_key=idempotency_key)

    def post_roles(self, body=None, idempotency_key=None):
        """Make a custom role from single permissions and groups - never more than the person making it holds (POST /v1/roles)"""
        return self._call("POST", f"/v1/roles", body=body, idempotency_key=idempotency_key)

    def post_roles_by_id_restore(self, id_, body=None, idempotency_key=None):
        """Restore a deleted custom role with its permissions (POST /v1/roles/{id}/restore)"""
        return self._call("POST", f"/v1/roles/{_q(id_)}/restore", body=body, idempotency_key=idempotency_key)

    def post_rum(self, body=None, idempotency_key=None):
        """Real-user signals from the browser SDK, masked again and kept for the session (POST /v1/rum)"""
        return self._call("POST", f"/v1/rum", body=body, idempotency_key=idempotency_key)

    def post_rum_external(self, body=None, idempotency_key=None):
        """Connect a replay tool with a token that reads its replays (POST /v1/rum/external)"""
        return self._call("POST", f"/v1/rum/external", body=body, idempotency_key=idempotency_key)

    def post_rum_feedback(self, body=None, idempotency_key=None):
        """A visitor's note, linked to the session it came from (POST /v1/rum/feedback)"""
        return self._call("POST", f"/v1/rum/feedback", body=body, idempotency_key=idempotency_key)

    def post_rum_replay(self, body=None, idempotency_key=None):
        """A masked replay chunk, kept with consent and within the plan's replays (POST /v1/rum/replay)"""
        return self._call("POST", f"/v1/rum/replay", body=body, idempotency_key=idempotency_key)

    def post_sandbox(self, body=None, idempotency_key=None):
        """Make your developer sandbox (POST /v1/sandbox)"""
        return self._call("POST", f"/v1/sandbox", body=body, idempotency_key=idempotency_key)

    def post_scam_check(self, body=None, idempotency_key=None):
        """Check a message for a scam (POST /v1/scam/check)"""
        return self._call("POST", f"/v1/scam/check", body=body, idempotency_key=idempotency_key)

    def post_scam_phone(self, body=None, idempotency_key=None):
        """Check what a phone read: a screenshot, a text, the Wi-Fi, the phone, a payment page, the data allowance or a calendar invite (POST /v1/scam/phone)"""
        return self._call("POST", f"/v1/scam/phone", body=body, idempotency_key=idempotency_key)

    def post_scam_report(self, body=None, idempotency_key=None):
        """Report a scam site for its takedown (POST /v1/scam/report)"""
        return self._call("POST", f"/v1/scam/report", body=body, idempotency_key=idempotency_key)

    def post_scim_v2_groups(self, body=None, idempotency_key=None):
        """A group pushed by the identity provider made a team of its name - a team of that name already here is said as taken with its id, so the provider links to it (POST /v1/scim/v2/Groups)"""
        return self._call("POST", f"/v1/scim/v2/Groups", body=body, idempotency_key=idempotency_key)

    def post_scim_v2_users(self, body=None, idempotency_key=None):
        """A person added at the identity provider, invited here with the role it names, within the workspace's own rules (POST /v1/scim/v2/Users)"""
        return self._call("POST", f"/v1/scim/v2/Users", body=body, idempotency_key=idempotency_key)

    def post_searches(self, body=None, idempotency_key=None):
        """Save a search on a list, for you or for your workspace (POST /v1/searches)"""
        return self._call("POST", f"/v1/searches", body=body, idempotency_key=idempotency_key)

    def post_secret_scanning_github(self, body=None, idempotency_key=None):
        """Where GitHub reports an Xovris key found in public, so it is revoked at once (POST /v1/secret-scanning/github)"""
        return self._call("POST", f"/v1/secret-scanning/github", body=body, idempotency_key=idempotency_key)

    def post_security_emergency(self, body=None, idempotency_key=None):
        """Start emergency mode: an incident, the records preserved, the steps and the people paged (POST /v1/security/emergency)"""
        return self._call("POST", f"/v1/security/emergency", body=body, idempotency_key=idempotency_key)

    def post_security_posture_fixes_by_id_state(self, id_, body=None, idempotency_key=None):
        """Say what you decided about a fix in the security queue - planned, the risk accepted with its reason, or resolved another way - with a note and your own tags (POST /v1/security/posture/fixes/{id}/state)"""
        return self._call("POST", f"/v1/security/posture/fixes/{_q(id_)}/state", body=body, idempotency_key=idempotency_key)

    def post_security_stack_connections(self, body=None, idempotency_key=None):
        """Connect a security tool you already use (POST /v1/security-stack/connections)"""
        return self._call("POST", f"/v1/security-stack/connections", body=body, idempotency_key=idempotency_key)

    def post_security_stack_connections_by_id_actions(self, id_, body=None, idempotency_key=None):
        """Have Xovris act through a security tool, such as containing a device (POST /v1/security-stack/connections/{id}/actions)"""
        return self._call("POST", f"/v1/security-stack/connections/{_q(id_)}/actions", body=body, idempotency_key=idempotency_key)

    def post_security_stack_connections_by_id_read(self, id_, body=None, idempotency_key=None):
        """Have Xovris read a security tool's devices and findings now (POST /v1/security-stack/connections/{id}/read)"""
        return self._call("POST", f"/v1/security-stack/connections/{_q(id_)}/read", body=body, idempotency_key=idempotency_key)

    def post_security_zero_days_by_id_report(self, id_, body=None, idempotency_key=None):
        """Send a zero-day's report to its maker's own security contact (an owner or admin) (POST /v1/security/zero-days/{id}/report)"""
        return self._call("POST", f"/v1/security/zero-days/{_q(id_)}/report", body=body, idempotency_key=idempotency_key)

    def post_sentry_issues_by_org_by_issue_id_resolve(self, org, issue_id, body=None, idempotency_key=None):
        """Mark one Sentry issue resolved from Xovris once its fix is proven (POST /v1/sentry/issues/{org}/{issueId}/resolve)"""
        return self._call("POST", f"/v1/sentry/issues/{_q(org)}/{_q(issue_id)}/resolve", body=body, idempotency_key=idempotency_key)

    def post_sessions(self, body=None, idempotency_key=None):
        """Start an AI work session in the cloud that you can follow from any device (POST /v1/sessions)"""
        return self._call("POST", f"/v1/sessions", body=body, idempotency_key=idempotency_key)

    def post_sessions_activities(self, body=None, idempotency_key=None):
        """Follow a session on a phone's lock screen as it works (POST /v1/sessions/activities)"""
        return self._call("POST", f"/v1/sessions/activities", body=body, idempotency_key=idempotency_key)

    def post_sessions_by_id_answers(self, id_, body=None, idempotency_key=None):
        """Answer a session's question so its work carries on (POST /v1/sessions/{id}/answers)"""
        return self._call("POST", f"/v1/sessions/{_q(id_)}/answers", body=body, idempotency_key=idempotency_key)

    def post_sessions_by_id_messages(self, id_, body=None, idempotency_key=None):
        """Send a running session a message - it reads it at its next step (POST /v1/sessions/{id}/messages)"""
        return self._call("POST", f"/v1/sessions/{_q(id_)}/messages", body=body, idempotency_key=idempotency_key)

    def post_sessions_by_id_stop(self, id_, body=None, idempotency_key=None):
        """Stop a running session (POST /v1/sessions/{id}/stop)"""
        return self._call("POST", f"/v1/sessions/{_q(id_)}/stop", body=body, idempotency_key=idempotency_key)

    def post_sessions_devices(self, body=None, idempotency_key=None):
        """Add a device that follows your sessions (POST /v1/sessions/devices)"""
        return self._call("POST", f"/v1/sessions/devices", body=body, idempotency_key=idempotency_key)

    def post_sessions_devices_exchange(self, body=None, idempotency_key=None):
        """Finish pairing a device with the code it was shown (POST /v1/sessions/devices/exchange)"""
        return self._call("POST", f"/v1/sessions/devices/exchange", body=body, idempotency_key=idempotency_key)

    def post_sessions_devices_links(self, body=None, idempotency_key=None):
        """Make a one-time link that pairs a device with your sessions (POST /v1/sessions/devices/links)"""
        return self._call("POST", f"/v1/sessions/devices/links", body=body, idempotency_key=idempotency_key)

    def post_sessions_presence(self, body=None, idempotency_key=None):
        """Say which device you are on now, so a session tells you there first (POST /v1/sessions/presence)"""
        return self._call("POST", f"/v1/sessions/presence", body=body, idempotency_key=idempotency_key)

    def post_sessions_tell(self, body=None, idempotency_key=None):
        """Tell your devices, in your order, that a session needs you (POST /v1/sessions/tell)"""
        return self._call("POST", f"/v1/sessions/tell", body=body, idempotency_key=idempotency_key)

    def post_settings_autonomy_suggestions_by_id_by_choice(self, id_, choice, body=None, idempotency_key=None):
        """Accept or dismiss a suggestion to trust Xovris more (POST /v1/settings/autonomy/suggestions/{id}/{choice})"""
        return self._call("POST", f"/v1/settings/autonomy/suggestions/{_q(id_)}/{_q(choice)}", body=body, idempotency_key=idempotency_key)

    def post_settings_billing_eligibility(self, body=None, idempotency_key=None):
        """Have Xovris read your school or your charity's register and keep the verdict (POST /v1/settings/billing/eligibility)"""
        return self._call("POST", f"/v1/settings/billing/eligibility", body=body, idempotency_key=idempotency_key)

    def post_settings_busy_periods(self, body=None, idempotency_key=None):
        """Add a busy period that holds risky changes (POST /v1/settings/busy-periods)"""
        return self._call("POST", f"/v1/settings/busy-periods", body=body, idempotency_key=idempotency_key)

    def post_settings_calendars(self, body=None, idempotency_key=None):
        """Connect a calendar of busy periods (POST /v1/settings/calendars)"""
        return self._call("POST", f"/v1/settings/calendars", body=body, idempotency_key=idempotency_key)

    def post_settings_change_windows(self, body=None, idempotency_key=None):
        """Set a maintenance window or a freeze on changes (POST /v1/settings/change-windows)"""
        return self._call("POST", f"/v1/settings/change-windows", body=body, idempotency_key=idempotency_key)

    def post_settings_plan(self, body=None, idempotency_key=None):
        """Ask to change your plan; it takes effect once payment is confirmed (POST /v1/settings/plan)"""
        return self._call("POST", f"/v1/settings/plan", body=body, idempotency_key=idempotency_key)

    def post_settings_plan_checkout(self, body=None, idempotency_key=None):
        """A plan's checkout, at its one approved price (POST /v1/settings/plan/checkout)"""
        return self._call("POST", f"/v1/settings/plan/checkout", body=body, idempotency_key=idempotency_key)

    def post_settings_plan_packs_checkout(self, body=None, idempotency_key=None):
        """A pack of fixes for this month, bought ahead at its one approved price (POST /v1/settings/plan/packs/checkout)"""
        return self._call("POST", f"/v1/settings/plan/packs/checkout", body=body, idempotency_key=idempotency_key)

    def post_settings_plan_preview(self, body=None, idempotency_key=None):
        """See exactly what a plan change would cost before you choose (POST /v1/settings/plan/preview)"""
        return self._call("POST", f"/v1/settings/plan/preview", body=body, idempotency_key=idempotency_key)

    def post_setup_grants(self, body=None, idempotency_key=None):
        """Give Xovris standing permission (POST /v1/setup/grants)"""
        return self._call("POST", f"/v1/setup/grants", body=body, idempotency_key=idempotency_key)

    def post_setup_recipes_by_id_research(self, id_, body=None, idempotency_key=None):
        """Draft the research a connection recipe needs, from its own sources (POST /v1/setup/recipes/{id}/research)"""
        return self._call("POST", f"/v1/setup/recipes/{_q(id_)}/research", body=body, idempotency_key=idempotency_key)

    def post_setup_research(self, body=None, idempotency_key=None):
        """Ask Xovris to research a provider it does not know yet (POST /v1/setup/research)"""
        return self._call("POST", f"/v1/setup/research", body=body, idempotency_key=idempotency_key)

    def post_setup_research_by_id_start(self, id_, body=None, idempotency_key=None):
        """Start the researched plan for a connection, tested by reading before it changes anything (POST /v1/setup/research/{id}/start)"""
        return self._call("POST", f"/v1/setup/research/{_q(id_)}/start", body=body, idempotency_key=idempotency_key)

    def post_setup_runs(self, body=None, idempotency_key=None):
        """Start a set-up (POST /v1/setup/runs)"""
        return self._call("POST", f"/v1/setup/runs", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_budget(self, id_, body=None, idempotency_key=None):
        """Answer a set-up's AI budget question (POST /v1/setup/runs/{id}/budget)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/budget", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_consent(self, id_, body=None, idempotency_key=None):
        """Agree to (or refuse) a set-up's changes (POST /v1/setup/runs/{id}/consent)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/consent", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_continue(self, id_, body=None, idempotency_key=None):
        """Continue a stopped set-up without redoing what still stands (POST /v1/setup/runs/{id}/continue)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/continue", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_credential(self, id_, body=None, idempotency_key=None):
        """Give a set-up the key it needs, kept sealed, and continue it if it was waiting for one (POST /v1/setup/runs/{id}/credential)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/credential", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_disconnect(self, id_, body=None, idempotency_key=None):
        """Disconnect a set-up (POST /v1/setup/runs/{id}/disconnect)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/disconnect", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_pause(self, id_, body=None, idempotency_key=None):
        """Pause a set-up (POST /v1/setup/runs/{id}/pause)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/pause", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_reconnected(self, id_, body=None, idempotency_key=None):
        """Continue a set-up after reconnecting its provider (POST /v1/setup/runs/{id}/reconnected)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/reconnected", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a set-up (POST /v1/setup/runs/{id}/resume)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_steps_by_step_id_approve(self, id_, step_id, body=None, idempotency_key=None):
        """Approve a set-up step (POST /v1/setup/runs/{id}/steps/{stepId}/approve)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/steps/{_q(step_id)}/approve", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_steps_by_step_id_connection(self, id_, step_id, body=None, idempotency_key=None):
        """Hand a set-up the connection you signed in with, proved by reading it back (POST /v1/setup/runs/{id}/steps/{stepId}/connection)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/steps/{_q(step_id)}/connection", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_steps_by_step_id_done(self, id_, step_id, body=None, idempotency_key=None):
        """Say a physical step of a set-up is done (Xovris then proves it) (POST /v1/setup/runs/{id}/steps/{stepId}/done)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/steps/{_q(step_id)}/done", body=body, idempotency_key=idempotency_key)

    def post_setup_runs_by_id_stop(self, id_, body=None, idempotency_key=None):
        """Stop a set-up and undo it (POST /v1/setup/runs/{id}/stop)"""
        return self._call("POST", f"/v1/setup/runs/{_q(id_)}/stop", body=body, idempotency_key=idempotency_key)

    def post_setup_steps_by_step_by_action(self, step, action, body=None, idempotency_key=None):
        """Do or skip a setup step (POST /v1/setup/steps/{step}/{action})"""
        return self._call("POST", f"/v1/setup/steps/{_q(step)}/{_q(action)}", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers(self, body=None, idempotency_key=None):
        """Hand a setup step to Xovris (POST /v1/setup/takeovers)"""
        return self._call("POST", f"/v1/setup/takeovers", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_answer(self, id_, body=None, idempotency_key=None):
        """Answer a hand-over's question (POST /v1/setup/takeovers/{id}/answer)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/answer", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_approve(self, id_, body=None, idempotency_key=None):
        """Approve a hand-over's next step (POST /v1/setup/takeovers/{id}/approve)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/approve", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_catch(self, id_, body=None, idempotency_key=None):
        """Catch the value a set-up page shows, once, into Xovris (POST /v1/setup/takeovers/{id}/catch)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/catch", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_continue(self, id_, body=None, idempotency_key=None):
        """Continue a hand-over (POST /v1/setup/takeovers/{id}/continue)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/continue", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_evidence_by_run_redrive(self, id_, run, body=None, idempotency_key=None):
        """Replay a recorded set-up against the site, step by step (POST /v1/setup/takeovers/{id}/evidence/{run}/redrive)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/evidence/{_q(run)}/redrive", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_handover(self, id_, body=None, idempotency_key=None):
        """Hand a takeover back to the person, with what Xovris did so far (POST /v1/setup/takeovers/{id}/handover)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/handover", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_input(self, id_, body=None, idempotency_key=None):
        """Type into a hand-over (POST /v1/setup/takeovers/{id}/input)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/input", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_key(self, id_, body=None, idempotency_key=None):
        """Give a guided set-up the key you made, kept only once the provider accepts it (POST /v1/setup/takeovers/{id}/key)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/key", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a paused takeover from where it stopped (POST /v1/setup/takeovers/{id}/resume)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_signed_in(self, id_, body=None, idempotency_key=None):
        """Say you have signed in during a hand-over (POST /v1/setup/takeovers/{id}/signed-in)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/signed-in", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_steps_by_step_id_done(self, id_, step_id, body=None, idempotency_key=None):
        """Mark a hand-over step done (POST /v1/setup/takeovers/{id}/steps/{stepId}/done)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/steps/{_q(step_id)}/done", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_stop(self, id_, body=None, idempotency_key=None):
        """Stop a hand-over (POST /v1/setup/takeovers/{id}/stop)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/stop", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_take_back(self, id_, body=None, idempotency_key=None):
        """Take back control from Xovris while it is setting something up for you (POST /v1/setup/takeovers/{id}/take-back)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/take-back", body=body, idempotency_key=idempotency_key)

    def post_setup_takeovers_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a hand-over (POST /v1/setup/takeovers/{id}/undo)"""
        return self._call("POST", f"/v1/setup/takeovers/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_setup_test_alert(self, body=None, idempotency_key=None):
        """Send a test alert (POST /v1/setup/test-alert)"""
        return self._call("POST", f"/v1/setup/test-alert", body=body, idempotency_key=idempotency_key)

    def post_sim_swap(self, body=None, idempotency_key=None):
        """See which accounts are at risk if someone takes over a phone number (POST /v1/sim-swap)"""
        return self._call("POST", f"/v1/sim-swap", body=body, idempotency_key=idempotency_key)

    def post_sla_credit(self, body=None, idempotency_key=None):
        """See the credit a provider owes you for its downtime, in your own currency (POST /v1/sla/credit)"""
        return self._call("POST", f"/v1/sla/credit", body=body, idempotency_key=idempotency_key)

    def post_sso_providers(self, body=None, idempotency_key=None):
        """Xovris connects your company's identity provider (OpenID Connect or SAML) for the email domain your people sign in with (POST /v1/sso/providers)"""
        return self._call("POST", f"/v1/sso/providers", body=body, idempotency_key=idempotency_key)

    def post_sso_providers_by_provider_id_test(self, provider_id, body=None, idempotency_key=None):
        """Test a company sign-in to its identity provider and back - nobody is created, signed in or joined (POST /v1/sso/providers/{providerId}/test)"""
        return self._call("POST", f"/v1/sso/providers/{_q(provider_id)}/test", body=body, idempotency_key=idempotency_key)

    def post_sso_providers_by_provider_id_verify(self, provider_id, body=None, idempotency_key=None):
        """Prove a company sign-in's domain - Xovris reads its DNS TXT record and switches the sign-in on when it holds (POST /v1/sso/providers/{providerId}/verify)"""
        return self._call("POST", f"/v1/sso/providers/{_q(provider_id)}/verify", body=body, idempotency_key=idempotency_key)

    def post_statement_saved(self, body=None, idempotency_key=None):
        """See the time and money Xovris saved this month, measured fix by fix at your own rates (POST /v1/statement/saved)"""
        return self._call("POST", f"/v1/statement/saved", body=body, idempotency_key=idempotency_key)

    def post_status_pages(self, body=None, idempotency_key=None):
        """A new status page beside the ones the workspace keeps - its own address, parts, followers and updates (POST /v1/status-pages)"""
        return self._call("POST", f"/v1/status-pages", body=body, idempotency_key=idempotency_key)

    def post_status_pages_by_id_audiences(self, id_, body=None, idempotency_key=None):
        """An audience added to a private status page - its name, the parts it reads, and its own password, networks or both (POST /v1/status-pages/{id}/audiences)"""
        return self._call("POST", f"/v1/status-pages/{_q(id_)}/audiences", body=body, idempotency_key=idempotency_key)

    def post_status_pages_by_id_maintenance(self, id_, body=None, idempotency_key=None):
        """Planned work on a status page - its title, the parts it touches, its start and end - shown on the page, told to its followers, and the alerts of those parts' checks held for its length (POST /v1/status-pages/{id}/maintenance)"""
        return self._call("POST", f"/v1/status-pages/{_q(id_)}/maintenance", body=body, idempotency_key=idempotency_key)

    def post_status_pages_by_id_open(self, id_, body=None, idempotency_key=None):
        """The way back to a private status page for a signed-in member of its workspace: a two-minute ticket on the address the page was read at (POST /v1/status-pages/{id}/open)"""
        return self._call("POST", f"/v1/status-pages/{_q(id_)}/open", body=body, idempotency_key=idempotency_key)

    def post_status_page_updates(self, body=None, idempotency_key=None):
        """Post an update on your status page (POST /v1/status-page/updates)"""
        return self._call("POST", f"/v1/status-page/updates", body=body, idempotency_key=idempotency_key)

    def post_storage_inventory_fields(self, body=None, idempotency_key=None):
        """Have Xovris add the fields a bucket's inventory is missing, written and read back from S3 (POST /v1/storage/inventory-fields)"""
        return self._call("POST", f"/v1/storage/inventory-fields", body=body, idempotency_key=idempotency_key)

    def post_storage_inventory_fields_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Put a bucket's inventory configuration back exactly as it was (POST /v1/storage/inventory-fields/{id}/undo)"""
        return self._call("POST", f"/v1/storage/inventory-fields/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_storage_waste(self, body=None, idempotency_key=None):
        """Find wasted object storage and plan the saving (POST /v1/storage/waste)"""
        return self._call("POST", f"/v1/storage/waste", body=body, idempotency_key=idempotency_key)

    def post_storage_waste_by_id_verify(self, id_, body=None, idempotency_key=None):
        """Prove a storage saving 30 days on (POST /v1/storage/waste/{id}/verify)"""
        return self._call("POST", f"/v1/storage/waste/{_q(id_)}/verify", body=body, idempotency_key=idempotency_key)

    def post_storage_waste_read(self, body=None, idempotency_key=None):
        """Have Xovris read each bucket's own inventory report and plan every saving it finds, changing nothing (POST /v1/storage/waste/read)"""
        return self._call("POST", f"/v1/storage/waste/read", body=body, idempotency_key=idempotency_key)

    def post_stripe_connect(self, body=None, idempotency_key=None):
        """Connect Stripe (POST /v1/stripe/connect)"""
        return self._call("POST", f"/v1/stripe/connect", body=body, idempotency_key=idempotency_key)

    def post_stripe_refunds(self, body=None, idempotency_key=None):
        """Refund a payment (POST /v1/stripe/refunds)"""
        return self._call("POST", f"/v1/stripe/refunds", body=body, idempotency_key=idempotency_key)

    def post_stripe_reviews_approve(self, body=None, idempotency_key=None):
        """Approve a payment held for review (POST /v1/stripe/reviews/approve)"""
        return self._call("POST", f"/v1/stripe/reviews/approve", body=body, idempotency_key=idempotency_key)

    def post_subscriptions_saver(self, body=None, idempotency_key=None):
        """Find what you pay for and do not use, and cancel or downgrade each one on your yes (POST /v1/subscriptions/saver)"""
        return self._call("POST", f"/v1/subscriptions/saver", body=body, idempotency_key=idempotency_key)

    def post_suppliers_impact(self, body=None, idempotency_key=None):
        """See what a supplier's incident means for you, and have Xovris act on it (POST /v1/suppliers/impact)"""
        return self._call("POST", f"/v1/suppliers/impact", body=body, idempotency_key=idempotency_key)

    def post_systems(self, body=None, idempotency_key=None):
        """Connect any system by its address - Xovris reads what it says about itself and looks after what is on it (POST /v1/systems)"""
        return self._call("POST", f"/v1/systems", body=body, idempotency_key=idempotency_key)

    def post_systems_general_runs(self, body=None, idempotency_key=None):
        """Ask Xovris to do a job on any system it can reach (POST /v1/systems/general-runs)"""
        return self._call("POST", f"/v1/systems/general-runs", body=body, idempotency_key=idempotency_key)

    def post_systems_general_runs_by_job_feedback(self, job, body=None, idempotency_key=None):
        """Tell Xovris how a job went - undone, a complaint or thanks (POST /v1/systems/general-runs/{job}/feedback)"""
        return self._call("POST", f"/v1/systems/general-runs/{_q(job)}/feedback", body=body, idempotency_key=idempotency_key)

    def post_systems_general_runs_jobs_by_job_record_check(self, job, body=None, idempotency_key=None):
        """Check that a job's signed recording is whole and unchanged (POST /v1/systems/general-runs/jobs/{job}/record/check)"""
        return self._call("POST", f"/v1/systems/general-runs/jobs/{_q(job)}/record/check", body=body, idempotency_key=idempotency_key)

    def post_systems_general_runs_memory_corrections(self, body=None, idempotency_key=None):
        """Tell Xovris what you meant, as a rule kept only for you (POST /v1/systems/general-runs/memory/corrections)"""
        return self._call("POST", f"/v1/systems/general-runs/memory/corrections", body=body, idempotency_key=idempotency_key)

    def post_systems_general_runs_schedules(self, body=None, idempotency_key=None):
        """Have Xovris check something on a system unasked and tell you only what changed (POST /v1/systems/general-runs/schedules)"""
        return self._call("POST", f"/v1/systems/general-runs/schedules", body=body, idempotency_key=idempotency_key)

    def post_systems_general_runs_standing_by_id_by_act(self, id_, act, body=None, idempotency_key=None):
        """Accept a standing yes Xovris offered, or take one back (POST /v1/systems/general-runs/standing/{id}/{act})"""
        return self._call("POST", f"/v1/systems/general-runs/standing/{_q(id_)}/{_q(act)}", body=body, idempotency_key=idempotency_key)

    def post_systems_profiles(self, body=None, idempotency_key=None):
        """Connect a system by what it publishes (POST /v1/systems/profiles)"""
        return self._call("POST", f"/v1/systems/profiles", body=body, idempotency_key=idempotency_key)

    def post_teams(self, body=None, idempotency_key=None):
        """Make a team that holds a role made here - its people hold it beside their own; never more than the person making it holds (POST /v1/teams)"""
        return self._call("POST", f"/v1/teams", body=body, idempotency_key=idempotency_key)

    def post_telemetry_diet_by_id_apply(self, id_, body=None, idempotency_key=None):
        """Apply a telemetry diet (POST /v1/telemetry/diet/{id}/apply)"""
        return self._call("POST", f"/v1/telemetry/diet/{_q(id_)}/apply", body=body, idempotency_key=idempotency_key)

    def post_telemetry_diet_propose(self, body=None, idempotency_key=None):
        """Propose a safe cut to metric and trace volume (POST /v1/telemetry/diet/propose)"""
        return self._call("POST", f"/v1/telemetry/diet/propose", body=body, idempotency_key=idempotency_key)

    def post_telemetry_diet_revert(self, body=None, idempotency_key=None):
        """Put the telemetry diet back (POST /v1/telemetry/diet/revert)"""
        return self._call("POST", f"/v1/telemetry/diet/revert", body=body, idempotency_key=idempotency_key)

    def post_things(self, body=None, idempotency_key=None):
        """Have Xovris meet a thing by its address (POST /v1/things)"""
        return self._call("POST", f"/v1/things", body=body, idempotency_key=idempotency_key)

    def post_things_by_id_changes(self, id_, body=None, idempotency_key=None):
        """Rehearse a change to a thing on a copy (POST /v1/things/{id}/changes)"""
        return self._call("POST", f"/v1/things/{_q(id_)}/changes", body=body, idempotency_key=idempotency_key)

    def post_things_by_id_changes_approve(self, id_, body=None, idempotency_key=None):
        """Approve a rehearsed change to a thing (POST /v1/things/{id}/changes/approve)"""
        return self._call("POST", f"/v1/things/{_q(id_)}/changes/approve", body=body, idempotency_key=idempotency_key)

    def post_things_by_id_changes_undo(self, id_, body=None, idempotency_key=None):
        """Put back the last change to a thing (POST /v1/things/{id}/changes/undo)"""
        return self._call("POST", f"/v1/things/{_q(id_)}/changes/undo", body=body, idempotency_key=idempotency_key)

    def post_things_by_id_normal(self, id_, body=None, idempotency_key=None):
        """Tell Xovris what a thing reads now is its new normal (POST /v1/things/{id}/normal)"""
        return self._call("POST", f"/v1/things/{_q(id_)}/normal", body=body, idempotency_key=idempotency_key)

    def post_things_by_id_pace(self, id_, body=None, idempotency_key=None):
        """How often Xovris looks at a thing - any number of seconds the plan has room for, or Xovris's own choice (POST /v1/things/{id}/pace)"""
        return self._call("POST", f"/v1/things/{_q(id_)}/pace", body=body, idempotency_key=idempotency_key)

    def post_things_by_id_watch(self, id_, body=None, idempotency_key=None):
        """Have Xovris look at a thing again now (POST /v1/things/{id}/watch)"""
        return self._call("POST", f"/v1/things/{_q(id_)}/watch", body=body, idempotency_key=idempotency_key)

    def post_tokens(self, body=None, idempotency_key=None):
        """Create an API token (POST /v1/tokens)"""
        return self._call("POST", f"/v1/tokens", body=body, idempotency_key=idempotency_key)

    def post_tokens_by_id_alerts(self, id_, body=None, idempotency_key=None):
        """Turn on or off being told when an API key is used in an unusual way (POST /v1/tokens/{id}/alerts)"""
        return self._call("POST", f"/v1/tokens/{_q(id_)}/alerts", body=body, idempotency_key=idempotency_key)

    def post_tokens_by_id_renew(self, id_, body=None, idempotency_key=None):
        """Renew an API token before it ends, with the same name and permissions (POST /v1/tokens/{id}/renew)"""
        return self._call("POST", f"/v1/tokens/{_q(id_)}/renew", body=body, idempotency_key=idempotency_key)

    def post_tokens_by_id_replace(self, id_, body=None, idempotency_key=None):
        """Replace an API key that was found in public, with the same name and permissions (POST /v1/tokens/{id}/replace)"""
        return self._call("POST", f"/v1/tokens/{_q(id_)}/replace", body=body, idempotency_key=idempotency_key)

    def post_tokens_by_id_rotate(self, id_, body=None, idempotency_key=None):
        """Replace an API token with a new one (POST /v1/tokens/{id}/rotate)"""
        return self._call("POST", f"/v1/tokens/{_q(id_)}/rotate", body=body, idempotency_key=idempotency_key)

    def post_tokens_by_id_widen(self, id_, body=None, idempotency_key=None):
        """Make an API key again with the one thing a refused call needed, every other limit kept (POST /v1/tokens/{id}/widen)"""
        return self._call("POST", f"/v1/tokens/{_q(id_)}/widen", body=body, idempotency_key=idempotency_key)

    def post_tool_connections(self, body=None, idempotency_key=None):
        """Connect a tool (POST /v1/tool-connections)"""
        return self._call("POST", f"/v1/tool-connections", body=body, idempotency_key=idempotency_key)

    def post_tool_connections_by_id_pause(self, id_, body=None, idempotency_key=None):
        """Pause a tool connection (POST /v1/tool-connections/{id}/pause)"""
        return self._call("POST", f"/v1/tool-connections/{_q(id_)}/pause", body=body, idempotency_key=idempotency_key)

    def post_tool_connections_by_id_resume(self, id_, body=None, idempotency_key=None):
        """Resume a tool connection (POST /v1/tool-connections/{id}/resume)"""
        return self._call("POST", f"/v1/tool-connections/{_q(id_)}/resume", body=body, idempotency_key=idempotency_key)

    def post_tool_connections_by_id_rewire(self, id_, body=None, idempotency_key=None):
        """Have Xovris put a fresh webhook and secret into a connected tool (POST /v1/tool-connections/{id}/rewire)"""
        return self._call("POST", f"/v1/tool-connections/{_q(id_)}/rewire", body=body, idempotency_key=idempotency_key)

    def post_tool_servers(self, body=None, idempotency_key=None):
        """Connect an AI tool server by its address (POST /v1/tool-servers)"""
        return self._call("POST", f"/v1/tool-servers", body=body, idempotency_key=idempotency_key)

    def post_tool_servers_by_id_tools_by_name_approve(self, id_, name, body=None, idempotency_key=None):
        """Approve one tool on a tool server (POST /v1/tool-servers/{id}/tools/{name}/approve)"""
        return self._call("POST", f"/v1/tool-servers/{_q(id_)}/tools/{_q(name)}/approve", body=body, idempotency_key=idempotency_key)

    def post_traces_sampling_raise(self, body=None, idempotency_key=None):
        """Keep every trace on one path for a while (POST /v1/traces/sampling/raise)"""
        return self._call("POST", f"/v1/traces/sampling/raise", body=body, idempotency_key=idempotency_key)

    def post_travel_plan(self, body=None, idempotency_key=None):
        """Plan how each device is locked down for a trip, with a snapshot kept to compare on return (POST /v1/travel/plan)"""
        return self._call("POST", f"/v1/travel/plan", body=body, idempotency_key=idempotency_key)

    def post_travel_return(self, body=None, idempotency_key=None):
        """Check a device back from a trip against its snapshot from before (POST /v1/travel/return)"""
        return self._call("POST", f"/v1/travel/return", body=body, idempotency_key=idempotency_key)

    def post_uploads(self, body=None, idempotency_key=None):
        """Start sending a large file in parts (POST /v1/uploads)"""
        return self._call("POST", f"/v1/uploads", body=body, idempotency_key=idempotency_key)

    def post_uploads_by_id_complete(self, id_, body=None, idempotency_key=None):
        """Finish a large file's upload once every part has arrived (POST /v1/uploads/{id}/complete)"""
        return self._call("POST", f"/v1/uploads/{_q(id_)}/complete", body=body, idempotency_key=idempotency_key)

    def post_vendor_fixes(self, body=None, idempotency_key=None):
        """Send your company's fix to Xovris, to be rehearsed and offered to every customer it helps (POST /v1/vendor-fixes)"""
        return self._call("POST", f"/v1/vendor-fixes", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_devices_by_id_importance(self, id_, body=None, idempotency_key=None):
        """Say how important a device is, so its risk is weighed right (POST /v1/vulnerabilities/devices/{id}/importance)"""
        return self._call("POST", f"/v1/vulnerabilities/devices/{_q(id_)}/importance", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_devices_by_id_packages_move(self, id_, body=None, idempotency_key=None):
        """Have Xovris install a supported line of a package beside the one past its support (POST /v1/vulnerabilities/devices/{id}/packages/move)"""
        return self._call("POST", f"/v1/vulnerabilities/devices/{_q(id_)}/packages/move", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_devices_by_id_packages_offers(self, id_, body=None, idempotency_key=None):
        """Ask a computer which supported line of a package its own package managers offer (POST /v1/vulnerabilities/devices/{id}/packages/offers)"""
        return self._call("POST", f"/v1/vulnerabilities/devices/{_q(id_)}/packages/offers", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_devices_by_id_patch(self, id_, body=None, idempotency_key=None):
        """Have Xovris patch a device (POST /v1/vulnerabilities/devices/{id}/patch)"""
        return self._call("POST", f"/v1/vulnerabilities/devices/{_q(id_)}/patch", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_devices_ids_blocks_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Put a sensor rule Xovris switched to drop back as it was (POST /v1/vulnerabilities/devices/ids-blocks/{id}/undo)"""
        return self._call("POST", f"/v1/vulnerabilities/devices/ids-blocks/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_devices_virtual_patches_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a virtual patch Xovris put in place (POST /v1/vulnerabilities/devices/virtual-patches/{id}/undo)"""
        return self._call("POST", f"/v1/vulnerabilities/devices/virtual-patches/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_vulnerabilities_upgrades_by_id_fix(self, id_, body=None, idempotency_key=None):
        """Ask Xovris to make an upgrade (POST /v1/vulnerabilities/upgrades/{id}/fix)"""
        return self._call("POST", f"/v1/vulnerabilities/upgrades/{_q(id_)}/fix", body=body, idempotency_key=idempotency_key)

    def post_watches(self, body=None, idempotency_key=None):
        """Watch something, in your own words (POST /v1/watches)"""
        return self._call("POST", f"/v1/watches", body=body, idempotency_key=idempotency_key)

    def post_watches_by_id_off(self, id_, body=None, idempotency_key=None):
        """Turn a watch off (POST /v1/watches/{id}/off)"""
        return self._call("POST", f"/v1/watches/{_q(id_)}/off", body=body, idempotency_key=idempotency_key)

    def post_watches_by_id_restore(self, id_, body=None, idempotency_key=None):
        """Put a watched record set back as Xovris kept it before the change (POST /v1/watches/{id}/restore)"""
        return self._call("POST", f"/v1/watches/{_q(id_)}/restore", body=body, idempotency_key=idempotency_key)

    def post_watches_preview(self, body=None, idempotency_key=None):
        """Preview a watch before adding it (POST /v1/watches/preview)"""
        return self._call("POST", f"/v1/watches/preview", body=body, idempotency_key=idempotency_key)

    def post_watches_test(self, body=None, idempotency_key=None):
        """Test a watch now (POST /v1/watches/test)"""
        return self._call("POST", f"/v1/watches/test", body=body, idempotency_key=idempotency_key)

    def post_web_filter_appeals(self, body=None, idempotency_key=None):
        """Ask for a blocked web name to be allowed (POST /v1/web-filter/appeals)"""
        return self._call("POST", f"/v1/web-filter/appeals", body=body, idempotency_key=idempotency_key)

    def post_web_filter_appeals_by_id_answer(self, id_, body=None, idempotency_key=None):
        """Answer a request to allow a blocked web name (POST /v1/web-filter/appeals/{id}/answer)"""
        return self._call("POST", f"/v1/web-filter/appeals/{_q(id_)}/answer", body=body, idempotency_key=idempotency_key)

    def post_web_filter_judge(self, body=None, idempotency_key=None):
        """Check how your web filter treats a web name, and why (POST /v1/web-filter/judge)"""
        return self._call("POST", f"/v1/web-filter/judge", body=body, idempotency_key=idempotency_key)

    def post_web_filter_policy(self, body=None, idempotency_key=None):
        """Change your web filter policy (POST /v1/web-filter/policy)"""
        return self._call("POST", f"/v1/web-filter/policy", body=body, idempotency_key=idempotency_key)

    def post_webhooks(self, body=None, idempotency_key=None):
        """Add a webhook (POST /v1/webhooks)"""
        return self._call("POST", f"/v1/webhooks", body=body, idempotency_key=idempotency_key)

    def post_webhooks_by_id_check(self, id_, body=None, idempotency_key=None):
        """Have Xovris check that your receiver refuses forged, changed and replayed deliveries (POST /v1/webhooks/{id}/check)"""
        return self._call("POST", f"/v1/webhooks/{_q(id_)}/check", body=body, idempotency_key=idempotency_key)

    def post_webhooks_by_id_deliveries_by_delivery_id_replay(self, id_, delivery_id, body=None, idempotency_key=None):
        """Send a webhook delivery again (POST /v1/webhooks/{id}/deliveries/{deliveryId}/replay)"""
        return self._call("POST", f"/v1/webhooks/{_q(id_)}/deliveries/{_q(delivery_id)}/replay", body=body, idempotency_key=idempotency_key)

    def post_webhooks_by_id_enable(self, id_, body=None, idempotency_key=None):
        """Switch a webhook back on (POST /v1/webhooks/{id}/enable)"""
        return self._call("POST", f"/v1/webhooks/{_q(id_)}/enable", body=body, idempotency_key=idempotency_key)

    def post_webhooks_by_id_recover(self, id_, body=None, idempotency_key=None):
        """Send again every delivery that failed since a time (POST /v1/webhooks/{id}/recover)"""
        return self._call("POST", f"/v1/webhooks/{_q(id_)}/recover", body=body, idempotency_key=idempotency_key)

    def post_webhooks_by_id_rotate(self, id_, body=None, idempotency_key=None):
        """Rotate a webhook's signing secret (POST /v1/webhooks/{id}/rotate)"""
        return self._call("POST", f"/v1/webhooks/{_q(id_)}/rotate", body=body, idempotency_key=idempotency_key)

    def post_webhooks_by_id_test(self, id_, body=None, idempotency_key=None):
        """Send a test event to a webhook (POST /v1/webhooks/{id}/test)"""
        return self._call("POST", f"/v1/webhooks/{_q(id_)}/test", body=body, idempotency_key=idempotency_key)

    def post_what_if_by_id_undo(self, id_, body=None, idempotency_key=None):
        """Undo a change made from a what-if (POST /v1/what-if/{id}/undo)"""
        return self._call("POST", f"/v1/what-if/{_q(id_)}/undo", body=body, idempotency_key=idempotency_key)

    def post_workspace_domains(self, body=None, idempotency_key=None):
        """Point a domain you own at this workspace and get the records to add (POST /v1/workspace/domains)"""
        return self._call("POST", f"/v1/workspace/domains", body=body, idempotency_key=idempotency_key)

    def post_workspace_domains_by_hostname_check(self, hostname, body=None, idempotency_key=None):
        """Check a domain's records and certificate again now (POST /v1/workspace/domains/{hostname}/check)"""
        return self._call("POST", f"/v1/workspace/domains/{_q(hostname)}/check", body=body, idempotency_key=idempotency_key)

    def post_workspace_erase(self, body=None, idempotency_key=None):
        """Erase this workspace and everything in it, with a signed receipt (POST /v1/workspace/erase)"""
        return self._call("POST", f"/v1/workspace/erase", body=body, idempotency_key=idempotency_key)

    def post_workspaces(self, body=None, idempotency_key=None):
        """Create a workspace (POST /v1/workspaces)"""
        return self._call("POST", f"/v1/workspaces", body=body, idempotency_key=idempotency_key)

    def put_access_level(self, body=None, idempotency_key=None):
        """Set how far Xovris may act, for the whole workspace or one connection, on the one four-level slider (PUT /v1/access/level)"""
        return self._call("PUT", f"/v1/access/level", body=body, idempotency_key=idempotency_key)

    def put_alerts_mail_server(self, body=None, idempotency_key=None):
        """Alert and status email through the workspace's own mail server (PUT /v1/alerts/mail-server)"""
        return self._call("PUT", f"/v1/alerts/mail-server", body=body, idempotency_key=idempotency_key)

    def put_alerts_sending_domain(self, body=None, idempotency_key=None):
        """Alert and status email from the workspace's own domain (PUT /v1/alerts/sending-domain)"""
        return self._call("PUT", f"/v1/alerts/sending-domain", body=body, idempotency_key=idempotency_key)

    def put_autonomy_approval_chain(self, body=None, idempotency_key=None):
        """Set the approval chain: the members Xovris asks in turn, each with how long it waits for them (PUT /v1/autonomy/approval-chain)"""
        return self._call("PUT", f"/v1/autonomy/approval-chain", body=body, idempotency_key=idempotency_key)

    def put_autonomy_facts_by_key(self, key, body=None, idempotency_key=None):
        """Tell Xovris a fact once, so every later setup reads it instead of asking (PUT /v1/autonomy/facts/{key})"""
        return self._call("PUT", f"/v1/autonomy/facts/{_q(key)}", body=body, idempotency_key=idempotency_key)

    def put_autonomy_me_level(self, body=None, idempotency_key=None):
        """Choose how much Xovris takes over for you (PUT /v1/autonomy/me/level)"""
        return self._call("PUT", f"/v1/autonomy/me/level", body=body, idempotency_key=idempotency_key)

    def put_autonomy_spend_policy(self, body=None, idempotency_key=None):
        """Change the spend policy Xovris cleans up spending under (PUT /v1/autonomy/spend/policy)"""
        return self._call("PUT", f"/v1/autonomy/spend/policy", body=body, idempotency_key=idempotency_key)

    def put_board_layout(self, body=None, idempotency_key=None):
        """Keep where your dashboard's tiles sit and how big they are (PUT /v1/board/layout)"""
        return self._call("PUT", f"/v1/board/layout", body=body, idempotency_key=idempotency_key)

    def put_checks_by_id_promise(self, id_, body=None, idempotency_key=None):
        """Set how much of the time a check must be up (PUT /v1/checks/{id}/promise)"""
        return self._call("PUT", f"/v1/checks/{_q(id_)}/promise", body=body, idempotency_key=idempotency_key)

    def put_code_projects_by_id_network(self, id_, body=None, idempotency_key=None):
        """Saves what a project's build sessions may reach - every connection decided and kept on the run's record (PUT /v1/code/projects/{id}/network)"""
        return self._call("PUT", f"/v1/code/projects/{_q(id_)}/network", body=body, idempotency_key=idempotency_key)

    def put_code_projects_by_id_secrets_by_name(self, id_, name, body=None, idempotency_key=None):
        """Keep a secret a build needs - a key or a password - out of its code (PUT /v1/code/projects/{id}/secrets/{name})"""
        return self._call("PUT", f"/v1/code/projects/{_q(id_)}/secrets/{_q(name)}", body=body, idempotency_key=idempotency_key)

    def put_code_spend_limit(self, body=None, idempotency_key=None):
        """Set how much your builds may spend in a month (PUT /v1/code/spend-limit)"""
        return self._call("PUT", f"/v1/code/spend-limit", body=body, idempotency_key=idempotency_key)

    def put_code_tasks_by_id_plan(self, id_, body=None, idempotency_key=None):
        """Change a build's plan before it is built (PUT /v1/code/tasks/{id}/plan)"""
        return self._call("PUT", f"/v1/code/tasks/{_q(id_)}/plan", body=body, idempotency_key=idempotency_key)

    def put_code_tasks_by_id_wait(self, id_, body=None, idempotency_key=None):
        """Make a coding job wait for an answer, a go, CI, a review, a reply, a ticket or a date - holding nothing while it waits (PUT /v1/code/tasks/{id}/wait)"""
        return self._call("PUT", f"/v1/code/tasks/{_q(id_)}/wait", body=body, idempotency_key=idempotency_key)

    def put_computer_policy(self, body=None, idempotency_key=None):
        """What Xovris may do on a computer in this workspace, as this workspace rules it (PUT /v1/computer/policy)"""
        return self._call("PUT", f"/v1/computer/policy", body=body, idempotency_key=idempotency_key)

    def put_computers_by_id_desk_profile(self, id_, body=None, idempotency_key=None):
        """The desktop's own door: it keeps the sign-ins made on it, sealed in your workspace's vault, with the key it was started with (PUT /v1/computers/{id}/desk/profile)"""
        return self._call("PUT", f"/v1/computers/{_q(id_)}/desk/profile", body=body, idempotency_key=idempotency_key)

    def put_household_members_by_id(self, id_, body=None, idempotency_key=None):
        """Change a household member's age band, quiet hours, services or allowed names (PUT /v1/household/members/{id})"""
        return self._call("PUT", f"/v1/household/members/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def put_incidents_by_id_owner(self, id_, body=None, idempotency_key=None):
        """Set or clear who owns an incident (PUT /v1/incidents/{id}/owner)"""
        return self._call("PUT", f"/v1/incidents/{_q(id_)}/owner", body=body, idempotency_key=idempotency_key)

    def put_incidents_by_id_workspace(self, id_, body=None, idempotency_key=None):
        """Save an incident's working notes (an out-of-date copy is refused, never overwritten) (PUT /v1/incidents/{id}/workspace)"""
        return self._call("PUT", f"/v1/incidents/{_q(id_)}/workspace", body=body, idempotency_key=idempotency_key)

    def put_issues_triage_settings(self, body=None, idempotency_key=None):
        """How triage works: who new issues go to, whether a priority is needed, and its rules (PUT /v1/issues/triage/settings)"""
        return self._call("PUT", f"/v1/issues/triage/settings", body=body, idempotency_key=idempotency_key)

    def put_logs_retention(self, body=None, idempotency_key=None):
        """Change how long logs are kept (PUT /v1/logs/retention)"""
        return self._call("PUT", f"/v1/logs/retention", body=body, idempotency_key=idempotency_key)

    def put_major_comms_rules(self, body=None, idempotency_key=None):
        """Keep the workspace's rules for who is told when a major incident of each kind and severity is declared (PUT /v1/major-comms/rules)"""
        return self._call("PUT", f"/v1/major-comms/rules", body=body, idempotency_key=idempotency_key)

    def put_me_preferences(self, body=None, idempotency_key=None):
        """Save your own appearance and notification choices for every device (PUT /v1/me/preferences)"""
        return self._call("PUT", f"/v1/me/preferences", body=body, idempotency_key=idempotency_key)

    def put_people_by_user_id_end(self, user_id, body=None, idempotency_key=None):
        """A person's access given an end date, or its end taken away - never an owner's, never one's own; from that second they hold nothing here (PUT /v1/people/{userId}/end)"""
        return self._call("PUT", f"/v1/people/{_q(user_id)}/end", body=body, idempotency_key=idempotency_key)

    def put_people_outside_rule(self, body=None, idempotency_key=None):
        """The rule for people from outside - the workspace's own domains, who may invite from outside, the domains only or never invited, and the longest stay (PUT /v1/people/outside/rule)"""
        return self._call("PUT", f"/v1/people/outside/rule", body=body, idempotency_key=idempotency_key)

    def put_pipelines_diet(self, body=None, idempotency_key=None):
        """Change which log lines are kept (PUT /v1/pipelines/diet)"""
        return self._call("PUT", f"/v1/pipelines/diet", body=body, idempotency_key=idempotency_key)

    def put_projects_by_id_debug_files_native(self, id_, body=None, idempotency_key=None):
        """Send a build's native debug files (a dSYM, an unstripped library) so its native crashes read as your own code (PUT /v1/projects/{id}/debug-files/native)"""
        return self._call("PUT", f"/v1/projects/{_q(id_)}/debug-files/native", body=body, idempotency_key=idempotency_key)

    def put_projects_by_id_debug_files_proguard(self, id_, body=None, idempotency_key=None):
        """Send a build's R8 or ProGuard mapping so its Android and JVM crashes read as your own code (PUT /v1/projects/{id}/debug-files/proguard)"""
        return self._call("PUT", f"/v1/projects/{_q(id_)}/debug-files/proguard", body=body, idempotency_key=idempotency_key)

    def put_projects_by_id_sourcemaps_by_debug_id(self, id_, debug_id, body=None, idempotency_key=None):
        """Send a build's source map so its stack traces read as your own code (PUT /v1/projects/{id}/sourcemaps/{debugId})"""
        return self._call("PUT", f"/v1/projects/{_q(id_)}/sourcemaps/{_q(debug_id)}", body=body, idempotency_key=idempotency_key)

    def put_queries_by_id(self, id_, body=None, idempotency_key=None):
        """Change a saved query (PUT /v1/queries/{id})"""
        return self._call("PUT", f"/v1/queries/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def put_reviews_cadence(self, body=None, idempotency_key=None):
        """Choose how often Xovris reviews everything, or one thing (PUT /v1/reviews/cadence)"""
        return self._call("PUT", f"/v1/reviews/cadence", body=body, idempotency_key=idempotency_key)

    def put_reviews_chats(self, body=None, idempotency_key=None):
        """Connect your own Discord application or Google Chat app, so people ask Xovris there (PUT /v1/reviews/chats)"""
        return self._call("PUT", f"/v1/reviews/chats", body=body, idempotency_key=idempotency_key)

    def put_reviews_hosts(self, body=None, idempotency_key=None):
        """Connect your own GitLab, Bitbucket or Azure DevOps, so every change there is reviewed and its fixes proved (PUT /v1/reviews/hosts)"""
        return self._call("PUT", f"/v1/reviews/hosts", body=body, idempotency_key=idempotency_key)

    def put_reviews_preferences_by_id(self, id_, body=None, idempotency_key=None):
        """Change a code review preference you set (PUT /v1/reviews/preferences/{id})"""
        return self._call("PUT", f"/v1/reviews/preferences/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def put_reviews_tracker(self, body=None, idempotency_key=None):
        """Connect the workspace's own tracker - Jira, Linear, GitHub Issues, GitLab, ServiceNow, Zendesk, Asana or Azure DevOps - its token proved by one read and sealed (PUT /v1/reviews/tracker)"""
        return self._call("PUT", f"/v1/reviews/tracker", body=body, idempotency_key=idempotency_key)

    def put_roles_by_id_elevation(self, id_, body=None, idempotency_key=None):
        """Who may ask for a role for a set time, the most minutes a time may run, and whether someone must say yes (PUT /v1/roles/{id}/elevation)"""
        return self._call("PUT", f"/v1/roles/{_q(id_)}/elevation", body=body, idempotency_key=idempotency_key)

    def put_scim_v2_groups_by_id(self, id_, body=None, idempotency_key=None):
        """A provisioned team's name and the people the provider keeps in it, replaced together (PUT /v1/scim/v2/Groups/{id})"""
        return self._call("PUT", f"/v1/scim/v2/Groups/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def put_scim_v2_users_by_id(self, id_, body=None, idempotency_key=None):
        """A person replaced at the identity provider - turned off, they lose this workspace at once (PUT /v1/scim/v2/Users/{id})"""
        return self._call("PUT", f"/v1/scim/v2/Users/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def put_sentry_issues_by_org_by_id(self, org, id_, body=None, idempotency_key=None):
        """Change one Sentry issue - its status, owner or priority - from Xovris (PUT /v1/sentry/issues/{org}/{id})"""
        return self._call("PUT", f"/v1/sentry/issues/{_q(org)}/{_q(id_)}", body=body, idempotency_key=idempotency_key)

    def put_sessions_order(self, body=None, idempotency_key=None):
        """Set the order your devices are told in when a session needs you (PUT /v1/sessions/order)"""
        return self._call("PUT", f"/v1/sessions/order", body=body, idempotency_key=idempotency_key)

    def put_settings_notify_rules(self, body=None, idempotency_key=None):
        """Set who is told what, and on which channels (PUT /v1/settings/notify-rules)"""
        return self._call("PUT", f"/v1/settings/notify-rules", body=body, idempotency_key=idempotency_key)

    def put_settings_quiet_hours(self, body=None, idempotency_key=None):
        """Set your quiet hours and what a high alert does during them (PUT /v1/settings/quiet-hours)"""
        return self._call("PUT", f"/v1/settings/quiet-hours", body=body, idempotency_key=idempotency_key)

    def put_settings_sign_in(self, body=None, idempotency_key=None):
        """Require a passkey for every member, or allow other sign-ins (PUT /v1/settings/sign-in)"""
        return self._call("PUT", f"/v1/settings/sign-in", body=body, idempotency_key=idempotency_key)

    def put_settings_spend_limit(self, body=None, idempotency_key=None):
        """Set your monthly spending limit on AI fixes (PUT /v1/settings/spend-limit)"""
        return self._call("PUT", f"/v1/settings/spend-limit", body=body, idempotency_key=idempotency_key)

    def put_settings_two_person_rules_by_kind(self, kind, body=None, idempotency_key=None):
        """Set the two-person rule for a kind of change (PUT /v1/settings/two-person-rules/{kind})"""
        return self._call("PUT", f"/v1/settings/two-person-rules/{_q(kind)}", body=body, idempotency_key=idempotency_key)

    def put_status_page(self, body=None, idempotency_key=None):
        """Create or change your status page (PUT /v1/status-page)"""
        return self._call("PUT", f"/v1/status-page", body=body, idempotency_key=idempotency_key)

    def put_status_page_domain(self, body=None, idempotency_key=None):
        """Serve your status page on your own domain (PUT /v1/status-page/domain)"""
        return self._call("PUT", f"/v1/status-page/domain", body=body, idempotency_key=idempotency_key)

    def put_status_pages_by_id_access(self, id_, body=None, idempotency_key=None):
        """Who can read a status page - anyone with its address, or only the readers its password or its listed networks let in (PUT /v1/status-pages/{id}/access)"""
        return self._call("PUT", f"/v1/status-pages/{_q(id_)}/access", body=body, idempotency_key=idempotency_key)

    def put_status_pages_by_id_audiences_by_audience(self, id_, audience, body=None, idempotency_key=None):
        """An audience of a private status page changed - its name, its parts, its password or its networks; absent keeps what is saved (PUT /v1/status-pages/{id}/audiences/{audience})"""
        return self._call("PUT", f"/v1/status-pages/{_q(id_)}/audiences/{_q(audience)}", body=body, idempotency_key=idempotency_key)

    def put_status_pages_by_id_maintenance_by_maintenance(self, id_, maintenance, body=None, idempotency_key=None):
        """Planned work on a status page moved, changed, ended early ({ end: true }) or called off ({ cancel: true }) - its followers told and its held alerts moved with it (PUT /v1/status-pages/{id}/maintenance/{maintenance})"""
        return self._call("PUT", f"/v1/status-pages/{_q(id_)}/maintenance/{_q(maintenance)}", body=body, idempotency_key=idempotency_key)

    def put_systems_general_runs_memory_consent(self, body=None, idempotency_key=None):
        """Agree to Xovris remembering your corrections, or withdraw and delete them all (PUT /v1/systems/general-runs/memory/consent)"""
        return self._call("PUT", f"/v1/systems/general-runs/memory/consent", body=body, idempotency_key=idempotency_key)

    def put_teams_by_id_people_by_user_id(self, id_, user_id, body=None, idempotency_key=None):
        """A member put in a team by hand - they hold its role from their next step (PUT /v1/teams/{id}/people/{userId})"""
        return self._call("PUT", f"/v1/teams/{_q(id_)}/people/{_q(user_id)}", body=body, idempotency_key=idempotency_key)

    def put_uploads_by_id_chunks(self, id_, body=None, idempotency_key=None):
        """Send one part of a large file (PUT /v1/uploads/{id}/chunks)"""
        return self._call("PUT", f"/v1/uploads/{_q(id_)}/chunks", body=body, idempotency_key=idempotency_key)

    def put_views_by_surface(self, surface, body=None, idempotency_key=None):
        """Save a view of a page under a name, for you or for the workspace (PUT /v1/views/{surface})"""
        return self._call("PUT", f"/v1/views/{_q(surface)}", body=body, idempotency_key=idempotency_key)

    def put_watch_by_feature_setup(self, feature, body=None, idempotency_key=None):
        """Turn the app inventory or the insider risk watch on, with its assessment accepted and staff told (PUT /v1/watch/{feature}/setup)"""
        return self._call("PUT", f"/v1/watch/{_q(feature)}/setup", body=body, idempotency_key=idempotency_key)

    def put_workspace_ai_checks_model(self, body=None, idempotency_key=None):
        """Choose the model and effort Xovris's AI reviews your workspace with: Auto, or any model your plan carries (PUT /v1/workspace/ai-checks/model)"""
        return self._call("PUT", f"/v1/workspace/ai-checks/model", body=body, idempotency_key=idempotency_key)

    def put_workspace_ai_checks_schedule(self, body=None, idempotency_key=None):
        """Choose when Xovris's AI reviews your workspace: adaptive (whenever something changes) or a fixed schedule (PUT /v1/workspace/ai-checks/schedule)"""
        return self._call("PUT", f"/v1/workspace/ai-checks/schedule", body=body, idempotency_key=idempotency_key)
