// Xovris API client for Go - generated from the public OpenAPI document version 0.1.0. MIT licence, Copyright (c) 2026 Xovris.
// Usage: c, err := xovris.New("") // reads XOVRIS_API_KEY
package xovris

import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"strings"
)

// Error is a refusal from the API, with its own words and what to do next.
type Error struct {
	Status   int
	Code     string
	Message  string
	NextStep string
}

func (e *Error) Error() string { return e.Message }

// CallOptions carries an idempotency key for a request that changes something.
type CallOptions struct{ IdempotencyKey string }

// Client calls the Xovris API.
type Client struct {
	APIKey  string
	BaseURL string
	HTTP    *http.Client
}

// New makes a client; an empty key reads XOVRIS_API_KEY.
func New(apiKey string) (*Client, error) {
	if apiKey == "" {
		apiKey = os.Getenv("XOVRIS_API_KEY")
	}
	if apiKey == "" {
		return nil, errors.New("set XOVRIS_API_KEY, or pass a key - make one in Settings, Developers")
	}
	base := os.Getenv("XOVRIS_BASE_URL")
	if base == "" {
		base = "https://api.xovris.ai"
	}
	return &Client{APIKey: apiKey, BaseURL: strings.TrimRight(base, "/"), HTTP: http.DefaultClient}, nil
}

func newKey() string {
	b := make([]byte, 16)
	_, _ = rand.Read(b)
	return fmt.Sprintf("%x-%x-%x-%x-%x", b[0:4], b[4:6], b[6:8], b[8:10], b[10:])
}

func (c *Client) call(ctx context.Context, method, path string, body any, query url.Values, opts *CallOptions) (any, error) {
	u := c.BaseURL + path
	if len(query) > 0 {
		u += "?" + query.Encode()
	}
	var rd io.Reader
	if body != nil {
		b, err := json.Marshal(body)
		if err != nil {
			return nil, err
		}
		rd = bytes.NewReader(b)
	}
	req, err := http.NewRequestWithContext(ctx, method, u, rd)
	if err != nil {
		return nil, err
	}
	req.Header.Set("Authorization", "Bearer "+c.APIKey)
	req.Header.Set("Accept", "application/json")
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	if method != "GET" {
		key := newKey()
		if opts != nil && opts.IdempotencyKey != "" {
			key = opts.IdempotencyKey
		}
		req.Header.Set("Idempotency-Key", key)
	}
	res, err := c.HTTP.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	raw, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	var out any
	if len(raw) > 0 {
		if err := json.Unmarshal(raw, &out); err != nil {
			return nil, err
		}
	}
	if res.StatusCode >= 300 {
		e := &Error{Status: res.StatusCode, Message: fmt.Sprintf("The API answered %d.", res.StatusCode)}
		if m, ok := out.(map[string]any); ok {
			if inner, ok := m["error"].(map[string]any); ok {
				e.Code, _ = inner["code"].(string)
				if s, ok := inner["message"].(string); ok && s != "" {
					e.Message = s
				}
				e.NextStep, _ = inner["nextStep"].(string)
			}
		}
		return nil, e
	}
	return out, nil
}

// DeleteAccessLevelConnectionsByScope: Put one connection back on the workspace's own level of access (DELETE /v1/access/level/connections/{scope})
func (c *Client) DeleteAccessLevelConnectionsByScope(ctx context.Context, scope string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/access/level/connections/%s", url.PathEscape(scope)), body, nil, opts)
}

// DeleteAccountSessionsById: Sign one of your sessions out (DELETE /v1/account/sessions/{id})
func (c *Client) DeleteAccountSessionsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/account/sessions/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteAlertActionsByIdRulesByRuleId: Stop an alert rule calling an action (DELETE /v1/alert-actions/{id}/rules/{ruleId})
func (c *Client) DeleteAlertActionsByIdRulesByRuleId(ctx context.Context, id string, ruleId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/alert-actions/%s/rules/%s", url.PathEscape(id), url.PathEscape(ruleId)), body, nil, opts)
}

// DeleteAlertsMailServer: Alert and status email by Xovris's own path again (DELETE /v1/alerts/mail-server)
func (c *Client) DeleteAlertsMailServer(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/alerts/mail-server", body, nil, opts)
}

// DeleteAlertsSendingDomain: Alert and status email from Xovris's own address again (DELETE /v1/alerts/sending-domain)
func (c *Client) DeleteAlertsSendingDomain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/alerts/sending-domain", body, nil, opts)
}

// DeleteAssetsById: Stop watching a website, with an undo (DELETE /v1/assets/{id})
func (c *Client) DeleteAssetsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/assets/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteAssistMemoryByKey: Make Xovris forget something (DELETE /v1/assist/memory/{key})
func (c *Client) DeleteAssistMemoryByKey(ctx context.Context, key string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/assist/memory/%s", url.PathEscape(key)), body, nil, opts)
}

// DeleteAssistRequestsById: Delete a conversation for good, with a signed receipt (DELETE /v1/assist/requests/{id})
func (c *Client) DeleteAssistRequestsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/assist/requests/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteAssistRequestsByIdShare: Withdraw a conversation's share link, so it no longer opens (DELETE /v1/assist/requests/{id}/share)
func (c *Client) DeleteAssistRequestsByIdShare(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/assist/requests/%s/share", url.PathEscape(id)), body, nil, opts)
}

// DeleteBoardTilesById: Take a tile off your dashboard (DELETE /v1/board/tiles/{id})
func (c *Client) DeleteBoardTilesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/board/tiles/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteChecksByIdPromiseAlertsByAlertId: Stop one alert on a check's promise (DELETE /v1/checks/{id}/promise/alerts/{alertId})
func (c *Client) DeleteChecksByIdPromiseAlertsByAlertId(ctx context.Context, id string, alertId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/checks/%s/promise/alerts/%s", url.PathEscape(id), url.PathEscape(alertId)), body, nil, opts)
}

// DeleteChecksByIdPromiseCorrectionsByCorrectionId: Remove a correction from a check's promise, so the window counts again (DELETE /v1/checks/{id}/promise/corrections/{correctionId})
func (c *Client) DeleteChecksByIdPromiseCorrectionsByCorrectionId(ctx context.Context, id string, correctionId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/checks/%s/promise/corrections/%s", url.PathEscape(id), url.PathEscape(correctionId)), body, nil, opts)
}

// DeleteCloudConnectionsById: Disconnect a cloud account (DELETE /v1/cloud/connections/{id})
func (c *Client) DeleteCloudConnectionsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/cloud/connections/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteCodePreviewsByTokenByPath: Remove something through a build's own app while it is being made (DELETE /v1/code/previews/{token}/{path})
func (c *Client) DeleteCodePreviewsByTokenByPath(ctx context.Context, token string, path string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/previews/%s/%s", url.PathEscape(token), url.PathEscape(path)), body, nil, opts)
}

// DeleteCodeProjectsByIdAnalytics: Delete the visit figures Xovris kept for a build's site (DELETE /v1/code/projects/{id}/analytics)
func (c *Client) DeleteCodeProjectsByIdAnalytics(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/projects/%s/analytics", url.PathEscape(id)), body, nil, opts)
}

// DeleteCodeProjectsByIdDomainsByDomain: Take a build's site off one of your domains (DELETE /v1/code/projects/{id}/domains/{domain})
func (c *Client) DeleteCodeProjectsByIdDomainsByDomain(ctx context.Context, id string, domain string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/projects/%s/domains/%s", url.PathEscape(id), url.PathEscape(domain)), body, nil, opts)
}

// DeleteCodeProjectsByIdResourcesByKind: Switch off a part a build runs on, and remove what it held (DELETE /v1/code/projects/{id}/resources/{kind})
func (c *Client) DeleteCodeProjectsByIdResourcesByKind(ctx context.Context, id string, kind string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/projects/%s/resources/%s", url.PathEscape(id), url.PathEscape(kind)), body, nil, opts)
}

// DeleteCodeProjectsByIdSecretsByName: Remove a secret a build was given (DELETE /v1/code/projects/{id}/secrets/{name})
func (c *Client) DeleteCodeProjectsByIdSecretsByName(ctx context.Context, id string, name string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/projects/%s/secrets/%s", url.PathEscape(id), url.PathEscape(name)), body, nil, opts)
}

// DeleteCodeSharedByTokenPreviewByPath: Remove something through a shared build's own app (DELETE /v1/code/shared/{token}/preview/{path})
func (c *Client) DeleteCodeSharedByTokenPreviewByPath(ctx context.Context, token string, path string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/shared/%s/preview/%s", url.PathEscape(token), url.PathEscape(path)), body, nil, opts)
}

// DeleteCodeSitesByTokenByPath: Remove something through the app a build deployed (DELETE /v1/code/sites/{token}/{path})
func (c *Client) DeleteCodeSitesByTokenByPath(ctx context.Context, token string, path string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/sites/%s/%s", url.PathEscape(token), url.PathEscape(path)), body, nil, opts)
}

// DeleteCodeTasksByIdSharesByShare: Stop a build's shared link from working (DELETE /v1/code/tasks/{id}/shares/{share})
func (c *Client) DeleteCodeTasksByIdSharesByShare(ctx context.Context, id string, share string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/code/tasks/%s/shares/%s", url.PathEscape(id), url.PathEscape(share)), body, nil, opts)
}

// DeleteComputersById: End a desktop and everything on it (DELETE /v1/computers/{id})
func (c *Client) DeleteComputersById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/computers/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteComputerSchedulesById: Delete a schedule (DELETE /v1/computer/schedules/{id})
func (c *Client) DeleteComputerSchedulesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/computer/schedules/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteComputerSessionsByIdFiles: Every file the session downloaded, deleted in one press (DELETE /v1/computer/sessions/{id}/files)
func (c *Client) DeleteComputerSessionsByIdFiles(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/computer/sessions/%s/files", url.PathEscape(id)), body, nil, opts)
}

// DeleteComputerSessionsByIdReplay: 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)
func (c *Client) DeleteComputerSessionsByIdReplay(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/computer/sessions/%s/replay", url.PathEscape(id)), body, nil, opts)
}

// DeleteComputersSignIns: Forget the sign-ins Xovris's own computer kept for you - your next session starts signed out (DELETE /v1/computers/sign-ins)
func (c *Client) DeleteComputersSignIns(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/computers/sign-ins", body, nil, opts)
}

// DeleteConnectionsFigma: Unlink Figma from this workspace (DELETE /v1/connections/figma)
func (c *Client) DeleteConnectionsFigma(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/connections/figma", body, nil, opts)
}

// DeleteDashboardsById: Delete a dashboard; its address reads as not found from then on (DELETE /v1/dashboards/{id})
func (c *Client) DeleteDashboardsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/dashboards/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteDashboardsByIdPanelsByPanelIdSilence: Turn a dashboard panel's alerts back on (DELETE /v1/dashboards/{id}/panels/{panelId}/silence)
func (c *Client) DeleteDashboardsByIdPanelsByPanelIdSilence(ctx context.Context, id string, panelId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/dashboards/%s/panels/%s/silence", url.PathEscape(id), url.PathEscape(panelId)), body, nil, opts)
}

// DeleteDashboardsByIdReportsByReportId: Stop a scheduled report (DELETE /v1/dashboards/{id}/reports/{reportId})
func (c *Client) DeleteDashboardsByIdReportsByReportId(ctx context.Context, id string, reportId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/dashboards/%s/reports/%s", url.PathEscape(id), url.PathEscape(reportId)), body, nil, opts)
}

// DeleteDashboardsByIdSharesByShareId: Switch off a shared link (DELETE /v1/dashboards/{id}/shares/{shareId})
func (c *Client) DeleteDashboardsByIdSharesByShareId(ctx context.Context, id string, shareId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/dashboards/%s/shares/%s", url.PathEscape(id), url.PathEscape(shareId)), body, nil, opts)
}

// DeleteDevicesEnrolmentCodesByCode: End a device code you made and no longer want - it enrols nothing and its download stops (DELETE /v1/devices/enrolment-codes/{code})
func (c *Client) DeleteDevicesEnrolmentCodesByCode(ctx context.Context, code string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/devices/enrolment-codes/%s", url.PathEscape(code)), body, nil, opts)
}

// DeleteDevicesGroupsByGroupId: Remove a device group - the devices in it are kept (DELETE /v1/devices/groups/{groupId})
func (c *Client) DeleteDevicesGroupsByGroupId(ctx context.Context, groupId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/devices/groups/%s", url.PathEscape(groupId)), body, nil, opts)
}

// DeleteDoorsExtensionById: Unpair a browser from the Xovris extension (DELETE /v1/doors/extension/{id})
func (c *Client) DeleteDoorsExtensionById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/doors/extension/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteExtensionsAppsByAppId: Remove an app (DELETE /v1/extensions/apps/{appId})
func (c *Client) DeleteExtensionsAppsByAppId(ctx context.Context, appId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/extensions/apps/%s", url.PathEscape(appId)), body, nil, opts)
}

// DeleteFailoverTargetsById: Remove a standby target (DELETE /v1/failover-targets/{id})
func (c *Client) DeleteFailoverTargetsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/failover-targets/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteGrantsById: Take back one standing permission - Xovris stops using it at once (DELETE /v1/grants/{id})
func (c *Client) DeleteGrantsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/grants/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteHelperWebsiteConversationsById: Delete a conversation carried from the website (DELETE /v1/helper/website-conversations/{id})
func (c *Client) DeleteHelperWebsiteConversationsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/helper/website-conversations/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteHomeNetworkKnownByDevice: Watch a device you had marked as yours again (DELETE /v1/home-network/known/{device})
func (c *Client) DeleteHomeNetworkKnownByDevice(ctx context.Context, device string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/home-network/known/%s", url.PathEscape(device)), body, nil, opts)
}

// DeleteIncidentsByIdAck: Take back an acknowledgement (DELETE /v1/incidents/{id}/ack)
func (c *Client) DeleteIncidentsByIdAck(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/ack", url.PathEscape(id)), body, nil, opts)
}

// DeleteIncidentsByIdMerge: Undo a merge (DELETE /v1/incidents/{id}/merge)
func (c *Client) DeleteIncidentsByIdMerge(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/merge", url.PathEscape(id)), body, nil, opts)
}

// DeleteIncidentsByIdMute: Send an incident's messages again (DELETE /v1/incidents/{id}/mute)
func (c *Client) DeleteIncidentsByIdMute(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/mute", url.PathEscape(id)), body, nil, opts)
}

// DeleteIncidentsByIdPin: Take your pin off an incident (DELETE /v1/incidents/{id}/pin)
func (c *Client) DeleteIncidentsByIdPin(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/pin", url.PathEscape(id)), body, nil, opts)
}

// DeleteIncidentsByIdSnooze: Wake a snoozed incident (DELETE /v1/incidents/{id}/snooze)
func (c *Client) DeleteIncidentsByIdSnooze(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/snooze", url.PathEscape(id)), body, nil, opts)
}

// DeleteIncidentsByIdStakeholdersByKey: Stop telling someone about an incident (DELETE /v1/incidents/{id}/stakeholders/{key})
func (c *Client) DeleteIncidentsByIdStakeholdersByKey(ctx context.Context, id string, key string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/stakeholders/%s", url.PathEscape(id), url.PathEscape(key)), body, nil, opts)
}

// DeleteIncidentsByIdWatch: Stop watching an incident (DELETE /v1/incidents/{id}/watch)
func (c *Client) DeleteIncidentsByIdWatch(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/incidents/%s/watch", url.PathEscape(id)), body, nil, opts)
}

// DeleteIssuesByIdAsk: Withdraw a question asked on an issue, so it returns to the queue (DELETE /v1/issues/{id}/ask)
func (c *Client) DeleteIssuesByIdAsk(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/issues/%s/ask", url.PathEscape(id)), body, nil, opts)
}

// DeleteLogConnectionsById: Remove a log source, with what Xovris made at the provider deleted first (DELETE /v1/log-connections/{id})
func (c *Client) DeleteLogConnectionsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/log-connections/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteMcp: End an MCP session (DELETE /v1/mcp)
func (c *Client) DeleteMcp(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/mcp", body, nil, opts)
}

// DeleteMembersByUserId: Remove a member (DELETE /v1/members/{userId})
func (c *Client) DeleteMembersByUserId(ctx context.Context, userId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/members/%s", url.PathEscape(userId)), body, nil, opts)
}

// DeleteMembersInvitationsById: Withdraw an open invitation before it is accepted (DELETE /v1/members/invitations/{id})
func (c *Client) DeleteMembersInvitationsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/members/invitations/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteModelsOwn: Remove your own model; Xovris plans code fixes on its own models again (DELETE /v1/models/own)
func (c *Client) DeleteModelsOwn(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/models/own", body, nil, opts)
}

// DeleteOauthAppsById: Retire an OAuth app everywhere it is allowed (DELETE /v1/oauth/apps/{id})
func (c *Client) DeleteOauthAppsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/oauth/apps/%s", url.PathEscape(id)), body, nil, opts)
}

// DeletePartnersSandboxKeysById: Revoke a provisioning sandbox key (DELETE /v1/partners/sandbox-keys/{id})
func (c *Client) DeletePartnersSandboxKeysById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/partners/sandbox-keys/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteQueriesById: Remove a saved query (DELETE /v1/queries/{id})
func (c *Client) DeleteQueriesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/queries/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteReviewsChatsById: Disconnect a Discord or Google Chat app (DELETE /v1/reviews/chats/{id})
func (c *Client) DeleteReviewsChatsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/reviews/chats/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteReviewsHostsById: Disconnect a Git host, with Xovris's webhooks taken off it (DELETE /v1/reviews/hosts/{id})
func (c *Client) DeleteReviewsHostsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/reviews/hosts/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteReviewsPreferencesById: Delete a code review preference you set (DELETE /v1/reviews/preferences/{id})
func (c *Client) DeleteReviewsPreferencesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/reviews/preferences/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteReviewsSchedulesById: Remove a scheduled coding automation; nothing more is started by it (DELETE /v1/reviews/schedules/{id})
func (c *Client) DeleteReviewsSchedulesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/reviews/schedules/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteReviewsTracker: Disconnect the workspace's tracker; its sealed token is deleted (DELETE /v1/reviews/tracker)
func (c *Client) DeleteReviewsTracker(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/reviews/tracker", body, nil, opts)
}

// DeleteReviewsViewsById: Delete a view of the code review findings you saved (DELETE /v1/reviews/views/{id})
func (c *Client) DeleteReviewsViewsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/reviews/views/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteRoleGrantsById: Take back a role given over one thing - it leaves on the person's next step (DELETE /v1/role-grants/{id})
func (c *Client) DeleteRoleGrantsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/role-grants/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteRolesById: Delete a custom role, kept among the deleted roles so it can be restored (DELETE /v1/roles/{id})
func (c *Client) DeleteRolesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/roles/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteRumExternalById: Remove a replay tool connection (DELETE /v1/rum/external/{id})
func (c *Client) DeleteRumExternalById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/rum/external/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteScimV2GroupsById: 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})
func (c *Client) DeleteScimV2GroupsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/scim/v2/Groups/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteScimV2UsersById: A person deleted at the identity provider loses this workspace at once (DELETE /v1/scim/v2/Users/{id})
func (c *Client) DeleteScimV2UsersById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/scim/v2/Users/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSearchesById: Delete a saved search (DELETE /v1/searches/{id})
func (c *Client) DeleteSearchesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/searches/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSecurityPostureFixesByIdState: 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)
func (c *Client) DeleteSecurityPostureFixesByIdState(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/security/posture/fixes/%s/state", url.PathEscape(id)), body, nil, opts)
}

// DeleteSecurityStackConnectionsById: Disconnect a security tool (DELETE /v1/security-stack/connections/{id})
func (c *Client) DeleteSecurityStackConnectionsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/security-stack/connections/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSessionsActivitiesByToken: Stop following a session on the lock screen (DELETE /v1/sessions/activities/{token})
func (c *Client) DeleteSessionsActivitiesByToken(ctx context.Context, token string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/sessions/activities/%s", url.PathEscape(token)), body, nil, opts)
}

// DeleteSessionsDevicesById: Remove a device from following your sessions (DELETE /v1/sessions/devices/{id})
func (c *Client) DeleteSessionsDevicesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/sessions/devices/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSettingsBusyPeriodsById: Remove a busy period (DELETE /v1/settings/busy-periods/{id})
func (c *Client) DeleteSettingsBusyPeriodsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/settings/busy-periods/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSettingsCalendarsById: Disconnect a calendar (DELETE /v1/settings/calendars/{id})
func (c *Client) DeleteSettingsCalendarsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/settings/calendars/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSettingsChangeWindowsById: Remove a maintenance window or freeze (DELETE /v1/settings/change-windows/{id})
func (c *Client) DeleteSettingsChangeWindowsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/settings/change-windows/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSetupGrantsById: Revoke a standing permission (DELETE /v1/setup/grants/{id})
func (c *Client) DeleteSetupGrantsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/setup/grants/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSetupTakeoversByIdEvidence: Delete the recordings of a set-up (DELETE /v1/setup/takeovers/{id}/evidence)
func (c *Client) DeleteSetupTakeoversByIdEvidence(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/setup/takeovers/%s/evidence", url.PathEscape(id)), body, nil, opts)
}

// DeleteSsoProvidersByProviderId: Remove a company sign-in - nobody signs in through it again (DELETE /v1/sso/providers/{providerId})
func (c *Client) DeleteSsoProvidersByProviderId(ctx context.Context, providerId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/sso/providers/%s", url.PathEscape(providerId)), body, nil, opts)
}

// DeleteStatusPageDomain: Take your status page off your own domain (DELETE /v1/status-page/domain)
func (c *Client) DeleteStatusPageDomain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/status-page/domain", body, nil, opts)
}

// DeleteStatusPagesById: 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})
func (c *Client) DeleteStatusPagesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/status-pages/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteStatusPagesByIdAudiencesByAudience: 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})
func (c *Client) DeleteStatusPagesByIdAudiencesByAudience(ctx context.Context, id string, audience string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/status-pages/%s/audiences/%s", url.PathEscape(id), url.PathEscape(audience)), body, nil, opts)
}

// DeleteSystemsById: Disconnect one system - every reading of it stops at once (DELETE /v1/systems/{id})
func (c *Client) DeleteSystemsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/systems/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSystemsGeneralRunsJobsByJobRecord: 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)
func (c *Client) DeleteSystemsGeneralRunsJobsByJobRecord(ctx context.Context, job string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/systems/general-runs/jobs/%s/record", url.PathEscape(job)), body, nil, opts)
}

// DeleteSystemsGeneralRunsJobsRecord: Forget what every job Xovris did kept about why it acted and how it went about it (DELETE /v1/systems/general-runs/jobs/record)
func (c *Client) DeleteSystemsGeneralRunsJobsRecord(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/systems/general-runs/jobs/record", body, nil, opts)
}

// DeleteSystemsGeneralRunsLearned: Forget what Xovris learned from past jobs on your systems (DELETE /v1/systems/general-runs/learned)
func (c *Client) DeleteSystemsGeneralRunsLearned(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", "/v1/systems/general-runs/learned", body, nil, opts)
}

// DeleteSystemsGeneralRunsLearnedById: Forget one plan Xovris learned on your systems (DELETE /v1/systems/general-runs/learned/{id})
func (c *Client) DeleteSystemsGeneralRunsLearnedById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/systems/general-runs/learned/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSystemsGeneralRunsMemoryRulesById: Delete one rule Xovris kept from your corrections (DELETE /v1/systems/general-runs/memory/rules/{id})
func (c *Client) DeleteSystemsGeneralRunsMemoryRulesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/systems/general-runs/memory/rules/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteSystemsGeneralRunsSchedulesById: Stop a check Xovris runs for you (DELETE /v1/systems/general-runs/schedules/{id})
func (c *Client) DeleteSystemsGeneralRunsSchedulesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/systems/general-runs/schedules/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteTeamsById: Delete a team - its people lose its role on their next step (DELETE /v1/teams/{id})
func (c *Client) DeleteTeamsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/teams/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteTeamsByIdPeopleByUserId: Take a member off a team - its role leaves them on their next step (DELETE /v1/teams/{id}/people/{userId})
func (c *Client) DeleteTeamsByIdPeopleByUserId(ctx context.Context, id string, userId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/teams/%s/people/%s", url.PathEscape(id), url.PathEscape(userId)), body, nil, opts)
}

// DeleteThingsById: Have Xovris forget a thing (DELETE /v1/things/{id})
func (c *Client) DeleteThingsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/things/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteTokensById: Revoke an API token (DELETE /v1/tokens/{id})
func (c *Client) DeleteTokensById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/tokens/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteToolConnectionsById: Disconnect a tool (DELETE /v1/tool-connections/{id})
func (c *Client) DeleteToolConnectionsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/tool-connections/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteToolServersById: Disconnect an AI tool server (DELETE /v1/tool-servers/{id})
func (c *Client) DeleteToolServersById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/tool-servers/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteUploadsById: Stop a large file's upload and remove what arrived (DELETE /v1/uploads/{id})
func (c *Client) DeleteUploadsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/uploads/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteVendorFixesById: Withdraw a fix you sent that is not yet proven (DELETE /v1/vendor-fixes/{id})
func (c *Client) DeleteVendorFixesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/vendor-fixes/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteViewsBySurfaceById: Remove a saved view (DELETE /v1/views/{surface}/{id})
func (c *Client) DeleteViewsBySurfaceById(ctx context.Context, surface string, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/views/%s/%s", url.PathEscape(surface), url.PathEscape(id)), body, nil, opts)
}

// DeleteWebhooksById: Remove a webhook (DELETE /v1/webhooks/{id})
func (c *Client) DeleteWebhooksById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/webhooks/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteWhatIfById: Delete a what-if report; the copy it ran on was already deleted (DELETE /v1/what-if/{id})
func (c *Client) DeleteWhatIfById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/what-if/%s", url.PathEscape(id)), body, nil, opts)
}

// DeleteWorkspaceDomainsByHostname: Stop serving one of your own domains from this workspace (DELETE /v1/workspace/domains/{hostname})
func (c *Client) DeleteWorkspaceDomainsByHostname(ctx context.Context, hostname string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "DELETE", fmt.Sprintf("/v1/workspace/domains/%s", url.PathEscape(hostname)), body, nil, opts)
}

// GetAccessLevel: Read how far Xovris may act on each connection - from observe only to acting by itself (GET /v1/access/level)
func (c *Client) GetAccessLevel(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/access/level", nil, query, nil)
}

// GetAccessMap: Read who can reach what (GET /v1/access/map)
func (c *Client) GetAccessMap(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/access/map", nil, query, nil)
}

// GetAccessPreview: 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)
func (c *Client) GetAccessPreview(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/access/preview", nil, query, nil)
}

// GetAccessReview: 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)
func (c *Client) GetAccessReview(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/access/review", nil, query, nil)
}

// GetAccountPasskeys: See the passkeys that can sign in to your account (GET /v1/account/passkeys)
func (c *Client) GetAccountPasskeys(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/account/passkeys", nil, query, nil)
}

// GetAccountSessions: See every place your account is signed in (GET /v1/account/sessions)
func (c *Client) GetAccountSessions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/account/sessions", nil, query, nil)
}

// GetActions: List what Xovris did and why (GET /v1/actions)
func (c *Client) GetActions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/actions", nil, query, nil)
}

// GetActionsBySeqReceipt: Take the proof receipt of one change or undo, with the checks anyone can run on it without Xovris (GET /v1/actions/{seq}/receipt)
func (c *Client) GetActionsBySeqReceipt(ctx context.Context, seq string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/actions/%s/receipt", url.PathEscape(seq)), nil, query, nil)
}

// GetActionsUndosById: Read where an undo is and what it found (GET /v1/actions/undos/{id})
func (c *Client) GetActionsUndosById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/actions/undos/%s", url.PathEscape(id)), nil, query, nil)
}

// GetActionsUndoWindow: See what undoing back to a moment would put back, before anything is undone (GET /v1/actions/undo-window)
func (c *Client) GetActionsUndoWindow(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/actions/undo-window", nil, query, nil)
}

// GetActionsVerify: Verify the record of what Xovris did has not been altered (GET /v1/actions/verify)
func (c *Client) GetActionsVerify(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/actions/verify", nil, query, nil)
}

// GetAiChoices: List the AI models and efforts an ask can be given, from the live catalogue (GET /v1/ai/choices)
func (c *Client) GetAiChoices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/ai/choices", nil, query, nil)
}

// GetAlertActions: List the actions your alerts can call (GET /v1/alert-actions)
func (c *Client) GetAlertActions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alert-actions", nil, query, nil)
}

// GetAlertActionsByIdRules: List the alert rules that call an action (GET /v1/alert-actions/{id}/rules)
func (c *Client) GetAlertActionsByIdRules(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/alert-actions/%s/rules", url.PathEscape(id)), nil, query, nil)
}

// GetAlerts: List the alerts raised in your workspace (GET /v1/alerts)
func (c *Client) GetAlerts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts", nil, query, nil)
}

// GetAlertsChannelFacts: List the channels Xovris reaches people through on this server, each live because its door is configured (GET /v1/alerts/channel-facts)
func (c *Client) GetAlertsChannelFacts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/channel-facts", nil, query, nil)
}

// GetAlertsChannelsDiscordCallback: Finish adding a Discord channel after Discord's own approval (GET /v1/alerts/channels/discord/callback)
func (c *Client) GetAlertsChannelsDiscordCallback(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/channels/discord/callback", nil, query, nil)
}

// GetAlertsChannelsPagerdutyCallback: 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)
func (c *Client) GetAlertsChannelsPagerdutyCallback(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/channels/pagerduty/callback", nil, query, nil)
}

// GetAlertsDelivery: See where each alert went and whether it arrived (GET /v1/alerts/delivery)
func (c *Client) GetAlertsDelivery(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/delivery", nil, query, nil)
}

// GetAlertsLimitPoints: Read the points at which you hear about AI spend, and the rule for shared channels (GET /v1/alerts/limit-points)
func (c *Client) GetAlertsLimitPoints(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/limit-points", nil, query, nil)
}

// GetAlertsMailServer: The workspace's own mail server and what it last answered (GET /v1/alerts/mail-server)
func (c *Client) GetAlertsMailServer(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/mail-server", nil, query, nil)
}

// GetAlertsPhrase: Read your own alert phrase and your workspace's (GET /v1/alerts/phrase)
func (c *Client) GetAlertsPhrase(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/phrase", nil, query, nil)
}

// GetAlertsPushKey: Read the key a device subscribes to push alerts with (GET /v1/alerts/push/key)
func (c *Client) GetAlertsPushKey(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/push/key", nil, query, nil)
}

// GetAlertsReach: See who a failure of one thing would reach now, and how (GET /v1/alerts/reach)
func (c *Client) GetAlertsReach(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/reach", nil, query, nil)
}

// GetAlertsRules: List your alert rules (GET /v1/alerts/rules)
func (c *Client) GetAlertsRules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/rules", nil, query, nil)
}

// GetAlertsSendingDomain: The workspace's own sending domain and each record read from outside (GET /v1/alerts/sending-domain)
func (c *Client) GetAlertsSendingDomain(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/sending-domain", nil, query, nil)
}

// GetAlertsStatusPageDoor: Read the status page Xovris posts updates to (GET /v1/alerts/status-page-door)
func (c *Client) GetAlertsStatusPageDoor(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/status-page-door", nil, query, nil)
}

// GetAlertsTuning: See the changes Xovris proposes to make your alerts quieter and sharper (GET /v1/alerts/tuning)
func (c *Client) GetAlertsTuning(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/tuning", nil, query, nil)
}

// GetAlertsUnsubscribe: The page that stops alerts to an address (GET /v1/alerts/unsubscribe)
func (c *Client) GetAlertsUnsubscribe(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/alerts/unsubscribe", nil, query, nil)
}

// GetApiAlertsDelivery: Read how alert delivery is doing across every channel (GET /api/alerts/delivery)
func (c *Client) GetApiAlertsDelivery(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/api/alerts/delivery", nil, query, nil)
}

// GetApiAlertsHealth: Read the health of the alerting service (GET /api/alerts/health)
func (c *Client) GetApiAlertsHealth(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/api/alerts/health", nil, query, nil)
}

// GetApiByProjectIdChunkUploadIndex: Read how a large file should be sent in parts: the part size and where each one goes (GET /api/{projectId}/chunk-upload/)
func (c *Client) GetApiByProjectIdChunkUploadIndex(ctx context.Context, projectId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/api/%s/chunk-upload/", url.PathEscape(projectId)), nil, query, nil)
}

// GetApiWatch: Read the changes found in the APIs you depend on (GET /v1/api-watch)
func (c *Client) GetApiWatch(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/api-watch", nil, query, nil)
}

// GetAppsWatch: Read the app store and crash watch (GET /v1/apps/watch)
func (c *Client) GetAppsWatch(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/apps/watch", nil, query, nil)
}

// GetAssetsByIdFirstLook: Read the first look at a website (GET /v1/assets/{id}/first-look)
func (c *Client) GetAssetsByIdFirstLook(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assets/%s/first-look", url.PathEscape(id)), nil, query, nil)
}

// GetAssetsByIdSiteQuality: Read a website's quality report (GET /v1/assets/{id}/site-quality)
func (c *Client) GetAssetsByIdSiteQuality(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assets/%s/site-quality", url.PathEscape(id)), nil, query, nil)
}

// GetAssetsGraph: Read what Xovris believed about your assets at a moment, and what was true then (GET /v1/assets/graph)
func (c *Client) GetAssetsGraph(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assets/graph", nil, query, nil)
}

// GetAssetStories: Read the story of each thing you own (GET /v1/asset-stories)
func (c *Client) GetAssetStories(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/asset-stories", nil, query, nil)
}

// GetAssetStoriesExport: Export the story of each thing you own (GET /v1/asset-stories/export)
func (c *Client) GetAssetStoriesExport(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/asset-stories/export", nil, query, nil)
}

// GetAssistCobrowse: List your past shared-tab help sessions (GET /v1/assist/cobrowse)
func (c *Client) GetAssistCobrowse(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/cobrowse", nil, query, nil)
}

// GetAssistCobrowseById: Read a shared tab's full record (GET /v1/assist/cobrowse/{id})
func (c *Client) GetAssistCobrowseById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assist/cobrowse/%s", url.PathEscape(id)), nil, query, nil)
}

// GetAssistCobrowseGuides: List the guides Xovris can walk you through in a shared tab (GET /v1/assist/cobrowse/guides)
func (c *Client) GetAssistCobrowseGuides(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/cobrowse/guides", nil, query, nil)
}

// GetAssistCompletion: See how many requests Xovris finished end to end, by kind (GET /v1/assist/completion)
func (c *Client) GetAssistCompletion(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/completion", nil, query, nil)
}

// GetAssistExecutionShare: See, for each kind of request, how much Xovris finished itself with a receipt (GET /v1/assist/execution-share)
func (c *Client) GetAssistExecutionShare(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/execution-share", nil, query, nil)
}

// GetAssistMemory: Read what Xovris remembers about you (GET /v1/assist/memory)
func (c *Client) GetAssistMemory(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/memory", nil, query, nil)
}

// GetAssistModels: List every AI model the Ask can answer on, with its maker and what it costs (GET /v1/assist/models)
func (c *Client) GetAssistModels(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/models", nil, query, nil)
}

// GetAssistNow: See everything Xovris is carrying on by itself right now, with its next step and when it looks again (GET /v1/assist/now)
func (c *Client) GetAssistNow(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/now", nil, query, nil)
}

// GetAssistProjects: List your projects with how many conversations each holds (GET /v1/assist/projects)
func (c *Client) GetAssistProjects(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/projects", nil, query, nil)
}

// GetAssistRequests: List your requests to Xovris (GET /v1/assist/requests)
func (c *Client) GetAssistRequests(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/requests", nil, query, nil)
}

// GetAssistRequestsById: Read a request and its steps (GET /v1/assist/requests/{id})
func (c *Client) GetAssistRequestsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assist/requests/%s", url.PathEscape(id)), nil, query, nil)
}

// GetAssistRequestsByIdPicturesBySlot: Read a picture sent with a request (GET /v1/assist/requests/{id}/pictures/{slot})
func (c *Client) GetAssistRequestsByIdPicturesBySlot(ctx context.Context, id string, slot string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assist/requests/%s/pictures/%s", url.PathEscape(id), url.PathEscape(slot)), nil, query, nil)
}

// GetAssistRequestsByIdReport: Read the report of one request: what was read, tried and proved (GET /v1/assist/requests/{id}/report)
func (c *Client) GetAssistRequestsByIdReport(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assist/requests/%s/report", url.PathEscape(id)), nil, query, nil)
}

// GetAssistRequestsByIdShare: See whether a conversation has a share link, and how many times it was opened (GET /v1/assist/requests/{id}/share)
func (c *Client) GetAssistRequestsByIdShare(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/assist/requests/%s/share", url.PathEscape(id)), nil, query, nil)
}

// GetAssistShares: List every share link of yours that still opens, with its views, to withdraw any of them (GET /v1/assist/shares)
func (c *Client) GetAssistShares(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/assist/shares", nil, query, nil)
}

// GetAudit: Read who changed what in this workspace (GET /v1/audit)
func (c *Client) GetAudit(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/audit", nil, query, nil)
}

// GetAuthMethods: List the ways to sign in (GET /v1/auth/methods)
func (c *Client) GetAuthMethods(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/auth/methods", nil, query, nil)
}

// GetAutomation: Read the grants, standing permissions, kill switches and approvals in force (GET /v1/automation)
func (c *Client) GetAutomation(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/automation", nil, query, nil)
}

// GetAutomationRules: Read each automation rule's runs, rates and median time over a range (GET /v1/automation/rules)
func (c *Client) GetAutomationRules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/automation/rules", nil, query, nil)
}

// GetAutonomyApprovalChain: Read who Xovris asks next, in order, when the person who asked has not answered (GET /v1/autonomy/approval-chain)
func (c *Client) GetAutonomyApprovalChain(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/approval-chain", nil, query, nil)
}

// GetAutonomyAskBudget: See every journey's asks against its floor of approve and sign in (GET /v1/autonomy/ask-budget)
func (c *Client) GetAutonomyAskBudget(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/ask-budget", nil, query, nil)
}

// GetAutonomyDigest: Read what Xovris did for you on a day, each with its undo (GET /v1/autonomy/digest)
func (c *Client) GetAutonomyDigest(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/digest", nil, query, nil)
}

// GetAutonomyDoors: See each browser door's nightly rehearsal and any door held after a break (GET /v1/autonomy/doors)
func (c *Client) GetAutonomyDoors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/doors", nil, query, nil)
}

// GetAutonomyFacts: See the facts Xovris remembers for this workspace, so it never asks twice (GET /v1/autonomy/facts)
func (c *Client) GetAutonomyFacts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/facts", nil, query, nil)
}

// GetAutonomyGoals: See every plan you asked for in one sentence, and where it stands (GET /v1/autonomy/goals)
func (c *Client) GetAutonomyGoals(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/goals", nil, query, nil)
}

// GetAutonomyGrantsUse: See every grant against the scopes Xovris actually needs (GET /v1/autonomy/grants/use)
func (c *Client) GetAutonomyGrantsUse(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/grants/use", nil, query, nil)
}

// GetAutonomyGuide: 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)
func (c *Client) GetAutonomyGuide(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/guide", nil, query, nil)
}

// GetAutonomyGuides: List every guide made from the plan Xovris's own browser runs (GET /v1/autonomy/guides)
func (c *Client) GetAutonomyGuides(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/guides", nil, query, nil)
}

// GetAutonomyGuidesByIntegration: Read one guide: Do this for me first, with Do it yourself instead beneath it (GET /v1/autonomy/guides/{integration})
func (c *Client) GetAutonomyGuidesByIntegration(ctx context.Context, integration string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/autonomy/guides/%s", url.PathEscape(integration)), nil, query, nil)
}

// GetAutonomyImmunity: See how Xovris protects you from vendor breaks other customers met first (GET /v1/autonomy/immunity)
func (c *Client) GetAutonomyImmunity(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/immunity", nil, query, nil)
}

// GetAutonomyMe: See how Xovris works with you, read from what you do (GET /v1/autonomy/me)
func (c *Client) GetAutonomyMe(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/me", nil, query, nil)
}

// GetAutonomyPeople: See every joiner and leaver Xovris is handling (GET /v1/autonomy/people)
func (c *Client) GetAutonomyPeople(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/people", nil, query, nil)
}

// GetAutonomyRecord: 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)
func (c *Client) GetAutonomyRecord(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/record", nil, query, nil)
}

// GetAutonomyRenewals: See every certificate and domain Xovris renews before it ends (GET /v1/autonomy/renewals)
func (c *Client) GetAutonomyRenewals(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/renewals", nil, query, nil)
}

// GetAutonomySitting: See every yes Xovris waits for, in the order that unblocks the most (GET /v1/autonomy/sitting)
func (c *Client) GetAutonomySitting(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/sitting", nil, query, nil)
}

// GetAutonomySpend: See unused seats and licences, and every cut Xovris made with its undo (GET /v1/autonomy/spend)
func (c *Client) GetAutonomySpend(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/spend", nil, query, nil)
}

// GetAutonomyStack: See the tools found from your domain against the tools you connected (GET /v1/autonomy/stack)
func (c *Client) GetAutonomyStack(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/stack", nil, query, nil)
}

// GetAutonomyTapByCode: Download the signed device app named for its enrolment code, in one tap (GET /v1/autonomy/tap/{code})
func (c *Client) GetAutonomyTapByCode(ctx context.Context, code string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/autonomy/tap/%s", url.PathEscape(code)), nil, query, nil)
}

// GetAutonomyUndoCoverage: See how much of what Xovris did by itself can be undone with one press (GET /v1/autonomy/undo-coverage)
func (c *Client) GetAutonomyUndoCoverage(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/undo-coverage", nil, query, nil)
}

// GetAutonomyVendorCases: See every vendor case Xovris is chasing for you (GET /v1/autonomy/vendor-cases)
func (c *Client) GetAutonomyVendorCases(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/vendor-cases", nil, query, nil)
}

// GetAutonomyVendorCasesById: Read one vendor case with every step Xovris took (GET /v1/autonomy/vendor-cases/{id})
func (c *Client) GetAutonomyVendorCasesById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/autonomy/vendor-cases/%s", url.PathEscape(id)), nil, query, nil)
}

// GetAutonomyWatches: See everything Xovris is waiting on you for, and how long each has waited (GET /v1/autonomy/watches)
func (c *Client) GetAutonomyWatches(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/autonomy/watches", nil, query, nil)
}

// GetAutonomyWatchesById: Read one thing Xovris is waiting on you for, and what it does the moment it has it (GET /v1/autonomy/watches/{id})
func (c *Client) GetAutonomyWatchesById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/autonomy/watches/%s", url.PathEscape(id)), nil, query, nil)
}

// GetBackupsFound: See the backups Xovris found (GET /v1/backups/found)
func (c *Client) GetBackupsFound(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/backups/found", nil, query, nil)
}

// GetBackupsJobs: See every backup job Xovris knows, its runs and what Xovris fixed on it (GET /v1/backups/jobs)
func (c *Client) GetBackupsJobs(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/backups/jobs", nil, query, nil)
}

// GetBackupsPlan: See the backup plan Xovris proposes for your systems (GET /v1/backups/plan)
func (c *Client) GetBackupsPlan(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/backups/plan", nil, query, nil)
}

// GetBadges: List your badges (GET /v1/badges)
func (c *Client) GetBadges(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/badges", nil, query, nil)
}

// GetBoard: Your own dashboard: every tile you pinned from an answer, with its place on the grid (GET /v1/board)
func (c *Client) GetBoard(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/board", nil, query, nil)
}

// GetBoardTilesByIdRead: Draw a tile again from its own read, now (GET /v1/board/tiles/{id}/read)
func (c *Client) GetBoardTilesByIdRead(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/board/tiles/%s/read", url.PathEscape(id)), nil, query, nil)
}

// GetBreachNotices: Read every notice of a breach of Xovris itself that touched this workspace's data (GET /v1/breach-notices)
func (c *Client) GetBreachNotices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/breach-notices", nil, query, nil)
}

// GetBuildsSize: Read how each build's size changed and why (GET /v1/builds/size)
func (c *Client) GetBuildsSize(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/builds/size", nil, query, nil)
}

// GetCapacity: Read how many investigations your plan runs at once, its reserved slots for critical incidents, and what is running now (GET /v1/capacity)
func (c *Client) GetCapacity(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/capacity", nil, query, nil)
}

// GetCarryOn: See what Xovris is still carrying on with, and the next step of each (GET /v1/carry-on)
func (c *Client) GetCarryOn(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/carry-on", nil, query, nil)
}

// GetChangesBefore: List what changed before a moment (GET /v1/changes/before)
func (c *Client) GetChangesBefore(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/changes/before", nil, query, nil)
}

// GetChecks: List checks (GET /v1/checks)
func (c *Client) GetChecks(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks", nil, query, nil)
}

// GetChecksAdded: List the checks added in Xovris, with their latest results (GET /v1/checks/added)
func (c *Client) GetChecksAdded(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks/added", nil, query, nil)
}

// GetChecksByIdPhases: 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)
func (c *Client) GetChecksByIdPhases(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/checks/%s/phases", url.PathEscape(id)), nil, query, nil)
}

// GetChecksByIdPromise: Read a check's promise and its error budget (GET /v1/checks/{id}/promise)
func (c *Client) GetChecksByIdPromise(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/checks/%s/promise", url.PathEscape(id)), nil, query, nil)
}

// GetChecksByIdRuns: See every run a check stored in the last hours, per place, with its response time (GET /v1/checks/{id}/runs)
func (c *Client) GetChecksByIdRuns(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/checks/%s/runs", url.PathEscape(id)), nil, query, nil)
}

// GetChecksByIdTeardowns: Read what a check cleaned up after itself (GET /v1/checks/{id}/teardowns)
func (c *Client) GetChecksByIdTeardowns(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/checks/%s/teardowns", url.PathEscape(id)), nil, query, nil)
}

// GetChecksByIdTimeline: Read a check's results over time (GET /v1/checks/{id}/timeline)
func (c *Client) GetChecksByIdTimeline(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/checks/%s/timeline", url.PathEscape(id)), nil, query, nil)
}

// GetChecksByIdVersions: List a check's versions (GET /v1/checks/{id}/versions)
func (c *Client) GetChecksByIdVersions(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/checks/%s/versions", url.PathEscape(id)), nil, query, nil)
}

// GetChecksMetrics: 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)
func (c *Client) GetChecksMetrics(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks/metrics", nil, query, nil)
}

// GetChecksPromises: 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)
func (c *Client) GetChecksPromises(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks/promises", nil, query, nil)
}

// GetChecksSecrets: List the secrets checks use (GET /v1/checks/secrets)
func (c *Client) GetChecksSecrets(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks/secrets", nil, query, nil)
}

// GetChecksTimings: 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)
func (c *Client) GetChecksTimings(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks/timings", nil, query, nil)
}

// GetChecksUptime: Read every check's days as one strip: the share of each day it was up, from its own results (GET /v1/checks/uptime)
func (c *Client) GetChecksUptime(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/checks/uptime", nil, query, nil)
}

// GetChoicesModels: List the AI models you can choose from, with what each one costs (GET /v1/choices/models)
func (c *Client) GetChoicesModels(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/choices/models", nil, query, nil)
}

// GetCloudAzureTemplateByOidByFile: The one-press Azure grant template, filled in for your workspace, that the Azure portal fetches (GET /v1/cloud/azure/template/{oid}/{file})
func (c *Client) GetCloudAzureTemplateByOidByFile(ctx context.Context, oid string, file string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/cloud/azure/template/%s/%s", url.PathEscape(oid), url.PathEscape(file)), nil, query, nil)
}

// GetCloudConnections: List your cloud accounts and how far each connection has got (GET /v1/cloud/connections)
func (c *Client) GetCloudConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/cloud/connections", nil, query, nil)
}

// GetCloudConnectionsByIdBillRegionsGrant: Get the one approval link that lets an older AWS connection read its bill by region (GET /v1/cloud/connections/{id}/bill/regions/grant)
func (c *Client) GetCloudConnectionsByIdBillRegionsGrant(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/cloud/connections/%s/bill/regions/grant", url.PathEscape(id)), nil, query, nil)
}

// GetCloudConnectionsByIdInventory: See everything a connected cloud account holds - every resource its own inventory reports, by type (GET /v1/cloud/connections/{id}/inventory)
func (c *Client) GetCloudConnectionsByIdInventory(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/cloud/connections/%s/inventory", url.PathEscape(id)), nil, query, nil)
}

// GetCloudPermissions: See the exact permissions Xovris asks for on each cloud before it connects to it (GET /v1/cloud/permissions)
func (c *Client) GetCloudPermissions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/cloud/permissions", nil, query, nil)
}

// GetCodePreviewsByToken: Open the live preview of a build while it is being made (GET /v1/code/previews/{token})
func (c *Client) GetCodePreviewsByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/previews/%s", url.PathEscape(token)), nil, query, nil)
}

// GetCodePreviewsByTokenByPath: Open one file of a build's live preview (GET /v1/code/previews/{token}/{path})
func (c *Client) GetCodePreviewsByTokenByPath(ctx context.Context, token string, path string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/previews/%s/%s", url.PathEscape(token), url.PathEscape(path)), nil, query, nil)
}

// GetCodePreviewsByTokenIndex: Open the live preview of a build while it is being made (GET /v1/code/previews/{token}/)
func (c *Client) GetCodePreviewsByTokenIndex(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/previews/%s/", url.PathEscape(token)), nil, query, nil)
}

// GetCodeProjects: List your builds and coding projects (GET /v1/code/projects)
func (c *Client) GetCodeProjects(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/code/projects", nil, query, nil)
}

// GetCodeProjectsById: Read one build: what was asked, each version and its checks (GET /v1/code/projects/{id})
func (c *Client) GetCodeProjectsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/projects/%s", url.PathEscape(id)), nil, query, nil)
}

// GetCodeProjectsByIdAnalytics: Read who visits a build's site - pages, visits and where people come from (GET /v1/code/projects/{id}/analytics)
func (c *Client) GetCodeProjectsByIdAnalytics(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/projects/%s/analytics", url.PathEscape(id)), nil, query, nil)
}

// GetCodeProjectsByIdBackend: See what a build runs behind its pages - its database, sign-in, storage and the parts switched on (GET /v1/code/projects/{id}/backend)
func (c *Client) GetCodeProjectsByIdBackend(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/projects/%s/backend", url.PathEscape(id)), nil, query, nil)
}

// GetCodeProjectsByIdCheckpoints: List the checkpoints saved of a build's data, newest first (GET /v1/code/projects/{id}/checkpoints)
func (c *Client) GetCodeProjectsByIdCheckpoints(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/projects/%s/checkpoints", url.PathEscape(id)), nil, query, nil)
}

// GetCodeProjectsByIdDataByTable: Read the rows of one table in a build's database (GET /v1/code/projects/{id}/data/{table})
func (c *Client) GetCodeProjectsByIdDataByTable(ctx context.Context, id string, table string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/projects/%s/data/%s", url.PathEscape(id), url.PathEscape(table)), nil, query, nil)
}

// GetCodeProjectsByIdNetwork: 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)
func (c *Client) GetCodeProjectsByIdNetwork(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/projects/%s/network", url.PathEscape(id)), nil, query, nil)
}

// GetCodeSharedByToken: Open a build someone shared with you (GET /v1/code/shared/{token})
func (c *Client) GetCodeSharedByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/shared/%s", url.PathEscape(token)), nil, query, nil)
}

// GetCodeSharedByTokenEvents: Follow a shared build's steps as they happen (GET /v1/code/shared/{token}/events)
func (c *Client) GetCodeSharedByTokenEvents(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/shared/%s/events", url.PathEscape(token)), nil, query, nil)
}

// GetCodeSharedByTokenFiles: Read the files of a build someone shared with you (GET /v1/code/shared/{token}/files)
func (c *Client) GetCodeSharedByTokenFiles(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/shared/%s/files", url.PathEscape(token)), nil, query, nil)
}

// GetCodeSharedByTokenPreviewByPath: Open one file of a shared build's live preview (GET /v1/code/shared/{token}/preview/{path})
func (c *Client) GetCodeSharedByTokenPreviewByPath(ctx context.Context, token string, path string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/shared/%s/preview/%s", url.PathEscape(token), url.PathEscape(path)), nil, query, nil)
}

// GetCodeSharedByTokenPreviewIndex: Open the live preview of a build someone shared with you (GET /v1/code/shared/{token}/preview/)
func (c *Client) GetCodeSharedByTokenPreviewIndex(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/shared/%s/preview/", url.PathEscape(token)), nil, query, nil)
}

// GetCodeSitesByToken: Open the site a build was deployed to (GET /v1/code/sites/{token})
func (c *Client) GetCodeSitesByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/sites/%s", url.PathEscape(token)), nil, query, nil)
}

// GetCodeSitesByTokenByPath: Open one file of a deployed build's site (GET /v1/code/sites/{token}/{path})
func (c *Client) GetCodeSitesByTokenByPath(ctx context.Context, token string, path string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/sites/%s/%s", url.PathEscape(token), url.PathEscape(path)), nil, query, nil)
}

// GetCodeSitesByTokenIndex: Open the site a build was deployed to (GET /v1/code/sites/{token}/)
func (c *Client) GetCodeSitesByTokenIndex(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/sites/%s/", url.PathEscape(token)), nil, query, nil)
}

// GetCodeSpendLimit: Read how much your builds may spend in a month, and what is spent so far (GET /v1/code/spend-limit)
func (c *Client) GetCodeSpendLimit(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/code/spend-limit", nil, query, nil)
}

// GetCodeSshKey: 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)
func (c *Client) GetCodeSshKey(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/code/ssh-key", nil, query, nil)
}

// GetCodeTasksById: Read one coding job: each step it took, its proof and the pull request or change it ended with (GET /v1/code/tasks/{id})
func (c *Client) GetCodeTasksById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/tasks/%s", url.PathEscape(id)), nil, query, nil)
}

// GetCodeTasksByIdArchive: Download a build's code as one zip (GET /v1/code/tasks/{id}/archive)
func (c *Client) GetCodeTasksByIdArchive(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/tasks/%s/archive", url.PathEscape(id)), nil, query, nil)
}

// GetCodeTasksByIdEvents: Follow one coding job as it happens: each step the moment it lands, then its end (GET /v1/code/tasks/{id}/events)
func (c *Client) GetCodeTasksByIdEvents(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/tasks/%s/events", url.PathEscape(id)), nil, query, nil)
}

// GetCodeTasksByIdInbox: Reads the events a build was handed; with take=1 its session takes what is new, each once (GET /v1/code/tasks/{id}/inbox)
func (c *Client) GetCodeTasksByIdInbox(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/tasks/%s/inbox", url.PathEscape(id)), nil, query, nil)
}

// GetCodeTasksByIdShares: List the links a build is shared with, and what each one may do (GET /v1/code/tasks/{id}/shares)
func (c *Client) GetCodeTasksByIdShares(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/code/tasks/%s/shares", url.PathEscape(id)), nil, query, nil)
}

// GetCollectors: List your collectors (GET /v1/collectors)
func (c *Client) GetCollectors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/collectors", nil, query, nil)
}

// GetCompanies: Read your account's companies, each one's usage and the shared pool (GET /v1/companies)
func (c *Client) GetCompanies(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/companies", nil, query, nil)
}

// GetComplianceCyberEssentials: Read your Cyber Essentials readiness (GET /v1/compliance/cyber-essentials)
func (c *Client) GetComplianceCyberEssentials(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/compliance/cyber-essentials", nil, query, nil)
}

// GetComputerAuditCsv: Every computer session's record, for this workspace's own audit, as one file (GET /v1/computer/audit.csv)
func (c *Client) GetComputerAuditCsv(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/computer/audit.csv", nil, query, nil)
}

// GetComputerPolicy: Read this workspace's rules for Xovris's computer (GET /v1/computer/policy)
func (c *Client) GetComputerPolicy(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/computer/policy", nil, query, nil)
}

// GetComputersAllowance: See whether a job may use a computer, as part of your plan's AI use (GET /v1/computers/allowance)
func (c *Client) GetComputersAllowance(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/computers/allowance", nil, query, nil)
}

// GetComputersById: 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})
func (c *Client) GetComputersById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computers/%s", url.PathEscape(id)), nil, query, nil)
}

// GetComputersByIdDeskInput: 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)
func (c *Client) GetComputersByIdDeskInput(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computers/%s/desk/input", url.PathEscape(id)), nil, query, nil)
}

// GetComputersByIdDeskProfile: 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)
func (c *Client) GetComputersByIdDeskProfile(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computers/%s/desk/profile", url.PathEscape(id)), nil, query, nil)
}

// GetComputersByIdDeskUploads: The desktop's own door: the files the person gave the session, taken into its Uploads folder (GET /v1/computers/{id}/desk/uploads)
func (c *Client) GetComputersByIdDeskUploads(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computers/%s/desk/uploads", url.PathEscape(id)), nil, query, nil)
}

// GetComputersByIdFrame: Read a desktop's latest screen, or wait for the next one after the one you have (GET /v1/computers/{id}/frame)
func (c *Client) GetComputersByIdFrame(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computers/%s/frame", url.PathEscape(id)), nil, query, nil)
}

// GetComputerSchedules: Every goal on a schedule, its next time and its runs, each run in a conversation of its own (GET /v1/computer/schedules)
func (c *Client) GetComputerSchedules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/computer/schedules", nil, query, nil)
}

// GetComputerSessions: List this workspace's computer sessions, newest first, each with its state and how it ended (GET /v1/computer/sessions)
func (c *Client) GetComputerSessions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/computer/sessions", nil, query, nil)
}

// GetComputerSessionsById: 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})
func (c *Client) GetComputerSessionsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s", url.PathEscape(id)), nil, query, nil)
}

// GetComputerSessionsByIdFiles: The files a session downloaded on Xovris's own computer - their names, sizes and when (GET /v1/computer/sessions/{id}/files)
func (c *Client) GetComputerSessionsByIdFiles(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s/files", url.PathEscape(id)), nil, query, nil)
}

// GetComputerSessionsByIdFilesByName: One file the session downloaded, as the person's own download (GET /v1/computer/sessions/{id}/files/{name})
func (c *Client) GetComputerSessionsByIdFilesByName(ctx context.Context, id string, name string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s/files/%s", url.PathEscape(id), url.PathEscape(name)), nil, query, nil)
}

// GetComputerSessionsByIdRecording: 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)
func (c *Client) GetComputerSessionsByIdRecording(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s/recording", url.PathEscape(id)), nil, query, nil)
}

// GetComputerSessionsByIdReelBySeqByI: 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})
func (c *Client) GetComputerSessionsByIdReelBySeqByI(ctx context.Context, id string, seq string, i string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s/reel/%s/%s", url.PathEscape(id), url.PathEscape(seq), url.PathEscape(i)), nil, query, nil)
}

// GetComputerSessionsByIdReplay: Replay a computer session you ran, step by step, each step beside the screen it was chosen from (GET /v1/computer/sessions/{id}/replay)
func (c *Client) GetComputerSessionsByIdReplay(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s/replay", url.PathEscape(id)), nil, query, nil)
}

// GetComputerSessionsByIdReplayBySeq: One screen of a session you ran, as Xovris saw it before the steps chosen from it (GET /v1/computer/sessions/{id}/replay/{seq})
func (c *Client) GetComputerSessionsByIdReplayBySeq(ctx context.Context, id string, seq string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/computer/sessions/%s/replay/%s", url.PathEscape(id), url.PathEscape(seq)), nil, query, nil)
}

// GetComputersSignIns: 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)
func (c *Client) GetComputersSignIns(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/computers/sign-ins", nil, query, nil)
}

// GetConnectCallback: Where a provider's sign-in returns the person to finish a connection (GET /v1/connect/callback)
func (c *Client) GetConnectCallback(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connect/callback", nil, query, nil)
}

// GetConnections: List every connection and how its last check went (GET /v1/connections)
func (c *Client) GetConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connections", nil, query, nil)
}

// GetConnectionsByIdAccessDelta: Compare a connection's access with what a fix needs (GET /v1/connections/{id}/access-delta)
func (c *Client) GetConnectionsByIdAccessDelta(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/access-delta", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsByIdCanary: Read how a connection's scheduled check went (GET /v1/connections/{id}/canary)
func (c *Client) GetConnectionsByIdCanary(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/canary", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsByIdCapabilities: Read what a connection lets Xovris do (GET /v1/connections/{id}/capabilities)
func (c *Client) GetConnectionsByIdCapabilities(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/capabilities", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsByIdCredential: Read a connection's credential state (GET /v1/connections/{id}/credential)
func (c *Client) GetConnectionsByIdCredential(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/credential", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsByIdDomainsByDomainRenewal: See what renewing a domain costs at its registrar and the one call that buys it (GET /v1/connections/{id}/domains/{domain}/renewal)
func (c *Client) GetConnectionsByIdDomainsByDomainRenewal(ctx context.Context, id string, domain string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/domains/%s/renewal", url.PathEscape(id), url.PathEscape(domain)), nil, query, nil)
}

// GetConnectionsByIdGithub: See what a GitHub connection can do and what it needs (GET /v1/connections/{id}/github)
func (c *Client) GetConnectionsByIdGithub(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/github", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsByIdRemovePreview: See what stops working before you remove a connection (GET /v1/connections/{id}/remove-preview)
func (c *Client) GetConnectionsByIdRemovePreview(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/remove-preview", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsByIdVerify: Verify a connection is working (GET /v1/connections/{id}/verify)
func (c *Client) GetConnectionsByIdVerify(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/%s/verify", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsDns: List DNS connections (GET /v1/connections/dns)
func (c *Client) GetConnectionsDns(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connections/dns", nil, query, nil)
}

// GetConnectionsDnsById: Read a DNS connection (GET /v1/connections/dns/{id})
func (c *Client) GetConnectionsDnsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/dns/%s", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsDnsByIdRecords: List the records a DNS connection reads (GET /v1/connections/dns/{id}/records)
func (c *Client) GetConnectionsDnsByIdRecords(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/connections/dns/%s/records", url.PathEscape(id)), nil, query, nil)
}

// GetConnectionsFigma: See whether Figma is connected, and how (GET /v1/connections/figma)
func (c *Client) GetConnectionsFigma(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connections/figma", nil, query, nil)
}

// GetConnectionsFigmaCallback: Finish connecting Figma after allowing Xovris in Figma (GET /v1/connections/figma/callback)
func (c *Client) GetConnectionsFigmaCallback(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connections/figma/callback", nil, query, nil)
}

// GetConnectionsFigmaStart: Connect Figma in one press, allowed on Figma's own page (GET /v1/connections/figma/start)
func (c *Client) GetConnectionsFigmaStart(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connections/figma/start", nil, query, nil)
}

// GetConnectMcpLocal: See the MCP servers your own computers run, with the settings names each one is given (GET /v1/connect/mcp-local)
func (c *Client) GetConnectMcpLocal(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/connect/mcp-local", nil, query, nil)
}

// GetConversationsByTypeById: List the conversations a person started from one record's own page, newest first (GET /v1/conversations/{type}/{id})
func (c *Client) GetConversationsByTypeById(ctx context.Context, typeValue string, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/conversations/%s/%s", url.PathEscape(typeValue), url.PathEscape(id)), nil, query, nil)
}

// GetDashboards: List dashboards (GET /v1/dashboards)
func (c *Client) GetDashboards(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/dashboards", nil, query, nil)
}

// GetDashboardsById: Read a dashboard (GET /v1/dashboards/{id})
func (c *Client) GetDashboardsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/dashboards/%s", url.PathEscape(id)), nil, query, nil)
}

// GetDashboardsByIdReports: List a dashboard's scheduled reports (GET /v1/dashboards/{id}/reports)
func (c *Client) GetDashboardsByIdReports(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/dashboards/%s/reports", url.PathEscape(id)), nil, query, nil)
}

// GetDashboardsByIdReportsPreview: Read what a dashboard's report would say now (GET /v1/dashboards/{id}/reports/preview)
func (c *Client) GetDashboardsByIdReportsPreview(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/dashboards/%s/reports/preview", url.PathEscape(id)), nil, query, nil)
}

// GetDashboardsByIdShares: List a dashboard's shared links, embeds and TVs (GET /v1/dashboards/{id}/shares)
func (c *Client) GetDashboardsByIdShares(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/dashboards/%s/shares", url.PathEscape(id)), nil, query, nil)
}

// GetDeliveryAgents: See which commits a coding agent wrote and how they did in production (GET /v1/delivery/agents)
func (c *Client) GetDeliveryAgents(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/delivery/agents", nil, query, nil)
}

// GetDeliveryDora: Read your delivery measures (DORA) (GET /v1/delivery/dora)
func (c *Client) GetDeliveryDora(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/delivery/dora", nil, query, nil)
}

// GetDeployGuard: Whether a release may ship, read from every promised journey's error budget (GET /v1/deploy-guard)
func (c *Client) GetDeployGuard(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/deploy-guard", nil, query, nil)
}

// GetDeviceByCode: Read a device sign-in request (GET /v1/device/{code})
func (c *Client) GetDeviceByCode(ctx context.Context, code string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/device/%s", url.PathEscape(code)), nil, query, nil)
}

// GetDevices: List devices (GET /v1/devices)
func (c *Client) GetDevices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices", nil, query, nil)
}

// GetDevicesApple: See how far Xovris goes on an iPhone or iPad, with its guides and Shortcuts link (GET /v1/devices/apple)
func (c *Client) GetDevicesApple(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/apple", nil, query, nil)
}

// GetDevicesAppliances: List the appliance doors connected to your devices (GET /v1/devices/appliances)
func (c *Client) GetDevicesAppliances(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/appliances", nil, query, nil)
}

// GetDevicesAppUpdates: See application updates rolling out across your devices (GET /v1/devices/app-updates)
func (c *Client) GetDevicesAppUpdates(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/app-updates", nil, query, nil)
}

// GetDevicesById: Read a device (GET /v1/devices/{id})
func (c *Client) GetDevicesById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/devices/%s", url.PathEscape(id)), nil, query, nil)
}

// GetDevicesByIdActivity: Read a device's activity (GET /v1/devices/{id}/activity)
func (c *Client) GetDevicesByIdActivity(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/devices/%s/activity", url.PathEscape(id)), nil, query, nil)
}

// GetDevicesByIdMemory: See a device's model, quirks, history and what fixed it before (GET /v1/devices/{id}/memory)
func (c *Client) GetDevicesByIdMemory(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/devices/%s/memory", url.PathEscape(id)), nil, query, nil)
}

// GetDevicesByIdReliability: Read how reliable each workload on a device is (GET /v1/devices/{id}/reliability)
func (c *Client) GetDevicesByIdReliability(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/devices/%s/reliability", url.PathEscape(id)), nil, query, nil)
}

// GetDevicesByIdReportsByReportId: Read a device's report (GET /v1/devices/{id}/reports/{reportId})
func (c *Client) GetDevicesByIdReportsByReportId(ctx context.Context, id string, reportId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/devices/%s/reports/%s", url.PathEscape(id), url.PathEscape(reportId)), nil, query, nil)
}

// GetDevicesDoors: See every door Xovris reaches a device through, least asked of you first (GET /v1/devices/doors)
func (c *Client) GetDevicesDoors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/doors", nil, query, nil)
}

// GetDevicesEnrolmentCodesByCodeInstaller: Download the installer that enrols a device with this code (GET /v1/devices/enrolment-codes/{code}/installer)
func (c *Client) GetDevicesEnrolmentCodesByCodeInstaller(ctx context.Context, code string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/devices/enrolment-codes/%s/installer", url.PathEscape(code)), nil, query, nil)
}

// GetDevicesFindingsCsv: Every device finding, as one spreadsheet (GET /v1/devices/findings.csv)
func (c *Client) GetDevicesFindingsCsv(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/findings.csv", nil, query, nil)
}

// GetDevicesGroups: List your device groups (GET /v1/devices/groups)
func (c *Client) GetDevicesGroups(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/groups", nil, query, nil)
}

// GetDevicesInstallers: See what Xovris can hand a computer of each system - a download to open, or one line that fetches it (GET /v1/devices/installers)
func (c *Client) GetDevicesInstallers(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/installers", nil, query, nil)
}

// GetDevicesLocalAgentControlKey: Read the public key your computers' agents verify Xovris with (GET /v1/devices/local-agent/control-key)
func (c *Client) GetDevicesLocalAgentControlKey(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/local-agent/control-key", nil, query, nil)
}

// GetDevicesRemediations: List the fixes found for your devices, and which have been made (GET /v1/devices/remediations)
func (c *Client) GetDevicesRemediations(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/devices/remediations", nil, query, nil)
}

// GetDigestWeek: Read this week's letter, every figure from your own records (GET /v1/digest/week)
func (c *Client) GetDigestWeek(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/digest/week", nil, query, nil)
}

// GetDnsDangling: List records pointing at something nobody owns (GET /v1/dns/dangling)
func (c *Client) GetDnsDangling(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/dns/dangling", nil, query, nil)
}

// GetDnsQueryByToken: Ask a household member's protective resolver a DNS question (RFC 8484 GET) (GET /v1/dns-query/{token})
func (c *Client) GetDnsQueryByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/dns-query/%s", url.PathEscape(token)), nil, query, nil)
}

// GetDnsRestoreDrills: Read each zone's latest test restore and what it brought back (GET /v1/dns/restore-drills)
func (c *Client) GetDnsRestoreDrills(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/dns/restore-drills", nil, query, nil)
}

// GetDnssecDs: See the DNSSEC record your registrar needs (GET /v1/dnssec/ds)
func (c *Client) GetDnssecDs(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/dnssec/ds", nil, query, nil)
}

// GetDomainsByDomainRegistrar: See which of your registrar connections holds a domain, and whether its transfer lock is on (GET /v1/domains/{domain}/registrar)
func (c *Client) GetDomainsByDomainRegistrar(ctx context.Context, domain string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/domains/%s/registrar", url.PathEscape(domain)), nil, query, nil)
}

// GetDoorsExtension: See the browsers paired with the Xovris extension (GET /v1/doors/extension)
func (c *Client) GetDoorsExtension(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/doors/extension", nil, query, nil)
}

// GetDoorsExtensionNext: The paired extension asks for its next step (GET /v1/doors/extension/next)
func (c *Client) GetDoorsExtensionNext(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/doors/extension/next", nil, query, nil)
}

// GetDoorsExtensionTasksById: See how an extension task went, step by step (GET /v1/doors/extension/tasks/{id})
func (c *Client) GetDoorsExtensionTasksById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/doors/extension/tasks/%s", url.PathEscape(id)), nil, query, nil)
}

// GetEdgeProtect: See each zone you granted and what Xovris may put on its edge (GET /v1/edge/protect)
func (c *Client) GetEdgeProtect(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/edge/protect", nil, query, nil)
}

// GetEfficiency: Read the weekly list of ways to be faster or cheaper (GET /v1/efficiency)
func (c *Client) GetEfficiency(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/efficiency", nil, query, nil)
}

// GetEfficiencyWeekly: Read the weekly faster-or-cheaper email's contents (GET /v1/efficiency/weekly)
func (c *Client) GetEfficiencyWeekly(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/efficiency/weekly", nil, query, nil)
}

// GetElevations: 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)
func (c *Client) GetElevations(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/elevations", nil, query, nil)
}

// GetEstate: Read everything you run, by kind - each kind's things, what was last read, and how many wait on you (GET /v1/estate)
func (c *Client) GetEstate(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/estate", nil, query, nil)
}

// GetEstateByKind: Read one kind of thing you run, with its things, their readings and its open incidents (GET /v1/estate/{kind})
func (c *Client) GetEstateByKind(ctx context.Context, kind string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/estate/%s", url.PathEscape(kind)), nil, query, nil)
}

// GetEverydayActs: See everything Xovris did for you through these features, each with its undo (GET /v1/everyday/acts)
func (c *Client) GetEverydayActs(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/everyday/acts", nil, query, nil)
}

// GetEverydayFigures: 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)
func (c *Client) GetEverydayFigures(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/everyday/figures", nil, query, nil)
}

// GetEverydayPrevented: 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)
func (c *Client) GetEverydayPrevented(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/everyday/prevented", nil, query, nil)
}

// GetExport: Export everything in this workspace (GET /v1/export)
func (c *Client) GetExport(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/export", nil, query, nil)
}

// GetExports: Read where each export stands, reconciled (GET /v1/exports)
func (c *Client) GetExports(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/exports", nil, query, nil)
}

// GetExportsSchema: Read the export schema (GET /v1/exports/schema)
func (c *Client) GetExportsSchema(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/exports/schema", nil, query, nil)
}

// GetExposure: Read what is exposed about you (GET /v1/exposure)
func (c *Client) GetExposure(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/exposure", nil, query, nil)
}

// GetExposureProve: Open the link that confirms an address to watch (GET /v1/exposure/prove)
func (c *Client) GetExposureProve(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/exposure/prove", nil, query, nil)
}

// GetExtensions: Read the components for a place in the command centre (GET /v1/extensions)
func (c *Client) GetExtensions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/extensions", nil, query, nil)
}

// GetExtensionsApps: List installed apps (GET /v1/extensions/apps)
func (c *Client) GetExtensionsApps(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/extensions/apps", nil, query, nil)
}

// GetFailoverTargets: List the standby targets for failover (GET /v1/failover-targets)
func (c *Client) GetFailoverTargets(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/failover-targets", nil, query, nil)
}

// GetFixActions: List the fix actions Xovris can run here (GET /v1/fix-actions)
func (c *Client) GetFixActions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/fix-actions", nil, query, nil)
}

// GetForecasts: Read what will fail before it does (GET /v1/forecasts)
func (c *Client) GetForecasts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/forecasts", nil, query, nil)
}

// GetForwarders: List the log agents you can point at Xovris (GET /v1/forwarders)
func (c *Client) GetForwarders(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/forwarders", nil, query, nil)
}

// GetForwardersParity: Compare your log agents' settings with Xovris's (GET /v1/forwarders/parity)
func (c *Client) GetForwardersParity(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/forwarders/parity", nil, query, nil)
}

// GetFreeExpiryConfirm: Confirm a free expiry watch from its email (GET /v1/free/expiry/confirm)
func (c *Client) GetFreeExpiryConfirm(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/free/expiry/confirm", nil, query, nil)
}

// GetGoalsAccount: 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)
func (c *Client) GetGoalsAccount(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/goals/account", nil, query, nil)
}

// GetGoalsStanding: See your standing goals, what wakes each, and every time each fired (GET /v1/goals/standing)
func (c *Client) GetGoalsStanding(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/goals/standing", nil, query, nil)
}

// GetGrants: List the standing permissions you have given Xovris to act for you (GET /v1/grants)
func (c *Client) GetGrants(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/grants", nil, query, nil)
}

// GetHealth: Read whether the API and its database are answering (GET /v1/health)
func (c *Client) GetHealth(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/health", nil, query, nil)
}

// GetHelperWebsiteConversations: Read the conversations carried here from the website (GET /v1/helper/website-conversations)
func (c *Client) GetHelperWebsiteConversations(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/helper/website-conversations", nil, query, nil)
}

// GetHomeNetwork: Read what the weekly home-network check found (GET /v1/home-network)
func (c *Client) GetHomeNetwork(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/home-network", nil, query, nil)
}

// GetHooksSourcesByTenantByConnection: Read a connected source's door (GET /v1/hooks/sources/{tenant}/{connection})
func (c *Client) GetHooksSourcesByTenantByConnection(ctx context.Context, tenant string, connection string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/hooks/sources/%s/%s", url.PathEscape(tenant), url.PathEscape(connection)), nil, query, nil)
}

// GetHooksWatchByToken: Report to a watch with a GET (GET /v1/hooks/watch/{token})
func (c *Client) GetHooksWatchByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/hooks/watch/%s", url.PathEscape(token)), nil, query, nil)
}

// GetHousehold: See your household's members, their devices and what was blocked this week (GET /v1/household)
func (c *Client) GetHousehold(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/household", nil, query, nil)
}

// GetHouseholdMembersByIdBlocked: See what was blocked for a household member, and allow it (GET /v1/household/members/{id}/blocked)
func (c *Client) GetHouseholdMembersByIdBlocked(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/household/members/%s/blocked", url.PathEscape(id)), nil, query, nil)
}

// GetHouseholdSetupByTokenAppleMobileconfig: Download the protection profile for an iPhone, iPad or Mac (GET /v1/household/setup/{token}/apple.mobileconfig)
func (c *Client) GetHouseholdSetupByTokenAppleMobileconfig(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/household/setup/%s/apple.mobileconfig", url.PathEscape(token)), nil, query, nil)
}

// GetIdentityAppRisk: Read what each app people let into your directory can read and change, with its risk (GET /v1/identity/app-risk)
func (c *Client) GetIdentityAppRisk(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/identity/app-risk", nil, query, nil)
}

// GetIdentityConnections: List connected directories (GET /v1/identity/connections)
func (c *Client) GetIdentityConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/identity/connections", nil, query, nil)
}

// GetIdentityConnectionsByIdLayers: Read a directory's protection layers (GET /v1/identity/connections/{id}/layers)
func (c *Client) GetIdentityConnectionsByIdLayers(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/identity/connections/%s/layers", url.PathEscape(id)), nil, query, nil)
}

// GetIdentityDoors: See each identity system Xovris connects with one approval, and exactly what it asks for (GET /v1/identity/doors)
func (c *Client) GetIdentityDoors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/identity/doors", nil, query, nil)
}

// GetIdentityDoorsCallback: Finish connecting an identity system when its approval page sends you back (GET /v1/identity/doors/callback)
func (c *Client) GetIdentityDoorsCallback(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/identity/doors/callback", nil, query, nil)
}

// GetIdentityRuns: List starter and leaver runs (GET /v1/identity/runs)
func (c *Client) GetIdentityRuns(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/identity/runs", nil, query, nil)
}

// GetIdentityRunsById: Read a starter or leaver run (GET /v1/identity/runs/{id})
func (c *Client) GetIdentityRunsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/identity/runs/%s", url.PathEscape(id)), nil, query, nil)
}

// GetIdentityRunsByIdReceipt: 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)
func (c *Client) GetIdentityRunsByIdReceipt(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/identity/runs/%s/receipt", url.PathEscape(id)), nil, query, nil)
}

// GetIncidents: List incidents (GET /v1/incidents)
func (c *Client) GetIncidents(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/incidents", nil, query, nil)
}

// GetIncidentsById: Read an incident (GET /v1/incidents/{id})
func (c *Client) GetIncidentsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdAudiences: 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)
func (c *Client) GetIncidentsByIdAudiences(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/audiences", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdConversations: List the conversations a person started from an incident's own page, newest first (GET /v1/incidents/{id}/conversations)
func (c *Client) GetIncidentsByIdConversations(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/conversations", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdDependencies: 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)
func (c *Client) GetIncidentsByIdDependencies(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/dependencies", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdEvidencePack: Export an incident's evidence as one notarised file anyone can check offline (GET /v1/incidents/{id}/evidence-pack)
func (c *Client) GetIncidentsByIdEvidencePack(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/evidence-pack", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdFixFilm: Read an incident's fix film - before, each step and after - or download it as one notarised file (GET /v1/incidents/{id}/fix-film)
func (c *Client) GetIncidentsByIdFixFilm(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/fix-film", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdPlan: Read every cause Xovris is weighing for an incident and what tested each (GET /v1/incidents/{id}/plan)
func (c *Client) GetIncidentsByIdPlan(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/plan", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdReceiptsByReceiptIdSigned: Download a fix's receipt, signed so you can check it yourself (GET /v1/incidents/{id}/receipts/{receiptId}/signed)
func (c *Client) GetIncidentsByIdReceiptsByReceiptIdSigned(ctx context.Context, id string, receiptId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/receipts/%s/signed", url.PathEscape(id), url.PathEscape(receiptId)), nil, query, nil)
}

// GetIncidentsByIdRecord: 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)
func (c *Client) GetIncidentsByIdRecord(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/record", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdRecordExport: Download an incident's recording as a file that proves itself - signed where signing is on (GET /v1/incidents/{id}/record/export)
func (c *Client) GetIncidentsByIdRecordExport(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/record/export", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdRestoreOptions: Read the record and versions an incident can be restored to (GET /v1/incidents/{id}/restore-options)
func (c *Client) GetIncidentsByIdRestoreOptions(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/restore-options", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdReview: 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)
func (c *Client) GetIncidentsByIdReview(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/review", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdRoom: See who is on an incident now and who worked it today (GET /v1/incidents/{id}/room)
func (c *Client) GetIncidentsByIdRoom(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/room", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdRunsByRunId: Read one run of an incident's check in full - its status, headers and what it read (GET /v1/incidents/{id}/runs/{runId})
func (c *Client) GetIncidentsByIdRunsByRunId(ctx context.Context, id string, runId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/runs/%s", url.PathEscape(id), url.PathEscape(runId)), nil, query, nil)
}

// GetIncidentsByIdRunsByRunIdProof: Download a fix's signed proof - the cause, the tests before and after and their verdicts (GET /v1/incidents/{id}/runs/{runId}/proof)
func (c *Client) GetIncidentsByIdRunsByRunIdProof(ctx context.Context, id string, runId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/runs/%s/proof", url.PathEscape(id), url.PathEscape(runId)), nil, query, nil)
}

// GetIncidentsByIdShares: List an incident's shared links (GET /v1/incidents/{id}/shares)
func (c *Client) GetIncidentsByIdShares(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/shares", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdSimilar: Read the incidents that look like this one, each with why (GET /v1/incidents/{id}/similar)
func (c *Client) GetIncidentsByIdSimilar(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/similar", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdStakeholders: 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)
func (c *Client) GetIncidentsByIdStakeholders(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/stakeholders", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentsByIdWorkspace: Read an incident's working notes, the same on every device (GET /v1/incidents/{id}/workspace)
func (c *Client) GetIncidentsByIdWorkspace(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/incidents/%s/workspace", url.PathEscape(id)), nil, query, nil)
}

// GetIncidentScopes: Read how often people here chose each window on an incident's record, for one kind or every kind (GET /v1/incident-scopes)
func (c *Client) GetIncidentScopes(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/incident-scopes", nil, query, nil)
}

// GetIncidentsShared: Count the incidents sharing a value (GET /v1/incidents/shared)
func (c *Client) GetIncidentsShared(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/incidents/shared", nil, query, nil)
}

// GetIntegrationsSlack: See whether Slack is connected, or why not (GET /v1/integrations/slack)
func (c *Client) GetIntegrationsSlack(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/integrations/slack", nil, query, nil)
}

// GetIssues: List errors (GET /v1/issues)
func (c *Client) GetIssues(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/issues", nil, query, nil)
}

// GetIssuesById: Read an error (GET /v1/issues/{id})
func (c *Client) GetIssuesById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesByIdEvents: List an error's kept events, newest first (GET /v1/issues/{id}/events)
func (c *Client) GetIssuesByIdEvents(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/events", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesByIdEventsByEventId: Read one kept event of an error (GET /v1/issues/{id}/events/{eventId})
func (c *Client) GetIssuesByIdEventsByEventId(ctx context.Context, id string, eventId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/events/%s", url.PathEscape(id), url.PathEscape(eventId)), nil, query, nil)
}

// GetIssuesByIdFields: Read an issue's fields: status, priority, who has it, labels and the rest (GET /v1/issues/{id}/fields)
func (c *Client) GetIssuesByIdFields(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/fields", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesByIdPeople: See who has an issue, who opened it, who follows it and who has seen it (GET /v1/issues/{id}/people)
func (c *Client) GetIssuesByIdPeople(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/people", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesByIdSessions: 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)
func (c *Client) GetIssuesByIdSessions(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/sessions", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesByIdSimilar: Find issues like this one (GET /v1/issues/{id}/similar)
func (c *Client) GetIssuesByIdSimilar(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/similar", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesByIdTrend: See how often an issue has happened over time (GET /v1/issues/{id}/trend)
func (c *Client) GetIssuesByIdTrend(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/issues/%s/trend", url.PathEscape(id)), nil, query, nil)
}

// GetIssuesCycles: See the weeks around this one, each with its issues, how many are done and what was carried in (GET /v1/issues/cycles)
func (c *Client) GetIssuesCycles(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/issues/cycles", nil, query, nil)
}

// GetIssuesInsights: See how issues are opened, taken and closed across the workspace (GET /v1/issues/insights)
func (c *Client) GetIssuesInsights(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/issues/insights", nil, query, nil)
}

// GetIssuesMine: See the issues given to you, the ones you opened and the ones you follow, with what happened to each (GET /v1/issues/mine)
func (c *Client) GetIssuesMine(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/issues/mine", nil, query, nil)
}

// GetIssuesSaid: Read what people wrote about the workspace's errors (GET /v1/issues/said)
func (c *Client) GetIssuesSaid(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/issues/said", nil, query, nil)
}

// GetIssuesTriage: See every open issue nobody has taken yet, newest first, with who is on triage (GET /v1/issues/triage)
func (c *Client) GetIssuesTriage(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/issues/triage", nil, query, nil)
}

// GetLive: Follow every change to this workspace's incidents and fixes as it happens, on one stream (GET /v1/live)
func (c *Client) GetLive(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/live", nil, query, nil)
}

// GetLogArchiveDestinations: List log archive destinations (GET /v1/log-archive/destinations)
func (c *Client) GetLogArchiveDestinations(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/log-archive/destinations", nil, query, nil)
}

// GetLogArchiveSearch: Search archived logs (GET /v1/log-archive/search)
func (c *Client) GetLogArchiveSearch(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/log-archive/search", nil, query, nil)
}

// GetLogConnections: List log connections (GET /v1/log-connections)
func (c *Client) GetLogConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/log-connections", nil, query, nil)
}

// GetLogConnectionsById: Read a log connection (GET /v1/log-connections/{id})
func (c *Client) GetLogConnectionsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/log-connections/%s", url.PathEscape(id)), nil, query, nil)
}

// GetLogsBreakdown: Break the lines a search matched down by any field, with exact counts (GET /v1/logs/breakdown)
func (c *Client) GetLogsBreakdown(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/breakdown", nil, query, nil)
}

// GetLogsCompare: Compare a window of logs with its healthy baseline (GET /v1/logs/compare)
func (c *Client) GetLogsCompare(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/compare", nil, query, nil)
}

// GetLogsExport: Export every line a search matches, as CSV or NDJSON (GET /v1/logs/export)
func (c *Client) GetLogsExport(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/export", nil, query, nil)
}

// GetLogsFaults: Read the failing lines as faults, each with its root cause (GET /v1/logs/faults)
func (c *Client) GetLogsFaults(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/faults", nil, query, nil)
}

// GetLogsLinesById: Read a log line with its context (GET /v1/logs/lines/{id})
func (c *Client) GetLogsLinesById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/logs/lines/%s", url.PathEscape(id)), nil, query, nil)
}

// GetLogsPatterns: Read log patterns (GET /v1/logs/patterns)
func (c *Client) GetLogsPatterns(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/patterns", nil, query, nil)
}

// GetLogsPatternsByTemplateIdInspect: Inspect one kind of log line - each varying part's values across its lines (GET /v1/logs/patterns/{templateId}/inspect)
func (c *Client) GetLogsPatternsByTemplateIdInspect(ctx context.Context, templateId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/logs/patterns/%s/inspect", url.PathEscape(templateId)), nil, query, nil)
}

// GetLogsRetention: Read how long logs are kept (GET /v1/logs/retention)
func (c *Client) GetLogsRetention(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/retention", nil, query, nil)
}

// GetLogsSearch: Search logs (GET /v1/logs/search)
func (c *Client) GetLogsSearch(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/search", nil, query, nil)
}

// GetLogsSources: List log sources (GET /v1/logs/sources)
func (c *Client) GetLogsSources(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/sources", nil, query, nil)
}

// GetLogsTail: Watch log lines arrive live, each judged as it arrives (GET /v1/logs/tail)
func (c *Client) GetLogsTail(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/tail", nil, query, nil)
}

// GetLogsTransactions: Follow the lines of one process - an order, a request, a job - by the field they share (GET /v1/logs/transactions)
func (c *Client) GetLogsTransactions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/logs/transactions", nil, query, nil)
}

// GetMailAudit: Check a domain's mail records and see what Xovris writes for each finding (GET /v1/mail/audit)
func (c *Client) GetMailAudit(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/mail/audit", nil, query, nil)
}

// GetMailKeys: See the DKIM records Xovris holds for a domain, each with the mail service it came from (GET /v1/mail/keys)
func (c *Client) GetMailKeys(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/mail/keys", nil, query, nil)
}

// GetMajorCommsRules: Read who is told when a major incident of each kind and severity is declared (GET /v1/major-comms/rules)
func (c *Client) GetMajorCommsRules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/major-comms/rules", nil, query, nil)
}

// GetMakeById: 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})
func (c *Client) GetMakeById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/make/%s", url.PathEscape(id)), nil, query, nil)
}

// GetMakeByIdFilesByName: 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})
func (c *Client) GetMakeByIdFilesByName(ctx context.Context, id string, name string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/make/%s/files/%s", url.PathEscape(id), url.PathEscape(name)), nil, query, nil)
}

// GetMcp: Open the stream an MCP session listens on (GET /v1/mcp)
func (c *Client) GetMcp(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/mcp", nil, query, nil)
}

// GetMe: Read who you are and your workspaces (GET /v1/me)
func (c *Client) GetMe(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/me", nil, query, nil)
}

// GetMeClients: 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)
func (c *Client) GetMeClients(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/me/clients", nil, query, nil)
}

// GetMeLearned: Read what Xovris has learned about you and your systems, and how to erase it (GET /v1/me/learned)
func (c *Client) GetMeLearned(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/me/learned", nil, query, nil)
}

// GetMembers: List members (GET /v1/members)
func (c *Client) GetMembers(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/members", nil, query, nil)
}

// GetMembersInvitations: See the open invitations to this workspace, each with its role and when it expires (GET /v1/members/invitations)
func (c *Client) GetMembersInvitations(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/members/invitations", nil, query, nil)
}

// GetMePreferences: Read your own appearance and notification choices (GET /v1/me/preferences)
func (c *Client) GetMePreferences(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/me/preferences", nil, query, nil)
}

// GetMetricsAlerts: List metric alerts (GET /v1/metrics/alerts)
func (c *Client) GetMetricsAlerts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/metrics/alerts", nil, query, nil)
}

// GetMetricsEntities: List what reports metrics (GET /v1/metrics/entities)
func (c *Client) GetMetricsEntities(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/metrics/entities", nil, query, nil)
}

// GetMetricsFindings: List infrastructure findings (GET /v1/metrics/findings)
func (c *Client) GetMetricsFindings(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/metrics/findings", nil, query, nil)
}

// GetMetricsGpuIdle: Read idle GPU time and its cost (GET /v1/metrics/gpu-idle)
func (c *Client) GetMetricsGpuIdle(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/metrics/gpu-idle", nil, query, nil)
}

// GetMetricsInference: Read AI model latency (GET /v1/metrics/inference)
func (c *Client) GetMetricsInference(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/metrics/inference", nil, query, nil)
}

// GetMetricsQuery: Query metrics (GET /v1/metrics/query)
func (c *Client) GetMetricsQuery(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/metrics/query", nil, query, nil)
}

// GetModelsOwn: 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)
func (c *Client) GetModelsOwn(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/models/own", nil, query, nil)
}

// GetMspGrants: List the MSPs you granted access (GET /v1/msp/grants)
func (c *Client) GetMspGrants(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/msp/grants", nil, query, nil)
}

// GetMspSharedCauses: Read what is failing for more than one of the workspaces that granted you access, at once (GET /v1/msp/shared-causes)
func (c *Client) GetMspSharedCauses(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/msp/shared-causes", nil, query, nil)
}

// GetMspSuccessRates: Read what Xovris fixed and proved on each system across the workspaces that granted you access (GET /v1/msp/success-rates)
func (c *Client) GetMspSuccessRates(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/msp/success-rates", nil, query, nil)
}

// GetMspTenants: List the workspaces that granted you access (GET /v1/msp/tenants)
func (c *Client) GetMspTenants(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/msp/tenants", nil, query, nil)
}

// GetNeedsYou: What waits on you - incidents, requests and stopped work, each counted once, the one count every surface draws (GET /v1/needs-you)
func (c *Client) GetNeedsYou(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/needs-you", nil, query, nil)
}

// GetNetworkDefenceAdvisories: 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)
func (c *Client) GetNetworkDefenceAdvisories(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/advisories", nil, query, nil)
}

// GetNetworkDefenceFirewallPolicyRuns: See each machine's firewall policy run with what it proved (GET /v1/network-defence/firewall-policy/runs)
func (c *Client) GetNetworkDefenceFirewallPolicyRuns(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/firewall-policy/runs", nil, query, nil)
}

// GetNetworkDefenceFreshness: See how current each threat feed and list behind your defences is (GET /v1/network-defence/freshness)
func (c *Client) GetNetworkDefenceFreshness(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/freshness", nil, query, nil)
}

// GetNetworkDefenceHunts: See where your network memory matched a threat indicator (GET /v1/network-defence/hunts)
func (c *Client) GetNetworkDefenceHunts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/hunts", nil, query, nil)
}

// GetNetworkDefenceIncidents: See network incidents with their real risk and a plain explanation (GET /v1/network-defence/incidents)
func (c *Client) GetNetworkDefenceIncidents(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/incidents", nil, query, nil)
}

// GetNetworkDefenceIncidentsById: 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})
func (c *Client) GetNetworkDefenceIncidentsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network-defence/incidents/%s", url.PathEscape(id)), nil, query, nil)
}

// GetNetworkDefenceIncidentsByIdContain: 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)
func (c *Client) GetNetworkDefenceIncidentsByIdContain(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network-defence/incidents/%s/contain", url.PathEscape(id)), nil, query, nil)
}

// GetNetworkDefenceIncidentsByIdEvidence: See a network incident's raw evidence, each line with the digest it was received under (GET /v1/network-defence/incidents/{id}/evidence)
func (c *Client) GetNetworkDefenceIncidentsByIdEvidence(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network-defence/incidents/%s/evidence", url.PathEscape(id)), nil, query, nil)
}

// GetNetworkDefencePreventions: See every block asked for, with the proof that it stops the traffic or why it was taken out (GET /v1/network-defence/preventions)
func (c *Client) GetNetworkDefencePreventions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/preventions", nil, query, nil)
}

// GetNetworkDefenceSensors: See every network sensor's own health: reporting or stopped, the traffic it handles and the share it misses (GET /v1/network-defence/sensors)
func (c *Client) GetNetworkDefenceSensors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/sensors", nil, query, nil)
}

// GetNetworkDefenceSuppressions: List what your workspace has said is expected on its network (GET /v1/network-defence/suppressions)
func (c *Client) GetNetworkDefenceSuppressions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network-defence/suppressions", nil, query, nil)
}

// GetNetworkDevicesConfigByCheckId: See where a device change stands - its plan, its backup and what the device reads back (GET /v1/network/devices/config/{checkId})
func (c *Client) GetNetworkDevicesConfigByCheckId(ctx context.Context, checkId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network/devices/config/%s", url.PathEscape(checkId)), nil, query, nil)
}

// GetNetworkMap: 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)
func (c *Client) GetNetworkMap(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network/map", nil, query, nil)
}

// GetNetworkReviewByCheckId: See where a network device's review stands, with what it found (GET /v1/network/review/{checkId})
func (c *Client) GetNetworkReviewByCheckId(ctx context.Context, checkId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network/review/%s", url.PathEscape(checkId)), nil, query, nil)
}

// GetNetworkReviews: List the network device reviews Xovris has run, newest first (GET /v1/network/reviews)
func (c *Client) GetNetworkReviews(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/network/reviews", nil, query, nil)
}

// GetNetworkSourcesNetboxByCheckId: See where a NetBox read stands (GET /v1/network/sources/netbox/{checkId})
func (c *Client) GetNetworkSourcesNetboxByCheckId(ctx context.Context, checkId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network/sources/netbox/%s", url.PathEscape(checkId)), nil, query, nil)
}

// GetNetworkTroubleshootByCheckId: See where a network troubleshoot stands, with each step Xovris read (GET /v1/network/troubleshoot/{checkId})
func (c *Client) GetNetworkTroubleshootByCheckId(ctx context.Context, checkId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/network/troubleshoot/%s", url.PathEscape(checkId)), nil, query, nil)
}

// GetNow: Read every figure your home draws - who needs you, security, devices, checks and today's counters (GET /v1/now)
func (c *Client) GetNow(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/now", nil, query, nil)
}

// GetOauthApps: List the OAuth apps this workspace publishes (GET /v1/oauth/apps)
func (c *Client) GetOauthApps(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/oauth/apps", nil, query, nil)
}

// GetOauthAuthorize: Read what an app asks to be allowed to do (GET /v1/oauth/authorize)
func (c *Client) GetOauthAuthorize(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/oauth/authorize", nil, query, nil)
}

// GetOauthDeviceByCode: Read the sign-in request behind a device code (GET /v1/oauth/device/{code})
func (c *Client) GetOauthDeviceByCode(ctx context.Context, code string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/oauth/device/%s", url.PathEscape(code)), nil, query, nil)
}

// GetOauthGrants: List the apps people here have allowed (GET /v1/oauth/grants)
func (c *Client) GetOauthGrants(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/oauth/grants", nil, query, nil)
}

// GetOncall: See who is on call, the schedules and who is away (GET /v1/oncall)
func (c *Client) GetOncall(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/oncall", nil, query, nil)
}

// GetOncallDrills: Read each escalation policy's newest drill, hop by hop (GET /v1/oncall/drills)
func (c *Client) GetOncallDrills(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/oncall/drills", nil, query, nil)
}

// GetOncallDrillsById: Read one drill: every page it made and whether a person acknowledged it (GET /v1/oncall/drills/{id})
func (c *Client) GetOncallDrillsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/oncall/drills/%s", url.PathEscape(id)), nil, query, nil)
}

// GetOncallImports: List your on-call imports (GET /v1/oncall/imports)
func (c *Client) GetOncallImports(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/oncall/imports", nil, query, nil)
}

// GetOncallSchedulesByIdTimeline: See a schedule's timeline - who is on call when (GET /v1/oncall/schedules/{id}/timeline)
func (c *Client) GetOncallSchedulesByIdTimeline(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/oncall/schedules/%s/timeline", url.PathEscape(id)), nil, query, nil)
}

// GetOpenapiJson: Read this API's OpenAPI document (GET /v1/openapi.json)
func (c *Client) GetOpenapiJson(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/openapi.json", nil, query, nil)
}

// GetOutcomesLeaders: See how each feature compares with the leading tools in its area (GET /v1/outcomes/leaders)
func (c *Client) GetOutcomesLeaders(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/outcomes/leaders", nil, query, nil)
}

// GetOutcomesLearning: See whether Xovris is getting quicker and better at each kind of problem (GET /v1/outcomes/learning)
func (c *Client) GetOutcomesLearning(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/outcomes/learning", nil, query, nil)
}

// GetOutcomesSpeed: Read how quickly Xovris found causes and proved fixes in this workspace (GET /v1/outcomes/speed)
func (c *Client) GetOutcomesSpeed(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/outcomes/speed", nil, query, nil)
}

// GetPartners: List your partner keys (GET /v1/partners)
func (c *Client) GetPartners(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/partners", nil, query, nil)
}

// GetPartnersAccounts: List the accounts you provisioned (GET /v1/partners/accounts)
func (c *Client) GetPartnersAccounts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/partners/accounts", nil, query, nil)
}

// GetPartnersAccountsByIdExport: Download a removed account's export (GET /v1/partners/accounts/{id}/export)
func (c *Client) GetPartnersAccountsByIdExport(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/partners/accounts/%s/export", url.PathEscape(id)), nil, query, nil)
}

// GetPartnersSandboxKeys: List your provisioning sandbox keys (GET /v1/partners/sandbox-keys)
func (c *Client) GetPartnersSandboxKeys(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/partners/sandbox-keys", nil, query, nil)
}

// GetPartnersStatements: List your monthly partner statements (GET /v1/partners/statements)
func (c *Client) GetPartnersStatements(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/partners/statements", nil, query, nil)
}

// GetPaymentsConnections: Read every connected payment provider's sales, failed payments, disputes and payouts (GET /v1/payments/connections)
func (c *Client) GetPaymentsConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/payments/connections", nil, query, nil)
}

// GetPeopleOutside: 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)
func (c *Client) GetPeopleOutside(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/people/outside", nil, query, nil)
}

// GetPermissions: 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)
func (c *Client) GetPermissions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/permissions", nil, query, nil)
}

// GetPinsIncidents: The incidents you have pinned, the last one first and every open one before a closed one (GET /v1/pins/incidents)
func (c *Client) GetPinsIncidents(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/pins/incidents", nil, query, nil)
}

// GetPipelinesDerived: List metrics made from log lines (GET /v1/pipelines/derived)
func (c *Client) GetPipelinesDerived(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/pipelines/derived", nil, query, nil)
}

// GetPipelinesDerivedByIdSeries: Read a derived metric's values (GET /v1/pipelines/derived/{id}/series)
func (c *Client) GetPipelinesDerivedByIdSeries(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/pipelines/derived/%s/series", url.PathEscape(id)), nil, query, nil)
}

// GetPipelinesDerivedProposals: List metrics Xovris suggests from your logs (GET /v1/pipelines/derived/proposals)
func (c *Client) GetPipelinesDerivedProposals(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/pipelines/derived/proposals", nil, query, nil)
}

// GetPipelinesDiet: Read which log lines are kept and dropped (GET /v1/pipelines/diet)
func (c *Client) GetPipelinesDiet(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/pipelines/diet", nil, query, nil)
}

// GetPipelinesRules: List log pipeline rules (GET /v1/pipelines/rules)
func (c *Client) GetPipelinesRules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/pipelines/rules", nil, query, nil)
}

// GetPipelinesRulesAccuracy: Read how accurately the rules matched (GET /v1/pipelines/rules/accuracy)
func (c *Client) GetPipelinesRulesAccuracy(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/pipelines/rules/accuracy", nil, query, nil)
}

// GetProcedures: List your runbooks and their approved versions (GET /v1/procedures)
func (c *Client) GetProcedures(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/procedures", nil, query, nil)
}

// GetProceduresById: Read one runbook with its versions (GET /v1/procedures/{id})
func (c *Client) GetProceduresById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/procedures/%s", url.PathEscape(id)), nil, query, nil)
}

// GetProceduresLibrary: Read your account's private library of approved procedures (GET /v1/procedures/library)
func (c *Client) GetProceduresLibrary(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/procedures/library", nil, query, nil)
}

// GetProfiles: List the profiles kept for a window, by service and kind (GET /v1/profiles)
func (c *Client) GetProfiles(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/profiles", nil, query, nil)
}

// GetProfilesDiff: Compare a service's profiles across two windows and see what moved (GET /v1/profiles/diff)
func (c *Client) GetProfilesDiff(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/profiles/diff", nil, query, nil)
}

// GetProfilesFlame: Draw a service's flame graph for a window, with its hottest frames (GET /v1/profiles/flame)
func (c *Client) GetProfilesFlame(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/profiles/flame", nil, query, nil)
}

// GetProtocolConnections: See every system connected by its own protocol, with what Xovris read of it (GET /v1/protocol-connections)
func (c *Client) GetProtocolConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/protocol-connections", nil, query, nil)
}

// GetProvisioningActs: 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)
func (c *Client) GetProvisioningActs(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/provisioning/acts", nil, query, nil)
}

// GetPublicAccount: See who is signed in on this page, and their plan and day (GET /v1/public/account)
func (c *Client) GetPublicAccount(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/account", nil, query, nil)
}

// GetPublicAddressBySlug: Find out whether a xovris.ai address is live or has moved (GET /v1/public/address/{slug})
func (c *Client) GetPublicAddressBySlug(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/address/%s", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicAiActivity: What Xovris did across every workspace - never published (GET /v1/public/ai-activity)
func (c *Client) GetPublicAiActivity(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/ai-activity", nil, query, nil)
}

// GetPublicBadgeByFile: Read a live badge (GET /v1/public/badge/{file})
func (c *Client) GetPublicBadgeByFile(ctx context.Context, file string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/badge/%s", url.PathEscape(file)), nil, query, nil)
}

// GetPublicBuildPublishById: Read how a page being put live is getting on (GET /v1/public/build/publish/{id})
func (c *Client) GetPublicBuildPublishById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/build/publish/%s", url.PathEscape(id)), nil, query, nil)
}

// GetPublicCatalogueMatrix: 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)
func (c *Client) GetPublicCatalogueMatrix(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/catalogue/matrix", nil, query, nil)
}

// GetPublicCataloguePlan: 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)
func (c *Client) GetPublicCataloguePlan(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/catalogue/plan", nil, query, nil)
}

// GetPublicCatalogueScopes: Read every permission a connection asks for, in plain words, why it is needed and what it enables (GET /v1/public/catalogue/scopes)
func (c *Client) GetPublicCatalogueScopes(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/catalogue/scopes", nil, query, nil)
}

// GetPublicCatalogueServices: List the services Xovris connects to (GET /v1/public/catalogue/services)
func (c *Client) GetPublicCatalogueServices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/catalogue/services", nil, query, nil)
}

// GetPublicCatalogueTotals: Read the catalogue's totals (GET /v1/public/catalogue/totals)
func (c *Client) GetPublicCatalogueTotals(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/catalogue/totals", nil, query, nil)
}

// GetPublicCheckChallenge: Get the free check's background challenge (GET /v1/public/check/challenge)
func (c *Client) GetPublicCheckChallenge(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/check/challenge", nil, query, nil)
}

// GetPublicCheckProof: Prove you own a domain for the free check (GET /v1/public/check/proof)
func (c *Client) GetPublicCheckProof(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/check/proof", nil, query, nil)
}

// GetPublicCheckRules: Read the free check's rules (GET /v1/public/check/rules)
func (c *Client) GetPublicCheckRules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/check/rules", nil, query, nil)
}

// GetPublicConversationsByToken: Read a conversation someone shared with a link (GET /v1/public/conversations/{token})
func (c *Client) GetPublicConversationsByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/conversations/%s", url.PathEscape(token)), nil, query, nil)
}

// GetPublicCounters: Read the live counters of Xovris's own systems (GET /v1/public/counters)
func (c *Client) GetPublicCounters(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/counters", nil, query, nil)
}

// GetPublicDashboardsByToken: Read a shared dashboard (GET /v1/public/dashboards/{token})
func (c *Client) GetPublicDashboardsByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/dashboards/%s", url.PathEscape(token)), nil, query, nil)
}

// GetPublicDemoSlots: See the times a person from Xovris can show you Xovris (GET /v1/public/demo/slots)
func (c *Client) GetPublicDemoSlots(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/demo/slots", nil, query, nil)
}

// GetPublicDeviceAppByTarget: Download the Xovris device app for one system - the file the one-line install fetches (GET /v1/public/device-app/{target})
func (c *Client) GetPublicDeviceAppByTarget(ctx context.Context, target string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/device-app/%s", url.PathEscape(target)), nil, query, nil)
}

// GetPublicDown: Read whether popular services are up (GET /v1/public/down)
func (c *Client) GetPublicDown(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/down", nil, query, nil)
}

// GetPublicDownByService: Read a service's last day of probes (GET /v1/public/down/{service})
func (c *Client) GetPublicDownByService(ctx context.Context, service string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/down/%s", url.PathEscape(service)), nil, query, nil)
}

// GetPublicHandoffByToken: Open a waiting job's one-press page from its notice, no sign-in needed (GET /v1/public/handoff/{token})
func (c *Client) GetPublicHandoffByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/handoff/%s", url.PathEscape(token)), nil, query, nil)
}

// GetPublicHostnameByHost: Find which workspace address an attached domain serves (GET /v1/public/hostname/{host})
func (c *Client) GetPublicHostnameByHost(ctx context.Context, host string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/hostname/%s", url.PathEscape(host)), nil, query, nil)
}

// GetPublicHosts: Download every outside host Xovris has identified, so a page's scripts are matched on your own device (GET /v1/public/hosts)
func (c *Client) GetPublicHosts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/hosts", nil, query, nil)
}

// GetPublicIntegrationProgramme: Read the integration programme (GET /v1/public/integration-programme)
func (c *Client) GetPublicIntegrationProgramme(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/integration-programme", nil, query, nil)
}

// GetPublicIntegrationProgrammeServices: List the integration programme's services (GET /v1/public/integration-programme/services)
func (c *Client) GetPublicIntegrationProgrammeServices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/integration-programme/services", nil, query, nil)
}

// GetPublicLearning: Read how Xovris's speed and first-time fixes change week by week (GET /v1/public/learning)
func (c *Client) GetPublicLearning(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/learning", nil, query, nil)
}

// GetPublicLivePreviewsById: Read a shared page - its newest version, or wait for the next one (GET /v1/public/live-previews/{id})
func (c *Client) GetPublicLivePreviewsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/live-previews/%s", url.PathEscape(id)), nil, query, nil)
}

// GetPublicMailCheckByToken: What the message sent to an email check proved - SPF, DKIM, DMARC and its encryption (GET /v1/public/mail-check/{token})
func (c *Client) GetPublicMailCheckByToken(ctx context.Context, token string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/mail-check/%s", url.PathEscape(token)), nil, query, nil)
}

// GetPublicMcp: The free MCP endpoint answers POST only (GET /v1/public/mcp)
func (c *Client) GetPublicMcp(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/mcp", nil, query, nil)
}

// GetPublicMemory: Read what Xovris remembers of the signed-in person - preferences, decisions, past fixes and what they asked it to keep (GET /v1/public/memory)
func (c *Client) GetPublicMemory(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/memory", nil, query, nil)
}

// GetPublicModels: List every AI model the signed-in person can choose in a chat, with its price (GET /v1/public/models)
func (c *Client) GetPublicModels(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/models", nil, query, nil)
}

// GetPublicModelsCount: See how many AI models and makers you can choose from once signed in (GET /v1/public/models/count)
func (c *Client) GetPublicModelsCount(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/models/count", nil, query, nil)
}

// GetPublicOwnControls: See the trust page's controls, each lit from Xovris's own records (GET /v1/public/own-controls)
func (c *Client) GetPublicOwnControls(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/own-controls", nil, query, nil)
}

// GetPublicPlans: Read every plan's price in every currency, what it is priced on and what it includes, without signing in (GET /v1/public/plans)
func (c *Client) GetPublicPlans(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/plans", nil, query, nil)
}

// GetPublicRandomServiceTest: Read a randomly drawn sample of service tests (GET /v1/public/random-service-test)
func (c *Client) GetPublicRandomServiceTest(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/random-service-test", nil, query, nil)
}

// GetPublicReceiptKey: Read the public key that fix receipts are signed with (GET /v1/public/receipt-key)
func (c *Client) GetPublicReceiptKey(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/receipt-key", nil, query, nil)
}

// GetPublicRecipesRecords: Read each set-up method's verified record before it runs (GET /v1/public/recipes/records)
func (c *Client) GetPublicRecipesRecords(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/recipes/records", nil, query, nil)
}

// GetPublicResults: Read Xovris's published results (GET /v1/public/results)
func (c *Client) GetPublicResults(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/results", nil, query, nil)
}

// GetPublicRunLessons: 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)
func (c *Client) GetPublicRunLessons(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/run-lessons", nil, query, nil)
}

// GetPublicSample: A sample workspace to look around in without an account (GET /v1/public/sample)
func (c *Client) GetPublicSample(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/sample", nil, query, nil)
}

// GetPublicSchemasXosV1Json: The XOS schema every verdict, proof and confidence is written in (GET /v1/public/schemas/xos-v1.json)
func (c *Client) GetPublicSchemasXosV1Json(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/schemas/xos-v1.json", nil, query, nil)
}

// GetPublicScoreboard: Read the scoreboard of verified fixes, root causes and false fixes - Xovris beside the best rival (GET /v1/public/scoreboard)
func (c *Client) GetPublicScoreboard(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/scoreboard", nil, query, nil)
}

// GetPublicSdks: List every SDK Xovris reads (GET /v1/public/sdks)
func (c *Client) GetPublicSdks(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/sdks", nil, query, nil)
}

// GetPublicSelfFixes: Read the times Xovris healed its own service, what it did and how it was undone (GET /v1/public/self-fixes)
func (c *Client) GetPublicSelfFixes(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/self-fixes", nil, query, nil)
}

// GetPublicSignInByProvider: Sign in with Google, GitHub, Apple or Microsoft, and come back to the page (GET /v1/public/sign-in/{provider})
func (c *Client) GetPublicSignInByProvider(ctx context.Context, provider string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/sign-in/%s", url.PathEscape(provider)), nil, query, nil)
}

// GetPublicSiteErrors: Read the website error reporting contract (GET /v1/public/site-errors)
func (c *Client) GetPublicSiteErrors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/site-errors", nil, query, nil)
}

// GetPublicSpeed: Read how quickly Xovris finds causes and proves fixes, by kind of problem (GET /v1/public/speed)
func (c *Client) GetPublicSpeed(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/speed", nil, query, nil)
}

// GetPublicSsoDomain: See whether an email address signs in through its company's own identity provider (GET /v1/public/sso/domain)
func (c *Client) GetPublicSsoDomain(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/sso/domain", nil, query, nil)
}

// GetPublicStatus: Read Xovris's own status (GET /v1/public/status)
func (c *Client) GetPublicStatus(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/status", nil, query, nil)
}

// GetPublicStatusBySlug: Read a workspace's public status page (GET /v1/public/status/{slug})
func (c *Client) GetPublicStatusBySlug(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugBadgeSvg: A workspace's status as one image any site shows (GET /v1/public/status/{slug}/badge.svg)
func (c *Client) GetPublicStatusBySlugBadgeSvg(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/badge.svg", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugConfirm: The press that confirms a status page subscription; opening it changes nothing (GET /v1/public/status/{slug}/confirm)
func (c *Client) GetPublicStatusBySlugConfirm(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/confirm", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugFeedAtom: A workspace's status page as an Atom feed for any reader (GET /v1/public/status/{slug}/feed.atom)
func (c *Client) GetPublicStatusBySlugFeedAtom(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/feed.atom", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugFeedRss: A workspace's status page as an RSS 2.0 feed for any reader (GET /v1/public/status/{slug}/feed.rss)
func (c *Client) GetPublicStatusBySlugFeedRss(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/feed.rss", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugIncidentsById: Read one incident on a workspace's status page, with every update (GET /v1/public/status/{slug}/incidents/{id})
func (c *Client) GetPublicStatusBySlugIncidentsById(ctx context.Context, slug string, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/incidents/%s", url.PathEscape(slug), url.PathEscape(id)), nil, query, nil)
}

// GetPublicStatusBySlugRead: 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)
func (c *Client) GetPublicStatusBySlugRead(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/read", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugUnlock: 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)
func (c *Client) GetPublicStatusBySlugUnlock(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/unlock", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugUnsubscribe: The press that stops a status page's emails; opening it changes nothing (GET /v1/public/status/{slug}/unsubscribe)
func (c *Client) GetPublicStatusBySlugUnsubscribe(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/unsubscribe", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusBySlugWidget: A workspace's live status in one frame any site shows (GET /v1/public/status/{slug}/widget)
func (c *Client) GetPublicStatusBySlugWidget(ctx context.Context, slug string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status/%s/widget", url.PathEscape(slug)), nil, query, nil)
}

// GetPublicStatusFeed: Follow incidents as a feed in any reader, no email needed (GET /v1/public/status/feed)
func (c *Client) GetPublicStatusFeed(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/status/feed", nil, query, nil)
}

// GetPublicStatusHostByHost: Read a workspace's status page on its own hostname (GET /v1/public/status-host/{host})
func (c *Client) GetPublicStatusHostByHost(ctx context.Context, host string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/status-host/%s", url.PathEscape(host)), nil, query, nil)
}

// GetPublicSubProcessors: Read the companies that process customer data for Xovris, and why (GET /v1/public/sub-processors)
func (c *Client) GetPublicSubProcessors(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/public/sub-processors", nil, query, nil)
}

// GetPublicTvPairingsByPairingId: Check whether a TV has been paired (GET /v1/public/tv/pairings/{pairingId})
func (c *Client) GetPublicTvPairingsByPairingId(ctx context.Context, pairingId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/public/tv/pairings/%s", url.PathEscape(pairingId)), nil, query, nil)
}

// GetQueries: List saved queries (GET /v1/queries)
func (c *Client) GetQueries(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/queries", nil, query, nil)
}

// GetReadings: List what Xovris read by itself, and what it found (GET /v1/readings)
func (c *Client) GetReadings(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/readings", nil, query, nil)
}

// GetRecoveries: List the money recovered in a month (GET /v1/recoveries)
func (c *Client) GetRecoveries(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/recoveries", nil, query, nil)
}

// GetReportsOwner: Read the owner's monthly report: what broke, what was fixed and what it saved (GET /v1/reports/owner)
func (c *Client) GetReportsOwner(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reports/owner", nil, query, nil)
}

// GetReviews: See your code reviews over time - raised, fixed, proven and dismissed (GET /v1/reviews)
func (c *Client) GetReviews(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews", nil, query, nil)
}

// GetReviewsBill: 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)
func (c *Client) GetReviewsBill(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/bill", nil, query, nil)
}

// GetReviewsById: Read one review pass reading by reading - what it read, found and fixed (GET /v1/reviews/{id})
func (c *Client) GetReviewsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/reviews/%s", url.PathEscape(id)), nil, query, nil)
}

// GetReviewsChats: See the Discord and Google Chat apps connected to Xovris (GET /v1/reviews/chats)
func (c *Client) GetReviewsChats(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/chats", nil, query, nil)
}

// GetReviewsFindings: Narrow the code review findings on every axis at once, with a count on every value (GET /v1/reviews/findings)
func (c *Client) GetReviewsFindings(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/findings", nil, query, nil)
}

// GetReviewsHosts: See the Git hosts connected to Xovris for reviews (GET /v1/reviews/hosts)
func (c *Client) GetReviewsHosts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/hosts", nil, query, nil)
}

// GetReviewsImageBill: Read a container image's bill of materials from its own registry, or download it as CycloneDX or SPDX (GET /v1/reviews/image-bill)
func (c *Client) GetReviewsImageBill(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/image-bill", nil, query, nil)
}

// GetReviewsLicencePolicy: See your workspace's licence policy and who set it (GET /v1/reviews/licence-policy)
func (c *Client) GetReviewsLicencePolicy(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/licence-policy", nil, query, nil)
}

// GetReviewsLive: Read the whole live state a code review holds a change to, as one readings document for a local review (GET /v1/reviews/live)
func (c *Client) GetReviewsLive(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/live", nil, query, nil)
}

// GetReviewsLiveHosts: Read the names the workspace's checks reach, which a code review checks a change to hosting against (GET /v1/reviews/live-hosts)
func (c *Client) GetReviewsLiveHosts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/live-hosts", nil, query, nil)
}

// GetReviewsLiveZones: Read the live DNS zones a code review checks a change against (GET /v1/reviews/live-zones)
func (c *Client) GetReviewsLiveZones(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/live-zones", nil, query, nil)
}

// GetReviewsPreferences: Read the code review preferences that apply to a repository (GET /v1/reviews/preferences)
func (c *Client) GetReviewsPreferences(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/preferences", nil, query, nil)
}

// GetReviewsQueue: Read every open pull request ranked by what each needs next (GET /v1/reviews/queue)
func (c *Client) GetReviewsQueue(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/queue", nil, query, nil)
}

// GetReviewsReport: Read the report of your code reviews for a period (GET /v1/reviews/report)
func (c *Client) GetReviewsReport(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/report", nil, query, nil)
}

// GetReviewsSchedules: The workspace's scheduled coding automations and when each runs next (GET /v1/reviews/schedules)
func (c *Client) GetReviewsSchedules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/schedules", nil, query, nil)
}

// GetReviewsStandards: See your code reviews' security findings counted by the OWASP Top 10 or the CWE Top 25 (GET /v1/reviews/standards)
func (c *Client) GetReviewsStandards(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/standards", nil, query, nil)
}

// GetReviewsTasksById: Read one coding task: where it is, what was done and the change it made (GET /v1/reviews/tasks/{id})
func (c *Client) GetReviewsTasksById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/reviews/tasks/%s", url.PathEscape(id)), nil, query, nil)
}

// GetReviewsTracker: The tracker the workspace's chosen findings are filed in, never its token (GET /v1/reviews/tracker)
func (c *Client) GetReviewsTracker(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/tracker", nil, query, nil)
}

// GetReviewsViews: List the views of the code review findings you saved (GET /v1/reviews/views)
func (c *Client) GetReviewsViews(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/reviews/views", nil, query, nil)
}

// GetRoleGrants: 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)
func (c *Client) GetRoleGrants(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/role-grants", nil, query, nil)
}

// GetRoles: List this workspace's custom roles, and the deleted ones that can still be restored (GET /v1/roles)
func (c *Client) GetRoles(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/roles", nil, query, nil)
}

// GetRumBroken: Screens broken after an HTTP 200 by cohort, their fault, repair and proof (GET /v1/rum/broken)
func (c *Client) GetRumBroken(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/rum/broken", nil, query, nil)
}

// GetRumExternal: Replays read from Sentry, PostHog or Microsoft Clarity (GET /v1/rum/external)
func (c *Client) GetRumExternal(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/rum/external", nil, query, nil)
}

// GetRumFilm: A fix's before-and-after film of what the customer saw (GET /v1/rum/film)
func (c *Client) GetRumFilm(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/rum/film", nil, query, nil)
}

// GetRumPlatforms: Replay, masking, consent, limits and retention for each platform (GET /v1/rum/platforms)
func (c *Client) GetRumPlatforms(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/rum/platforms", nil, query, nil)
}

// GetRumReplaysBySession: A session's masked replay (GET /v1/rum/replays/{session})
func (c *Client) GetRumReplaysBySession(ctx context.Context, session string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/rum/replays/%s", url.PathEscape(session)), nil, query, nil)
}

// GetRumSessions: Real-user sessions of the last day, with their cohort and broken screens (GET /v1/rum/sessions)
func (c *Client) GetRumSessions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/rum/sessions", nil, query, nil)
}

// GetRumSessionsById: One session's masked signals, feedback and replay (GET /v1/rum/sessions/{id})
func (c *Client) GetRumSessionsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/rum/sessions/%s", url.PathEscape(id)), nil, query, nil)
}

// GetSandbox: Read your developer sandbox (GET /v1/sandbox)
func (c *Client) GetSandbox(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sandbox", nil, query, nil)
}

// GetScimV2Groups: 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)
func (c *Client) GetScimV2Groups(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/scim/v2/Groups", nil, query, nil)
}

// GetScimV2GroupsById: 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})
func (c *Client) GetScimV2GroupsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/scim/v2/Groups/%s", url.PathEscape(id)), nil, query, nil)
}

// GetScimV2ResourceTypes: The SCIM resource types this workspace provisions - people, with their Xovris role, and groups, as teams (GET /v1/scim/v2/ResourceTypes)
func (c *Client) GetScimV2ResourceTypes(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/scim/v2/ResourceTypes", nil, query, nil)
}

// GetScimV2ServiceProviderConfig: What this SCIM 2.0 service supports, for the identity provider that connects to it (GET /v1/scim/v2/ServiceProviderConfig)
func (c *Client) GetScimV2ServiceProviderConfig(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/scim/v2/ServiceProviderConfig", nil, query, nil)
}

// GetScimV2Users: Everyone the identity provider sees here - members and invitations still waiting - filtered by userName (GET /v1/scim/v2/Users)
func (c *Client) GetScimV2Users(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/scim/v2/Users", nil, query, nil)
}

// GetScimV2UsersById: One provisioned person by their SCIM id, the same before and after their first sign-in (GET /v1/scim/v2/Users/{id})
func (c *Client) GetScimV2UsersById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/scim/v2/Users/%s", url.PathEscape(id)), nil, query, nil)
}

// GetSearches: List the searches you saved on a list, and the ones shared with your workspace (GET /v1/searches)
func (c *Client) GetSearches(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/searches", nil, query, nil)
}

// GetSecurityPosture: Read your monthly security score and the fixes that raise it most (GET /v1/security/posture)
func (c *Client) GetSecurityPosture(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/security/posture", nil, query, nil)
}

// GetSecurityStackActions: See every action Xovris took through your security tools (GET /v1/security-stack/actions)
func (c *Client) GetSecurityStackActions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/security-stack/actions", nil, query, nil)
}

// GetSecurityStackConnections: List the security tools connected to Xovris (GET /v1/security-stack/connections)
func (c *Client) GetSecurityStackConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/security-stack/connections", nil, query, nil)
}

// GetSecurityStackDevices: List the devices your security tools see (GET /v1/security-stack/devices)
func (c *Client) GetSecurityStackDevices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/security-stack/devices", nil, query, nil)
}

// GetSecurityZeroDays: What Xovris read as exploited with no CVE, and each maker's report with its contact and exact words (GET /v1/security/zero-days)
func (c *Client) GetSecurityZeroDays(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/security/zero-days", nil, query, nil)
}

// GetSentryIssues: List issues from your Sentry account (GET /v1/sentry/issues)
func (c *Client) GetSentryIssues(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sentry/issues", nil, query, nil)
}

// GetSessions: List your AI work sessions running in the cloud and what each is doing now (GET /v1/sessions)
func (c *Client) GetSessions(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sessions", nil, query, nil)
}

// GetSessionsAway: Read what your sessions did while you were away (GET /v1/sessions/away)
func (c *Client) GetSessionsAway(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sessions/away", nil, query, nil)
}

// GetSessionsDevices: List the devices that follow your sessions (GET /v1/sessions/devices)
func (c *Client) GetSessionsDevices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sessions/devices", nil, query, nil)
}

// GetSessionsOrder: Read the order your devices are told in when a session needs you (GET /v1/sessions/order)
func (c *Client) GetSessionsOrder(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sessions/order", nil, query, nil)
}

// GetSettingsAiLimit: Read your monthly limit on AI fixes (GET /v1/settings/ai-limit)
func (c *Client) GetSettingsAiLimit(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/ai-limit", nil, query, nil)
}

// GetSettingsAutonomy: Read what Xovris may fix on its own (GET /v1/settings/autonomy)
func (c *Client) GetSettingsAutonomy(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/autonomy", nil, query, nil)
}

// GetSettingsAutonomyPreview: Preview what Xovris would do on its own under a way of acting (GET /v1/settings/autonomy/preview)
func (c *Client) GetSettingsAutonomyPreview(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/autonomy/preview", nil, query, nil)
}

// GetSettingsBilling: Read your invoices, in exact amounts, and how payment is set up (GET /v1/settings/billing)
func (c *Client) GetSettingsBilling(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/billing", nil, query, nil)
}

// GetSettingsBillingAll: Read one bill of fixed issues across every workspace whose billing you can read (GET /v1/settings/billing/all)
func (c *Client) GetSettingsBillingAll(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/billing/all", nil, query, nil)
}

// GetSettingsBillingEligibility: Read the workspace's education and non-profit standing, each with the register readings that settled it (GET /v1/settings/billing/eligibility)
func (c *Client) GetSettingsBillingEligibility(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/billing/eligibility", nil, query, nil)
}

// GetSettingsChangeControls: Read when and how Xovris may change things (GET /v1/settings/change-controls)
func (c *Client) GetSettingsChangeControls(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/change-controls", nil, query, nil)
}

// GetSettingsChangeWindows: Read the maintenance windows and freezes in force (GET /v1/settings/change-windows)
func (c *Client) GetSettingsChangeWindows(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/change-windows", nil, query, nil)
}

// GetSettingsNotifyRules: Read who is told what, and on which channels (GET /v1/settings/notify-rules)
func (c *Client) GetSettingsNotifyRules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/notify-rules", nil, query, nil)
}

// GetSettingsPlan: Read your plan and what you have used (GET /v1/settings/plan)
func (c *Client) GetSettingsPlan(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/plan", nil, query, nil)
}

// GetSettingsQuietHours: Read your quiet hours and what a high alert does during them (GET /v1/settings/quiet-hours)
func (c *Client) GetSettingsQuietHours(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/quiet-hours", nil, query, nil)
}

// GetSettingsSignIn: Read whether every member must sign in with a passkey, and who has none yet (GET /v1/settings/sign-in)
func (c *Client) GetSettingsSignIn(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/sign-in", nil, query, nil)
}

// GetSettingsSpendLimit: Read your monthly spending limit on AI fixes (GET /v1/settings/spend-limit)
func (c *Client) GetSettingsSpendLimit(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/settings/spend-limit", nil, query, nil)
}

// GetSetup: Read your setup (GET /v1/setup)
func (c *Client) GetSetup(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup", nil, query, nil)
}

// GetSetupBeginnerReport: Read how much a person had to do to get set up (GET /v1/setup/beginner-report)
func (c *Client) GetSetupBeginnerReport(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/beginner-report", nil, query, nil)
}

// GetSetupGrants: List standing permissions (GET /v1/setup/grants)
func (c *Client) GetSetupGrants(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/grants", nil, query, nil)
}

// GetSetupHealth: Read your setup's health (GET /v1/setup/health)
func (c *Client) GetSetupHealth(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/health", nil, query, nil)
}

// GetSetupRecipes: List every set-up Xovris can run, with what it changes, the keys it needs and the outcome it proves (GET /v1/setup/recipes)
func (c *Client) GetSetupRecipes(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/recipes", nil, query, nil)
}

// GetSetupResearch: List the providers Xovris has researched for this workspace, newest first (GET /v1/setup/research)
func (c *Client) GetSetupResearch(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/research", nil, query, nil)
}

// GetSetupResearchById: Read what Xovris found about a provider, and what is still unknown (GET /v1/setup/research/{id})
func (c *Client) GetSetupResearchById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/research/%s", url.PathEscape(id)), nil, query, nil)
}

// GetSetupRuns: List your set-ups on the runner (GET /v1/setup/runs)
func (c *Client) GetSetupRuns(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/runs", nil, query, nil)
}

// GetSetupRunsById: Read a set-up with its diagnosis and verified outcome (GET /v1/setup/runs/{id})
func (c *Client) GetSetupRunsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/runs/%s", url.PathEscape(id)), nil, query, nil)
}

// GetSetupTakeovers: List hand-overs and the fixes made in full control (GET /v1/setup/takeovers)
func (c *Client) GetSetupTakeovers(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/takeovers", nil, query, nil)
}

// GetSetupTakeoversById: Read a hand-over (GET /v1/setup/takeovers/{id})
func (c *Client) GetSetupTakeoversById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/takeovers/%s", url.PathEscape(id)), nil, query, nil)
}

// GetSetupTakeoversByIdEvidence: See the replayed runs of Xovris's browser for a set-up (GET /v1/setup/takeovers/{id}/evidence)
func (c *Client) GetSetupTakeoversByIdEvidence(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/takeovers/%s/evidence", url.PathEscape(id)), nil, query, nil)
}

// GetSetupTakeoversByIdEvidenceByRunBySeq: See one recorded step of a set-up, as it happened (GET /v1/setup/takeovers/{id}/evidence/{run}/{seq})
func (c *Client) GetSetupTakeoversByIdEvidenceByRunBySeq(ctx context.Context, id string, run string, seq string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/takeovers/%s/evidence/%s/%s", url.PathEscape(id), url.PathEscape(run), url.PathEscape(seq)), nil, query, nil)
}

// GetSetupTakeoversByIdEvidenceByRunRedrive: See how a replayed set-up went (GET /v1/setup/takeovers/{id}/evidence/{run}/redrive)
func (c *Client) GetSetupTakeoversByIdEvidenceByRunRedrive(ctx context.Context, id string, run string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/takeovers/%s/evidence/%s/redrive", url.PathEscape(id), url.PathEscape(run)), nil, query, nil)
}

// GetSetupTakeoversByIdFrame: Read a hand-over's live view (GET /v1/setup/takeovers/{id}/frame)
func (c *Client) GetSetupTakeoversByIdFrame(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/setup/takeovers/%s/frame", url.PathEscape(id)), nil, query, nil)
}

// GetSetupTakeoversPlans: List what Xovris can set up for you (GET /v1/setup/takeovers/plans)
func (c *Client) GetSetupTakeoversPlans(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/takeovers/plans", nil, query, nil)
}

// GetSetupTestAlerts: See the test alerts sent and whether each arrived (GET /v1/setup/test-alerts)
func (c *Client) GetSetupTestAlerts(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/setup/test-alerts", nil, query, nil)
}

// GetShell: Read the side menu's figures in one answer (GET /v1/shell)
func (c *Client) GetShell(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/shell", nil, query, nil)
}

// GetSpendDaily: 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)
func (c *Client) GetSpendDaily(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/spend/daily", nil, query, nil)
}

// GetSsoProviders: See this workspace's company sign-ins - each identity provider, its email domain and whether the domain is proved (GET /v1/sso/providers)
func (c *Client) GetSsoProviders(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/sso/providers", nil, query, nil)
}

// GetSsoProvidersByProviderIdExchanges: 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)
func (c *Client) GetSsoProvidersByProviderIdExchanges(ctx context.Context, providerId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/sso/providers/%s/exchanges", url.PathEscape(providerId)), nil, query, nil)
}

// GetStatusPage: Read your status page, its preview and drafted updates (GET /v1/status-page)
func (c *Client) GetStatusPage(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/status-page", nil, query, nil)
}

// GetStatusPageDomain: See the domain your status page is served on, and what is still to set (GET /v1/status-page/domain)
func (c *Client) GetStatusPageDomain(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/status-page/domain", nil, query, nil)
}

// GetStatusPages: Every status page the workspace keeps, each with its address and whether it is published (GET /v1/status-pages)
func (c *Client) GetStatusPages(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/status-pages", nil, query, nil)
}

// GetStatusSentence: Read one plain sentence on how your workspace stands right now (GET /v1/status-sentence)
func (c *Client) GetStatusSentence(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/status-sentence", nil, query, nil)
}

// GetStorageWaste: List storage savings planned and proved (GET /v1/storage/waste)
func (c *Client) GetStorageWaste(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/storage/waste", nil, query, nil)
}

// GetStripe: Read your Stripe payments health (GET /v1/stripe)
func (c *Client) GetStripe(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/stripe", nil, query, nil)
}

// GetStripeConnect: Connect Stripe in one press, approved in Stripe (GET /v1/stripe/connect)
func (c *Client) GetStripeConnect(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/stripe/connect", nil, query, nil)
}

// GetStripeConnectCallback: Finish connecting Stripe after approving it in Stripe (GET /v1/stripe/connect/callback)
func (c *Client) GetStripeConnectCallback(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/stripe/connect/callback", nil, query, nil)
}

// GetSystems: List the systems you connected by their address (GET /v1/systems)
func (c *Client) GetSystems(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/systems", nil, query, nil)
}

// GetSystemsById: Read one connected system: what Xovris read of it and what it looks after (GET /v1/systems/{id})
func (c *Client) GetSystemsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/systems/%s", url.PathEscape(id)), nil, query, nil)
}

// GetSystemsGeneralRunsJobsByJobRecordExport: Download a job's signed recording (GET /v1/systems/general-runs/jobs/{job}/record/export)
func (c *Client) GetSystemsGeneralRunsJobsByJobRecordExport(ctx context.Context, job string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/systems/general-runs/jobs/%s/record/export", url.PathEscape(job)), nil, query, nil)
}

// GetSystemsGeneralRunsLearned: What Xovris learned from past jobs on your systems (GET /v1/systems/general-runs/learned)
func (c *Client) GetSystemsGeneralRunsLearned(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/systems/general-runs/learned", nil, query, nil)
}

// GetSystemsGeneralRunsMemory: See every rule Xovris keeps from your corrections, and your consent (GET /v1/systems/general-runs/memory)
func (c *Client) GetSystemsGeneralRunsMemory(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/systems/general-runs/memory", nil, query, nil)
}

// GetSystemsGeneralRunsSchedules: See the checks Xovris runs for you unasked (GET /v1/systems/general-runs/schedules)
func (c *Client) GetSystemsGeneralRunsSchedules(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/systems/general-runs/schedules", nil, query, nil)
}

// GetSystemsGeneralRunsStanding: See every standing yes you gave Xovris to do a job again next time (GET /v1/systems/general-runs/standing)
func (c *Client) GetSystemsGeneralRunsStanding(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/systems/general-runs/standing", nil, query, nil)
}

// GetSystemsProfiles: List connected systems (GET /v1/systems/profiles)
func (c *Client) GetSystemsProfiles(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/systems/profiles", nil, query, nil)
}

// GetSystemsProfilesByProviderActions: List what Xovris can do in a system (GET /v1/systems/profiles/{provider}/actions)
func (c *Client) GetSystemsProfilesByProviderActions(ctx context.Context, provider string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/systems/profiles/%s/actions", url.PathEscape(provider)), nil, query, nil)
}

// GetSystemsProfilesByProviderChanges: List the changes made in a system (GET /v1/systems/profiles/{provider}/changes)
func (c *Client) GetSystemsProfilesByProviderChanges(ctx context.Context, provider string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/systems/profiles/%s/changes", url.PathEscape(provider)), nil, query, nil)
}

// GetTeams: 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)
func (c *Client) GetTeams(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/teams", nil, query, nil)
}

// GetTelemetryDiet: Read the telemetry diet (GET /v1/telemetry/diet)
func (c *Client) GetTelemetryDiet(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/telemetry/diet", nil, query, nil)
}

// GetThings: List the things Xovris has met (GET /v1/things)
func (c *Client) GetThings(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/things", nil, query, nil)
}

// GetThingsById: Read a thing Xovris has met (GET /v1/things/{id})
func (c *Client) GetThingsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/things/%s", url.PathEscape(id)), nil, query, nil)
}

// GetTokens: List API tokens (GET /v1/tokens)
func (c *Client) GetTokens(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/tokens", nil, query, nil)
}

// GetTokensByIdCalls: See each call made with an API key, and the control that refused any it did not allow (GET /v1/tokens/{id}/calls)
func (c *Client) GetTokensByIdCalls(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/tokens/%s/calls", url.PathEscape(id)), nil, query, nil)
}

// GetTokensByIdUnusual: See each unusual use of an API key Xovris found (GET /v1/tokens/{id}/unusual)
func (c *Client) GetTokensByIdUnusual(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/tokens/%s/unusual", url.PathEscape(id)), nil, query, nil)
}

// GetToolConnections: List tool connections (GET /v1/tool-connections)
func (c *Client) GetToolConnections(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/tool-connections", nil, query, nil)
}

// GetToolConnectionsByIdDeliveries: Read what was sent to a tool (GET /v1/tool-connections/{id}/deliveries)
func (c *Client) GetToolConnectionsByIdDeliveries(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/tool-connections/%s/deliveries", url.PathEscape(id)), nil, query, nil)
}

// GetToolServers: List the AI tool servers Xovris is connected to (GET /v1/tool-servers)
func (c *Client) GetToolServers(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/tool-servers", nil, query, nil)
}

// GetToolsSecurityHeaders: Grade a site's security headers, with the lines that fix them (GET /v1/tools/security-headers)
func (c *Client) GetToolsSecurityHeaders(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/tools/security-headers", nil, query, nil)
}

// GetTraces: Search the spans of kept traces (GET /v1/traces)
func (c *Client) GetTraces(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces", nil, query, nil)
}

// GetTracesByTraceId: Read a kept trace (GET /v1/traces/{traceId})
func (c *Client) GetTracesByTraceId(ctx context.Context, traceId string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/traces/%s", url.PathEscape(traceId)), nil, query, nil)
}

// GetTracesHeatmap: Read the latency heatmap of the workspace's traces (GET /v1/traces/heatmap)
func (c *Client) GetTracesHeatmap(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/heatmap", nil, query, nil)
}

// GetTracesPaths: See every endpoint's traffic, errors and speed (GET /v1/traces/paths)
func (c *Client) GetTracesPaths(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/paths", nil, query, nil)
}

// GetTracesRegression: Find who a slowdown hit, why, and whether the average hides it (GET /v1/traces/regression)
func (c *Client) GetTracesRegression(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/regression", nil, query, nil)
}

// GetTracesSampling: See what trace sampling kept and removed (GET /v1/traces/sampling)
func (c *Client) GetTracesSampling(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/sampling", nil, query, nil)
}

// GetTracesSelection: Read the traces inside a heatmap selection (GET /v1/traces/selection)
func (c *Client) GetTracesSelection(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/selection", nil, query, nil)
}

// GetTracesServiceMap: See how your services call each other (GET /v1/traces/service-map)
func (c *Client) GetTracesServiceMap(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/service-map", nil, query, nil)
}

// GetTracesSlo: Have Xovris write a path's objectives from its own traffic (GET /v1/traces/slo)
func (c *Client) GetTracesSlo(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/traces/slo", nil, query, nil)
}

// GetUploadsById: Read how much of a large file has arrived (GET /v1/uploads/{id})
func (c *Client) GetUploadsById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/uploads/%s", url.PathEscape(id)), nil, query, nil)
}

// GetUploadsByIdContent: A kept file, exactly as it was sent (GET /v1/uploads/{id}/content)
func (c *Client) GetUploadsByIdContent(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/uploads/%s/content", url.PathEscape(id)), nil, query, nil)
}

// GetValue: See what Xovris saved you this month - the time and money, at your own rate if you give one (GET /v1/value)
func (c *Client) GetValue(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/value", nil, query, nil)
}

// GetVendorFixes: See every fix you sent and whether it is waiting, being rehearsed, proven or refused (GET /v1/vendor-fixes)
func (c *Client) GetVendorFixes(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/vendor-fixes", nil, query, nil)
}

// GetViewsBySurface: List the saved views of a page, yours and the ones shared with the workspace (GET /v1/views/{surface})
func (c *Client) GetViewsBySurface(ctx context.Context, surface string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/views/%s", url.PathEscape(surface)), nil, query, nil)
}

// GetVulnerabilities: List software vulnerabilities that affect you (GET /v1/vulnerabilities)
func (c *Client) GetVulnerabilities(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/vulnerabilities", nil, query, nil)
}

// GetVulnerabilitiesDevices: See which of your devices have known vulnerabilities, by real risk (GET /v1/vulnerabilities/devices)
func (c *Client) GetVulnerabilitiesDevices(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/vulnerabilities/devices", nil, query, nil)
}

// GetVulnerabilitiesDevicesIdsBlocks: Every sensor rule Xovris switched to drop, why, its state and when (GET /v1/vulnerabilities/devices/ids-blocks)
func (c *Client) GetVulnerabilitiesDevicesIdsBlocks(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/vulnerabilities/devices/ids-blocks", nil, query, nil)
}

// GetVulnerabilitiesFeeds: See how fresh each vulnerability source Xovris reads is (GET /v1/vulnerabilities/feeds)
func (c *Client) GetVulnerabilitiesFeeds(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/vulnerabilities/feeds", nil, query, nil)
}

// GetVulnerabilitiesFeedsEarly: Read the next page of flaws a maker named before their record, after the last one you were shown (GET /v1/vulnerabilities/feeds/early)
func (c *Client) GetVulnerabilitiesFeedsEarly(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/vulnerabilities/feeds/early", nil, query, nil)
}

// GetWatchByFeatureSetup: See how the app inventory or the insider risk watch is set up, and whether it may run (GET /v1/watch/{feature}/setup)
func (c *Client) GetWatchByFeatureSetup(ctx context.Context, feature string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/watch/%s/setup", url.PathEscape(feature)), nil, query, nil)
}

// GetWatches: List watches (GET /v1/watches)
func (c *Client) GetWatches(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/watches", nil, query, nil)
}

// GetWatchesById: Read a watch (GET /v1/watches/{id})
func (c *Client) GetWatchesById(ctx context.Context, id string, query url.Values) (any, error) {
	return c.call(ctx, "GET", fmt.Sprintf("/v1/watches/%s", url.PathEscape(id)), nil, query, nil)
}

// GetWebFilterAppeals: See the requests to allow blocked web names (GET /v1/web-filter/appeals)
func (c *Client) GetWebFilterAppeals(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/web-filter/appeals", nil, query, nil)
}

// GetWebFilterCategories: List the web categories a filter policy can allow or block (GET /v1/web-filter/categories)
func (c *Client) GetWebFilterCategories(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/web-filter/categories", nil, query, nil)
}

// GetWebFilterPolicy: Read your web filter policy and the version your devices run (GET /v1/web-filter/policy)
func (c *Client) GetWebFilterPolicy(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/web-filter/policy", nil, query, nil)
}

// GetWebhooks: List webhooks (GET /v1/webhooks)
func (c *Client) GetWebhooks(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/webhooks", nil, query, nil)
}

// GetWhatIf: Read what Xovris found by playing every fault it can name on a copy of your setup, blind spots first (GET /v1/what-if)
func (c *Client) GetWhatIf(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/what-if", nil, query, nil)
}

// GetWorkspaceAddress: Read this workspace's free xovris.ai address and whether it is live (GET /v1/workspace/address)
func (c *Client) GetWorkspaceAddress(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/workspace/address", nil, query, nil)
}

// GetWorkspaceAiChecks: Read your AI checks: how often they run, what was looked at and what was found (GET /v1/workspace/ai-checks)
func (c *Client) GetWorkspaceAiChecks(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/workspace/ai-checks", nil, query, nil)
}

// GetWorkspaceDomains: List the domains you have pointed at this workspace and the records each still needs (GET /v1/workspace/domains)
func (c *Client) GetWorkspaceDomains(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/workspace/domains", nil, query, nil)
}

// GetWorkspaceResults: 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)
func (c *Client) GetWorkspaceResults(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/workspace/results", nil, query, nil)
}

// GetWorkspaceSuccessRates: Read what Xovris connected, diagnosed, fixed, verified and undid and proved on each of your systems (GET /v1/workspace/success-rates)
func (c *Client) GetWorkspaceSuccessRates(ctx context.Context, query url.Values) (any, error) {
	return c.call(ctx, "GET", "/v1/workspace/success-rates", nil, query, nil)
}

// PatchAssistRequestsById: Name a conversation in your own words (PATCH /v1/assist/requests/{id})
func (c *Client) PatchAssistRequestsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/assist/requests/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchMe: Correct your own name or email (a new email is proved by a code sent to it) (PATCH /v1/me)
func (c *Client) PatchMe(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", "/v1/me", body, nil, opts)
}

// PatchMembersByUserId: Change a member's role - admin, member, viewer or billing; ownership moves only by a transfer (PATCH /v1/members/{userId})
func (c *Client) PatchMembersByUserId(ctx context.Context, userId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/members/%s", url.PathEscape(userId)), body, nil, opts)
}

// PatchRolesById: 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})
func (c *Client) PatchRolesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/roles/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchScimV2GroupsById: 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})
func (c *Client) PatchScimV2GroupsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/scim/v2/Groups/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchScimV2UsersById: 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})
func (c *Client) PatchScimV2UsersById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/scim/v2/Users/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchSettingsAiLimit: Change your monthly limit on AI fixes (PATCH /v1/settings/ai-limit)
func (c *Client) PatchSettingsAiLimit(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", "/v1/settings/ai-limit", body, nil, opts)
}

// PatchSettingsAutonomyByKind: Change what Xovris may fix on its own, for one kind of change (PATCH /v1/settings/autonomy/{kind})
func (c *Client) PatchSettingsAutonomyByKind(ctx context.Context, kind string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/settings/autonomy/%s", url.PathEscape(kind)), body, nil, opts)
}

// PatchSettingsAutonomyByKindBudget: Set a kind of change's monthly risk budget, in your own words (PATCH /v1/settings/autonomy/{kind}/budget)
func (c *Client) PatchSettingsAutonomyByKindBudget(ctx context.Context, kind string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/settings/autonomy/%s/budget", url.PathEscape(kind)), body, nil, opts)
}

// PatchSettingsAutonomyGuards: Change the guards on fixes Xovris makes on its own (PATCH /v1/settings/autonomy/guards)
func (c *Client) PatchSettingsAutonomyGuards(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", "/v1/settings/autonomy/guards", body, nil, opts)
}

// PatchSsoProvidersByProviderId: 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})
func (c *Client) PatchSsoProvidersByProviderId(ctx context.Context, providerId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/sso/providers/%s", url.PathEscape(providerId)), body, nil, opts)
}

// PatchSystemsGeneralRunsLearnedById: Change the words one learned plan answers to (PATCH /v1/systems/general-runs/learned/{id})
func (c *Client) PatchSystemsGeneralRunsLearnedById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/systems/general-runs/learned/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchSystemsGeneralRunsMemoryRulesById: Change the words one of your rules applies to (PATCH /v1/systems/general-runs/memory/rules/{id})
func (c *Client) PatchSystemsGeneralRunsMemoryRulesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/systems/general-runs/memory/rules/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchTeamsById: 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})
func (c *Client) PatchTeamsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", fmt.Sprintf("/v1/teams/%s", url.PathEscape(id)), body, nil, opts)
}

// PatchWorkspaceAddress: Change this workspace's free xovris.ai address or where it forwards (PATCH /v1/workspace/address)
func (c *Client) PatchWorkspaceAddress(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PATCH", "/v1/workspace/address", body, nil, opts)
}

// PostA2a: Hand Xovris work from another AI agent (A2A SendMessage) (POST /v1/a2a)
func (c *Client) PostA2a(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/a2a", body, nil, opts)
}

// PostAccessAdminLinesById: Hold a connected system to your own line of admins, in place of CIS's two to four (POST /v1/access/admin-lines/{id})
func (c *Client) PostAccessAdminLinesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/access/admin-lines/%s", url.PathEscape(id)), body, nil, opts)
}

// PostAccessFlagsByKeyFix: Fix an access problem Xovris flagged (POST /v1/access/flags/{key}/fix)
func (c *Client) PostAccessFlagsByKeyFix(ctx context.Context, key string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/access/flags/%s/fix", url.PathEscape(key)), body, nil, opts)
}

// PostAccessOwners: Name the owner of a system or account (POST /v1/access/owners)
func (c *Client) PostAccessOwners(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/access/owners", body, nil, opts)
}

// PostAccessReview: Keep an access review on the record, with what was acted on (POST /v1/access/review)
func (c *Client) PostAccessReview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/access/review", body, nil, opts)
}

// PostAccessReviewSignOff: 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)
func (c *Client) PostAccessReviewSignOff(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/access/review/sign-off", body, nil, opts)
}

// PostAccountSessionsEndOthers: Sign out everywhere except here (POST /v1/account/sessions/end-others)
func (c *Client) PostAccountSessionsEndOthers(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/account/sessions/end-others", body, nil, opts)
}

// PostActionsBySeqUndo: Undo a change Xovris made, by its own way back (POST /v1/actions/{seq}/undo)
func (c *Client) PostActionsBySeqUndo(ctx context.Context, seq string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/actions/%s/undo", url.PathEscape(seq)), body, nil, opts)
}

// PostActionsUndoWindow: Undo everything Xovris changed in a window of time, in one press, each change read back (POST /v1/actions/undo-window)
func (c *Client) PostActionsUndoWindow(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/actions/undo-window", body, nil, opts)
}

// PostAgentsA2aCard: Read your own A2A agent's card - who it is and what it says it can do (POST /v1/agents/a2a/card)
func (c *Client) PostAgentsA2aCard(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/agents/a2a/card", body, nil, opts)
}

// PostAgentsA2aSend: 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)
func (c *Client) PostAgentsA2aSend(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/agents/a2a/send", body, nil, opts)
}

// PostAgentsA2aTask: Read how a task your own A2A agent is still working on stands (POST /v1/agents/a2a/task)
func (c *Client) PostAgentsA2aTask(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/agents/a2a/task", body, nil, opts)
}

// PostAlertActionsByIdRules: Call an action from an alert rule (POST /v1/alert-actions/{id}/rules)
func (c *Client) PostAlertActionsByIdRules(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alert-actions/%s/rules", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdDiscordUndo: Take back a Discord channel Xovris added (POST /v1/alerts/channels/{id}/discord/undo)
func (c *Client) PostAlertsChannelsByIdDiscordUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/discord/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdPagerdutyUndo: Take back a PagerDuty service Xovris connected (POST /v1/alerts/channels/{id}/pagerduty/undo)
func (c *Client) PostAlertsChannelsByIdPagerdutyUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/pagerduty/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdTeamsReply: Let Xovris answer when someone mentions it in a Microsoft Teams channel (POST /v1/alerts/channels/{id}/teams/reply)
func (c *Client) PostAlertsChannelsByIdTeamsReply(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/teams/reply", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdTest: Send a test alert (POST /v1/alerts/channels/{id}/test)
func (c *Client) PostAlertsChannelsByIdTest(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/test", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdWebhookHttps: Move a webhook channel to an https address (POST /v1/alerts/channels/{id}/webhook-https)
func (c *Client) PostAlertsChannelsByIdWebhookHttps(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/webhook-https", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdWebhookHttpsUndo: Put a webhook channel back on its earlier address (POST /v1/alerts/channels/{id}/webhook-https/undo)
func (c *Client) PostAlertsChannelsByIdWebhookHttpsUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/webhook-https/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdWebhookSecret: Sign a webhook channel's alerts with a secret (POST /v1/alerts/channels/{id}/webhook-secret)
func (c *Client) PostAlertsChannelsByIdWebhookSecret(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/webhook-secret", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsByIdWebhookSecretUndo: Stop signing a webhook channel's alerts (POST /v1/alerts/channels/{id}/webhook-secret/undo)
func (c *Client) PostAlertsChannelsByIdWebhookSecretUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/channels/%s/webhook-secret/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsChannelsDiscordGrant: Start adding a Discord channel through Discord's own approval (POST /v1/alerts/channels/discord/grant)
func (c *Client) PostAlertsChannelsDiscordGrant(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/discord/grant", body, nil, opts)
}

// PostAlertsChannelsEmail: Add the built-in email channel (POST /v1/alerts/channels/email)
func (c *Client) PostAlertsChannelsEmail(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/email", body, nil, opts)
}

// PostAlertsChannelsNative: Turn on notifications in the Xovris app on this phone (POST /v1/alerts/channels/native)
func (c *Client) PostAlertsChannelsNative(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/native", body, nil, opts)
}

// PostAlertsChannelsOneStep: One-step set-up of an alert channel (POST /v1/alerts/channels/one-step)
func (c *Client) PostAlertsChannelsOneStep(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/one-step", body, nil, opts)
}

// PostAlertsChannelsPagerdutyGrant: Start connecting PagerDuty through PagerDuty's own approval (POST /v1/alerts/channels/pagerduty/grant)
func (c *Client) PostAlertsChannelsPagerdutyGrant(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/pagerduty/grant", body, nil, opts)
}

// PostAlertsChannelsPush: Turn on push alerts on this device (POST /v1/alerts/channels/push)
func (c *Client) PostAlertsChannelsPush(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/push", body, nil, opts)
}

// PostAlertsChannelsPushOff: Turn off push alerts on this device (POST /v1/alerts/channels/push/off)
func (c *Client) PostAlertsChannelsPushOff(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/push/off", body, nil, opts)
}

// PostAlertsChannelsTelegram: Add a Telegram chat (POST /v1/alerts/channels/telegram)
func (c *Client) PostAlertsChannelsTelegram(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/channels/telegram", body, nil, opts)
}

// PostAlertsDeliveryByIdRetry: Retry a delivery (POST /v1/alerts/delivery/{id}/retry)
func (c *Client) PostAlertsDeliveryByIdRetry(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/delivery/%s/retry", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsLimitPoints: Save the points at which you hear about AI spend (POST /v1/alerts/limit-points)
func (c *Client) PostAlertsLimitPoints(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/limit-points", body, nil, opts)
}

// PostAlertsMailServerCheck: Xovris signs in to the workspace's mail server again (POST /v1/alerts/mail-server/check)
func (c *Client) PostAlertsMailServerCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/mail-server/check", body, nil, opts)
}

// PostAlertsPhrase: Save the phrase only your real alerts carry (POST /v1/alerts/phrase)
func (c *Client) PostAlertsPhrase(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/phrase", body, nil, opts)
}

// PostAlertsPhraseWorkspace: Save the phrase every alert in your workspace carries (POST /v1/alerts/phrase/workspace)
func (c *Client) PostAlertsPhraseWorkspace(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/phrase/workspace", body, nil, opts)
}

// PostAlertsPushShown: Record that a push alert was shown on the device (POST /v1/alerts/push/shown)
func (c *Client) PostAlertsPushShown(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/push/shown", body, nil, opts)
}

// PostAlertsRepliesCanaryCode: Read the production check's own sign-in code (POST /v1/alerts/replies/canary-code)
func (c *Client) PostAlertsRepliesCanaryCode(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/replies/canary-code", body, nil, opts)
}

// PostAlertsRepliesEmail: Receive an email to Xovris and answer it by email (POST /v1/alerts/replies/email)
func (c *Client) PostAlertsRepliesEmail(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/replies/email", body, nil, opts)
}

// PostAlertsRepliesTeamsByTenantIdByChannelId: Receive a Microsoft Teams mention of Xovris and answer it in the thread (POST /v1/alerts/replies/teams/{tenantId}/{channelId})
func (c *Client) PostAlertsRepliesTeamsByTenantIdByChannelId(ctx context.Context, tenantId string, channelId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/replies/teams/%s/%s", url.PathEscape(tenantId), url.PathEscape(channelId)), body, nil, opts)
}

// PostAlertsRepliesTwilio: Receive a text or WhatsApp reply to an alert (POST /v1/alerts/replies/twilio)
func (c *Client) PostAlertsRepliesTwilio(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/replies/twilio", body, nil, opts)
}

// PostAlertsRules: Save an alert rule (POST /v1/alerts/rules)
func (c *Client) PostAlertsRules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/rules", body, nil, opts)
}

// PostAlertsRulesPreview: See what an alert rule would do before you save it (POST /v1/alerts/rules/preview)
func (c *Client) PostAlertsRulesPreview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/rules/preview", body, nil, opts)
}

// PostAlertsSendingDomainCheck: Xovris reads the sending domain's records again (POST /v1/alerts/sending-domain/check)
func (c *Client) PostAlertsSendingDomainCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/sending-domain/check", body, nil, opts)
}

// PostAlertsStatusPageDoorConnect: Connect the status page Xovris posts updates to (POST /v1/alerts/status-page-door/connect)
func (c *Client) PostAlertsStatusPageDoorConnect(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/status-page-door/connect", body, nil, opts)
}

// PostAlertsStatusPageDoorDisconnect: Disconnect the status page Xovris posts updates to (POST /v1/alerts/status-page-door/disconnect)
func (c *Client) PostAlertsStatusPageDoorDisconnect(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/status-page-door/disconnect", body, nil, opts)
}

// PostAlertsStatusPageDoorUpdates: Post an update to your connected status page (POST /v1/alerts/status-page-door/updates)
func (c *Client) PostAlertsStatusPageDoorUpdates(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/status-page-door/updates", body, nil, opts)
}

// PostAlertsStatusPageDoorUpdatesByKeyWithdraw: Withdraw an update from your connected status page (POST /v1/alerts/status-page-door/updates/{key}/withdraw)
func (c *Client) PostAlertsStatusPageDoorUpdatesByKeyWithdraw(ctx context.Context, key string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/status-page-door/updates/%s/withdraw", url.PathEscape(key)), body, nil, opts)
}

// PostAlertsSuppressionsUnsuppress: Let a suppressed address receive alerts (POST /v1/alerts/suppressions/unsuppress)
func (c *Client) PostAlertsSuppressionsUnsuppress(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/suppressions/unsuppress", body, nil, opts)
}

// PostAlertsTelegramWebhook: Receive a Telegram message to Xovris (POST /v1/alerts/telegram/webhook)
func (c *Client) PostAlertsTelegramWebhook(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/telegram/webhook", body, nil, opts)
}

// PostAlertsTuningProposalsById: Accept or decline a proposed alert change (POST /v1/alerts/tuning/proposals/{id})
func (c *Client) PostAlertsTuningProposalsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/alerts/tuning/proposals/%s", url.PathEscape(id)), body, nil, opts)
}

// PostAlertsTuningRestore: Put an alert change back as it was (POST /v1/alerts/tuning/restore)
func (c *Client) PostAlertsTuningRestore(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/tuning/restore", body, nil, opts)
}

// PostAlertsTwilioStatus: Record whether a text, call or WhatsApp alert reached the phone (POST /v1/alerts/twilio/status)
func (c *Client) PostAlertsTwilioStatus(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/twilio/status", body, nil, opts)
}

// PostAlertsUnsubscribe: Stop alerts to an address in one press (POST /v1/alerts/unsubscribe)
func (c *Client) PostAlertsUnsubscribe(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/unsubscribe", body, nil, opts)
}

// PostAlertsVoiceAsk: Ask Xovris a question on a phone call (POST /v1/alerts/voice/ask)
func (c *Client) PostAlertsVoiceAsk(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/voice/ask", body, nil, opts)
}

// PostAlertsVoiceGather: Read the keys pressed on an alert call (POST /v1/alerts/voice/gather)
func (c *Client) PostAlertsVoiceGather(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/voice/gather", body, nil, opts)
}

// PostAlertsVoiceInbound: Answer a call to Xovris's number (POST /v1/alerts/voice/inbound)
func (c *Client) PostAlertsVoiceInbound(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/alerts/voice/inbound", body, nil, opts)
}

// PostApiByProjectIdAttachmentsAssembleIndex: Join the parts of a large attachment sent in pieces into one file, kept with its event (POST /api/{projectId}/attachments/assemble/)
func (c *Client) PostApiByProjectIdAttachmentsAssembleIndex(ctx context.Context, projectId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/api/%s/attachments/assemble/", url.PathEscape(projectId)), body, nil, opts)
}

// PostApiByProjectIdChunkUploadIndex: Send one part of a large file, such as a source map or debug file (POST /api/{projectId}/chunk-upload/)
func (c *Client) PostApiByProjectIdChunkUploadIndex(ctx context.Context, projectId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/api/%s/chunk-upload/", url.PathEscape(projectId)), body, nil, opts)
}

// PostApiByProjectIdEnvelopeIndex: Send events from a Sentry SDK (POST /api/{projectId}/envelope/)
func (c *Client) PostApiByProjectIdEnvelopeIndex(ctx context.Context, projectId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/api/%s/envelope/", url.PathEscape(projectId)), body, nil, opts)
}

// PostApiByProjectIdSecurityIndex: Send browser security reports (POST /api/{projectId}/security/)
func (c *Client) PostApiByProjectIdSecurityIndex(ctx context.Context, projectId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/api/%s/security/", url.PathEscape(projectId)), body, nil, opts)
}

// PostApiByProjectIdStoreIndex: Send one event from an older Sentry SDK (POST /api/{projectId}/store/)
func (c *Client) PostApiByProjectIdStoreIndex(ctx context.Context, projectId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/api/%s/store/", url.PathEscape(projectId)), body, nil, opts)
}

// PostApiV2Logs: Send logs in the Datadog format (POST /api/v2/logs)
func (c *Client) PostApiV2Logs(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/api/v2/logs", body, nil, opts)
}

// PostAppsAiAccess: Review who has access to what: leavers' accounts, stale and admin accounts, each with its decision (POST /v1/apps/ai/access)
func (c *Client) PostAppsAiAccess(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/access", body, nil, opts)
}

// PostAppsAiAdoption: See AI adoption and spend month by month, and next month's spend (POST /v1/apps/ai/adoption)
func (c *Client) PostAppsAiAdoption(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/adoption", body, nil, opts)
}

// PostAppsAiAgents: 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)
func (c *Client) PostAppsAiAgents(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/agents", body, nil, opts)
}

// PostAppsAiBreaches: See the breaches of vendors in use, each told once with what Xovris does (POST /v1/apps/ai/breaches)
func (c *Client) PostAppsAiBreaches(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/breaches", body, nil, opts)
}

// PostAppsAiConversations: 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)
func (c *Client) PostAppsAiConversations(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/conversations", body, nil, opts)
}

// PostAppsAiFlows: See company data flowing from each app into each AI tool, drawn (POST /v1/apps/ai/flows)
func (c *Client) PostAppsAiFlows(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/flows", body, nil, opts)
}

// PostAppsAiGrants: See the risk of each app grant from what its scopes reach, with revoke, review or keep (POST /v1/apps/ai/grants)
func (c *Client) PostAppsAiGrants(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/grants", body, nil, opts)
}

// PostAppsAiGuard: Decide whether data may go into an AI tool from its label and size: allow, warn, block or redirect (POST /v1/apps/ai/guard)
func (c *Client) PostAppsAiGuard(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/guard", body, nil, opts)
}

// PostAppsAiMail: 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)
func (c *Client) PostAppsAiMail(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/mail", body, nil, opts)
}

// PostAppsAiNew: See the new AI tools staff started using, each told once with the approved one to use instead (POST /v1/apps/ai/new)
func (c *Client) PostAppsAiNew(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/new", body, nil, opts)
}

// PostAppsAiNudges: 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)
func (c *Client) PostAppsAiNudges(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/nudges", body, nil, opts)
}

// PostAppsAiPastes: See company data pasted or uploaded from each app into each app, counted - never the content (POST /v1/apps/ai/pastes)
func (c *Client) PostAppsAiPastes(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/pastes", body, nil, opts)
}

// PostAppsAiPolicy: See who acknowledged the AI use policy, by team, and remind the rest (POST /v1/apps/ai/policy)
func (c *Client) PostAppsAiPolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/policy", body, nil, opts)
}

// PostAppsAiPosture: See each app's security settings checked, with the fix for each (POST /v1/apps/ai/posture)
func (c *Client) PostAppsAiPosture(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/posture", body, nil, opts)
}

// PostAppsAiReach: 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)
func (c *Client) PostAppsAiReach(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/reach", body, nil, opts)
}

// PostAppsAiRisk: See how each AI app's risk changed since the last read, with the reasons (POST /v1/apps/ai/risk)
func (c *Client) PostAppsAiRisk(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/risk", body, nil, opts)
}

// PostAppsAiSpend: See unused seats and two paid tools doing one job, with the money each saves a month (POST /v1/apps/ai/spend)
func (c *Client) PostAppsAiSpend(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/spend", body, nil, opts)
}

// PostAppsAiSupplyChain: See the AI services behind each app from its own sub-processor list (POST /v1/apps/ai/supply-chain)
func (c *Client) PostAppsAiSupplyChain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/supply-chain", body, nil, opts)
}

// PostAppsAiVendor: See an AI vendor's training, retention, region and attestation policy against your own requirements (POST /v1/apps/ai/vendor)
func (c *Client) PostAppsAiVendor(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/ai/vendor", body, nil, opts)
}

// PostAppsInventory: Find the apps and AI tools staff use that the business has not approved (POST /v1/apps/inventory)
func (c *Client) PostAppsInventory(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/inventory", body, nil, opts)
}

// PostAppsWatch: Watch a mobile app (POST /v1/apps/watch)
func (c *Client) PostAppsWatch(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/apps/watch", body, nil, opts)
}

// PostAppsWatchByIdRemove: Stop watching an app (POST /v1/apps/watch/{id}/remove)
func (c *Client) PostAppsWatchByIdRemove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/apps/watch/%s/remove", url.PathEscape(id)), body, nil, opts)
}

// PostAppsWatchRepliesByReviewIdApprove: Approve a drafted reply to a store review (POST /v1/apps/watch/replies/{reviewId}/approve)
func (c *Client) PostAppsWatchRepliesByReviewIdApprove(ctx context.Context, reviewId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/apps/watch/replies/%s/approve", url.PathEscape(reviewId)), body, nil, opts)
}

// PostAssets: Add a website to monitor (POST /v1/assets)
func (c *Client) PostAssets(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assets", body, nil, opts)
}

// PostAssetsByIdSiteQualityRun: Check a website's quality now (POST /v1/assets/{id}/site-quality/run)
func (c *Client) PostAssetsByIdSiteQualityRun(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assets/%s/site-quality/run", url.PathEscape(id)), body, nil, opts)
}

// PostAssetsRemovalsByIdUndo: Undo a website's removal (POST /v1/assets/removals/{id}/undo)
func (c *Client) PostAssetsRemovalsByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assets/removals/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAssistCobrowse: Share a browser tab with Xovris for step-by-step help (POST /v1/assist/cobrowse)
func (c *Client) PostAssistCobrowse(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/cobrowse", body, nil, opts)
}

// PostAssistCobrowseByIdActed: Report what the shared tab did (POST /v1/assist/cobrowse/{id}/acted)
func (c *Client) PostAssistCobrowseByIdActed(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/cobrowse/%s/acted", url.PathEscape(id)), body, nil, opts)
}

// PostAssistCobrowseByIdCaptured: Keep what a co-browse step captured, sealed in your vault (POST /v1/assist/cobrowse/{id}/captured)
func (c *Client) PostAssistCobrowseByIdCaptured(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/cobrowse/%s/captured", url.PathEscape(id)), body, nil, opts)
}

// PostAssistCobrowseByIdConsent: Say yes or no to the step Xovris proposed (POST /v1/assist/cobrowse/{id}/consent)
func (c *Client) PostAssistCobrowseByIdConsent(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/cobrowse/%s/consent", url.PathEscape(id)), body, nil, opts)
}

// PostAssistCobrowseByIdFrame: Send the shared tab's outline and get the next step (POST /v1/assist/cobrowse/{id}/frame)
func (c *Client) PostAssistCobrowseByIdFrame(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/cobrowse/%s/frame", url.PathEscape(id)), body, nil, opts)
}

// PostAssistCobrowseByIdStop: Stop sharing a tab (POST /v1/assist/cobrowse/{id}/stop)
func (c *Client) PostAssistCobrowseByIdStop(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/cobrowse/%s/stop", url.PathEscape(id)), body, nil, opts)
}

// PostAssistDesignImport: 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)
func (c *Client) PostAssistDesignImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/design/import", body, nil, opts)
}

// PostAssistDocuments: Make an answer into a file - Word, Excel, PowerPoint or PDF - and download it (POST /v1/assist/documents)
func (c *Client) PostAssistDocuments(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/documents", body, nil, opts)
}

// PostAssistFilesRead: 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)
func (c *Client) PostAssistFilesRead(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/files/read", body, nil, opts)
}

// PostAssistListen: Send a recording and get back the words that were said (POST /v1/assist/listen)
func (c *Client) PostAssistListen(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/listen", body, nil, opts)
}

// PostAssistRequests: Ask Xovris to do something (POST /v1/assist/requests)
func (c *Client) PostAssistRequests(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/requests", body, nil, opts)
}

// PostAssistRequestsArchiveAll: Archive every conversation at once - each is kept whole and can be restored (POST /v1/assist/requests/archive-all)
func (c *Client) PostAssistRequestsArchiveAll(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/requests/archive-all", body, nil, opts)
}

// PostAssistRequestsByIdReply: Reply to Xovris about a request (POST /v1/assist/requests/{id}/reply)
func (c *Client) PostAssistRequestsByIdReply(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/requests/%s/reply", url.PathEscape(id)), body, nil, opts)
}

// PostAssistRequestsByIdSay: Carry a conversation on in your own words, where it stopped (POST /v1/assist/requests/{id}/say)
func (c *Client) PostAssistRequestsByIdSay(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/requests/%s/say", url.PathEscape(id)), body, nil, opts)
}

// PostAssistRequestsByIdSecret: Give Xovris a secret for a request, sealed (POST /v1/assist/requests/{id}/secret)
func (c *Client) PostAssistRequestsByIdSecret(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/requests/%s/secret", url.PathEscape(id)), body, nil, opts)
}

// PostAssistRequestsByIdShare: Make a link anyone can open to read a conversation (POST /v1/assist/requests/{id}/share)
func (c *Client) PostAssistRequestsByIdShare(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/assist/requests/%s/share", url.PathEscape(id)), body, nil, opts)
}

// PostAssistSpeech: Turn written words into speech and get the recording back (POST /v1/assist/speech)
func (c *Client) PostAssistSpeech(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/assist/speech", body, nil, opts)
}

// PostAutomationKillSwitches: Stop or restart what Xovris does on its own, for the workspace or one kind of action (POST /v1/automation/kill-switches)
func (c *Client) PostAutomationKillSwitches(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/automation/kill-switches", body, nil, opts)
}

// PostAutonomyAsks: Count one thing Xovris asked a person to do against its journey's floor (POST /v1/autonomy/asks)
func (c *Client) PostAutonomyAsks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/asks", body, nil, opts)
}

// PostAutonomyDnssec: DNSSEC switched on for a domain by Xovris, read back from public resolvers (POST /v1/autonomy/dnssec)
func (c *Client) PostAutonomyDnssec(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/dnssec", body, nil, opts)
}

// PostAutonomyDomainsByDomainKeepRenewing: Keep a domain renewing at its registrar (POST /v1/autonomy/domains/{domain}/keep-renewing)
func (c *Client) PostAutonomyDomainsByDomainKeepRenewing(ctx context.Context, domain string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/domains/%s/keep-renewing", url.PathEscape(domain)), body, nil, opts)
}

// PostAutonomyEdgeHeaders: A site's security headers set by Xovris at its edge (POST /v1/autonomy/edge/headers)
func (c *Client) PostAutonomyEdgeHeaders(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/edge/headers", body, nil, opts)
}

// PostAutonomyFactsAsk: Ask the person for a fact once - a fact already given is returned instead (POST /v1/autonomy/facts/ask)
func (c *Client) PostAutonomyFactsAsk(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/facts/ask", body, nil, opts)
}

// PostAutonomyGoals: Say what you want in one sentence; Xovris plans it, rehearses it and runs it (POST /v1/autonomy/goals)
func (c *Client) PostAutonomyGoals(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/goals", body, nil, opts)
}

// PostAutonomyGoalsByIdYes: Say yes once to a plan Xovris rehearsed (POST /v1/autonomy/goals/{id}/yes)
func (c *Client) PostAutonomyGoalsByIdYes(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/goals/%s/yes", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomyGrantsLeast: See the least grant a plan needs, and what it lets Xovris do (POST /v1/autonomy/grants/least)
func (c *Client) PostAutonomyGrantsLeast(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/grants/least", body, nil, opts)
}

// PostAutonomyImmunityBreaks: Share only the fix for a vendor's break, so every other customer is protected (POST /v1/autonomy/immunity/breaks)
func (c *Client) PostAutonomyImmunityBreaks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/immunity/breaks", body, nil, opts)
}

// PostAutonomyImperative: Check words for instructions that hand the person work Xovris could do (POST /v1/autonomy/imperative)
func (c *Client) PostAutonomyImperative(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/imperative", body, nil, opts)
}

// PostAutonomyKeyboardByIdHandOver: Hand Xovris the keyboard in a shared tab, or take it back (POST /v1/autonomy/keyboard/{id}/hand-over)
func (c *Client) PostAutonomyKeyboardByIdHandOver(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/keyboard/%s/hand-over", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomyKeyboardLink: Make a one-tap link that installs the signed device app (POST /v1/autonomy/keyboard/link)
func (c *Client) PostAutonomyKeyboardLink(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/keyboard/link", body, nil, opts)
}

// PostAutonomyMeSignals: Tell Xovris how you prefer to work (POST /v1/autonomy/me/signals)
func (c *Client) PostAutonomyMeSignals(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/me/signals", body, nil, opts)
}

// PostAutonomyPeople: Have a joiner made ready before day one, or a leaver's access removed on their last day (POST /v1/autonomy/people)
func (c *Client) PostAutonomyPeople(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/people", body, nil, opts)
}

// PostAutonomyPeopleByIdUndo: Undo a joiner or a leaver (POST /v1/autonomy/people/{id}/undo)
func (c *Client) PostAutonomyPeopleByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/people/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomyRenewals: Have Xovris renew everything inside its renewal window now (POST /v1/autonomy/renewals)
func (c *Client) PostAutonomyRenewals(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/renewals", body, nil, opts)
}

// PostAutonomySitting: Start one sitting to say every yes at once (POST /v1/autonomy/sitting)
func (c *Client) PostAutonomySitting(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/sitting", body, nil, opts)
}

// PostAutonomySittingByIdEnd: End a sitting (POST /v1/autonomy/sitting/{id}/end)
func (c *Client) PostAutonomySittingByIdEnd(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/sitting/%s/end", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomySittingByIdYes: Say one yes in a sitting; Xovris carries that setup on at once (POST /v1/autonomy/sitting/{id}/yes)
func (c *Client) PostAutonomySittingByIdYes(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/sitting/%s/yes", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomySpendByIdRestore: Give back what an undone spend change took (POST /v1/autonomy/spend/{id}/restore)
func (c *Client) PostAutonomySpendByIdRestore(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/spend/%s/restore", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomySpendByIdUndo: Undo a spend change (POST /v1/autonomy/spend/{id}/undo)
func (c *Client) PostAutonomySpendByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/spend/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomySpendByIdYes: Say yes to a spend change that waits for you (POST /v1/autonomy/spend/{id}/yes)
func (c *Client) PostAutonomySpendByIdYes(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/spend/%s/yes", url.PathEscape(id)), body, nil, opts)
}

// PostAutonomySpendClean: Have Xovris release unused seats and licences under your policy (POST /v1/autonomy/spend/clean)
func (c *Client) PostAutonomySpendClean(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/spend/clean", body, nil, opts)
}

// PostAutonomySpendPurchase: Make a purchase under your spend policy; above it, it waits for your yes (POST /v1/autonomy/spend/purchase)
func (c *Client) PostAutonomySpendPurchase(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/spend/purchase", body, nil, opts)
}

// PostAutonomyStackByToolDismiss: Set aside a tool Xovris found that you do not use (POST /v1/autonomy/stack/{tool}/dismiss)
func (c *Client) PostAutonomyStackByToolDismiss(ctx context.Context, tool string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/stack/%s/dismiss", url.PathEscape(tool)), body, nil, opts)
}

// PostAutonomyStackRead: Read the tools your company uses from your domain's public records (POST /v1/autonomy/stack/read)
func (c *Client) PostAutonomyStackRead(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/stack/read", body, nil, opts)
}

// PostAutonomyVendorCases: Have Xovris open a support case with a vendor and chase it until it is fixed (POST /v1/autonomy/vendor-cases)
func (c *Client) PostAutonomyVendorCases(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/autonomy/vendor-cases", body, nil, opts)
}

// PostAutonomyVendorCasesByIdReply: Record the vendor's reply; a fix is settled with the vendor's words as proof (POST /v1/autonomy/vendor-cases/{id}/reply)
func (c *Client) PostAutonomyVendorCasesByIdReply(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/autonomy/vendor-cases/%s/reply", url.PathEscape(id)), body, nil, opts)
}

// PostBackupsFind: Have Xovris find the backups your systems already make (POST /v1/backups/find)
func (c *Client) PostBackupsFind(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/backups/find", body, nil, opts)
}

// PostBackupsUnwire: Stop Xovris watching a backup, putting it back as it was (POST /v1/backups/unwire)
func (c *Client) PostBackupsUnwire(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/backups/unwire", body, nil, opts)
}

// PostBackupsWire: Have Xovris watch a backup and prove it can be restored (POST /v1/backups/wire)
func (c *Client) PostBackupsWire(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/backups/wire", body, nil, opts)
}

// PostBadges: Make a live badge for a site you watch (POST /v1/badges)
func (c *Client) PostBadges(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/badges", body, nil, opts)
}

// PostBadgesByIdRevoke: Revoke a badge (POST /v1/badges/{id}/revoke)
func (c *Client) PostBadgesByIdRevoke(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/badges/%s/revoke", url.PathEscape(id)), body, nil, opts)
}

// PostBillingStripeEvents: Take in a billing event from the payment provider (POST /v1/billing/stripe/events)
func (c *Client) PostBillingStripeEvents(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/billing/stripe/events", body, nil, opts)
}

// PostBillsSpike: Check a bill for a spike against its own normal, and whether the month will pass its budget (POST /v1/bills/spike)
func (c *Client) PostBillsSpike(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/bills/spike", body, nil, opts)
}

// PostBoardStarter: Set up your dashboard from what Xovris already watches - your checks, its fixes, your cloud bill and your devices (POST /v1/board/starter)
func (c *Client) PostBoardStarter(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/board/starter", body, nil, opts)
}

// PostBoardTiles: Pin an answer's chart or calculator to your dashboard as a live tile (POST /v1/board/tiles)
func (c *Client) PostBoardTiles(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/board/tiles", body, nil, opts)
}

// PostBudgetForecast: See next year's IT budget from what you pay now and the contracts that renew (POST /v1/budget/forecast)
func (c *Client) PostBudgetForecast(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/budget/forecast", body, nil, opts)
}

// PostBuildsSize: Record a build's size by asset and dependency (POST /v1/builds/size)
func (c *Client) PostBuildsSize(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/builds/size", body, nil, opts)
}

// PostCarryOnAskAdmins: Ask this workspace's admins to approve a step (POST /v1/carry-on/ask-admins)
func (c *Client) PostCarryOnAskAdmins(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/carry-on/ask-admins", body, nil, opts)
}

// PostCarryOnByIdNow: Have Xovris try the next step now (POST /v1/carry-on/{id}/now)
func (c *Client) PostCarryOnByIdNow(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/carry-on/%s/now", url.PathEscape(id)), body, nil, opts)
}

// PostCarryOnRedeliverKey: Have Xovris put a fresh key into the place that sends to it (POST /v1/carry-on/redeliver-key)
func (c *Client) PostCarryOnRedeliverKey(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/carry-on/redeliver-key", body, nil, opts)
}

// PostChangesWillItBreak: Ask whether a change will break anything before you make it (POST /v1/changes/will-it-break)
func (c *Client) PostChangesWillItBreak(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/changes/will-it-break", body, nil, opts)
}

// PostChecks: Add a check (POST /v1/checks)
func (c *Client) PostChecks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks", body, nil, opts)
}

// PostChecksByIdPause: Pause a check (POST /v1/checks/{id}/pause)
func (c *Client) PostChecksByIdPause(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/pause", url.PathEscape(id)), body, nil, opts)
}

// PostChecksByIdPromiseAlerts: Be told when a check's promise is at risk of being missed (POST /v1/checks/{id}/promise/alerts)
func (c *Client) PostChecksByIdPromiseAlerts(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/promise/alerts", url.PathEscape(id)), body, nil, opts)
}

// PostChecksByIdPromiseCorrections: Correct a check's promise for a window that should not count against it, with the reason (POST /v1/checks/{id}/promise/corrections)
func (c *Client) PostChecksByIdPromiseCorrections(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/promise/corrections", url.PathEscape(id)), body, nil, opts)
}

// PostChecksByIdResume: Resume a check (POST /v1/checks/{id}/resume)
func (c *Client) PostChecksByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostChecksByIdRollback: Roll a check back to an earlier version (POST /v1/checks/{id}/rollback)
func (c *Client) PostChecksByIdRollback(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/rollback", url.PathEscape(id)), body, nil, opts)
}

// PostChecksByIdRunNow: Run a check now from every location (POST /v1/checks/{id}/run-now)
func (c *Client) PostChecksByIdRunNow(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/run-now", url.PathEscape(id)), body, nil, opts)
}

// PostChecksByIdSchedule: Change when a check runs (POST /v1/checks/{id}/schedule)
func (c *Client) PostChecksByIdSchedule(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/%s/schedule", url.PathEscape(id)), body, nil, opts)
}

// PostChecksDeploy: Deploy checks from code (POST /v1/checks/deploy)
func (c *Client) PostChecksDeploy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/deploy", body, nil, opts)
}

// PostChecksFix: Have Xovris rewrite a failing check so it passes again (POST /v1/checks/fix)
func (c *Client) PostChecksFix(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/fix", body, nil, opts)
}

// PostChecksJourneysWalk: Have Xovris record journeys by walking your site (POST /v1/checks/journeys/walk)
func (c *Client) PostChecksJourneysWalk(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/journeys/walk", body, nil, opts)
}

// PostChecksProbes: Add a private probe (POST /v1/checks/probes)
func (c *Client) PostChecksProbes(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/probes", body, nil, opts)
}

// PostChecksProbesByIdRevoke: Revoke a private probe (POST /v1/checks/probes/{id}/revoke)
func (c *Client) PostChecksProbesByIdRevoke(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/checks/probes/%s/revoke", url.PathEscape(id)), body, nil, opts)
}

// PostChecksSecrets: Add a secret for checks, sealed (POST /v1/checks/secrets)
func (c *Client) PostChecksSecrets(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/secrets", body, nil, opts)
}

// PostChecksSuggestions: Suggest journeys from real visits (POST /v1/checks/suggestions)
func (c *Client) PostChecksSuggestions(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/suggestions", body, nil, opts)
}

// PostChecksTest: Run a check once without saving it (POST /v1/checks/test)
func (c *Client) PostChecksTest(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/checks/test", body, nil, opts)
}

// PostCloudAwsCallback: Receive the result of an AWS account connection from its stack (POST /v1/cloud/aws/callback)
func (c *Client) PostCloudAwsCallback(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/cloud/aws/callback", body, nil, opts)
}

// PostCloudConnections: Start connecting a cloud account with one link (POST /v1/cloud/connections)
func (c *Client) PostCloudConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/cloud/connections", body, nil, opts)
}

// PostCloudConnectionsByIdBillRegions: Read an AWS account's bill by region, its Cost Explorer charge said before you accept (POST /v1/cloud/connections/{id}/bill/regions)
func (c *Client) PostCloudConnectionsByIdBillRegions(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/cloud/connections/%s/bill/regions", url.PathEscape(id)), body, nil, opts)
}

// PostCloudConnectionsByIdCheck: Check a cloud connection's access again (POST /v1/cloud/connections/{id}/check)
func (c *Client) PostCloudConnectionsByIdCheck(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/cloud/connections/%s/check", url.PathEscape(id)), body, nil, opts)
}

// PostCodePreviewsByTokenByPath: 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})
func (c *Client) PostCodePreviewsByTokenByPath(ctx context.Context, token string, path string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/previews/%s/%s", url.PathEscape(token), url.PathEscape(path)), body, nil, opts)
}

// PostCodeProjectsByIdCheckpoints: Save a checkpoint of a build's data, to go back to later (POST /v1/code/projects/{id}/checkpoints)
func (c *Client) PostCodeProjectsByIdCheckpoints(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/projects/%s/checkpoints", url.PathEscape(id)), body, nil, opts)
}

// PostCodeProjectsByIdCheckpointsByCheckpointRestore: Put a build's data back to how it was at one checkpoint (POST /v1/code/projects/{id}/checkpoints/{checkpoint}/restore)
func (c *Client) PostCodeProjectsByIdCheckpointsByCheckpointRestore(ctx context.Context, id string, checkpoint string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/projects/%s/checkpoints/%s/restore", url.PathEscape(id), url.PathEscape(checkpoint)), body, nil, opts)
}

// PostCodeProjectsByIdDomains: Put a build's site on your own domain (POST /v1/code/projects/{id}/domains)
func (c *Client) PostCodeProjectsByIdDomains(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/projects/%s/domains", url.PathEscape(id)), body, nil, opts)
}

// PostCodeProjectsByIdDomainsByDomainCheck: Check that your domain points at a build's site, and what is still to set (POST /v1/code/projects/{id}/domains/{domain}/check)
func (c *Client) PostCodeProjectsByIdDomainsByDomainCheck(ctx context.Context, id string, domain string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/projects/%s/domains/%s/check", url.PathEscape(id), url.PathEscape(domain)), body, nil, opts)
}

// PostCodeProjectsByIdRelays: 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)
func (c *Client) PostCodeProjectsByIdRelays(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/projects/%s/relays", url.PathEscape(id)), body, nil, opts)
}

// PostCodeProjectsByIdResourcesByKind: Switch on a part a build runs on - a database, storage, sign-in or a schedule (POST /v1/code/projects/{id}/resources/{kind})
func (c *Client) PostCodeProjectsByIdResourcesByKind(ctx context.Context, id string, kind string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/projects/%s/resources/%s", url.PathEscape(id), url.PathEscape(kind)), body, nil, opts)
}

// PostCodeProjectsImport: Bring a build made elsewhere in as a project of your own (POST /v1/code/projects/import)
func (c *Client) PostCodeProjectsImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/code/projects/import", body, nil, opts)
}

// PostCodeSharedByTokenPreviewByPath: 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})
func (c *Client) PostCodeSharedByTokenPreviewByPath(ctx context.Context, token string, path string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/shared/%s/preview/%s", url.PathEscape(token), url.PathEscape(path)), body, nil, opts)
}

// PostCodeSitesByTokenByPath: Send to the app a build deployed - a form, a sign-in or a call to its API (POST /v1/code/sites/{token}/{path})
func (c *Client) PostCodeSitesByTokenByPath(ctx context.Context, token string, path string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/sites/%s/%s", url.PathEscape(token), url.PathEscape(path)), body, nil, opts)
}

// PostCodeTasks: 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)
func (c *Client) PostCodeTasks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/code/tasks", body, nil, opts)
}

// PostCodeTasksByIdAnswer: Answer a waiting coding job - it carries on in the same job, nothing redone (POST /v1/code/tasks/{id}/answer)
func (c *Client) PostCodeTasksByIdAnswer(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/answer", url.PathEscape(id)), body, nil, opts)
}

// PostCodeTasksByIdCancel: Stop a build that is running - nothing more is written or charged (POST /v1/code/tasks/{id}/cancel)
func (c *Client) PostCodeTasksByIdCancel(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/cancel", url.PathEscape(id)), body, nil, opts)
}

// PostCodeTasksByIdDeploy: Deploy a build that passed its checks to a live address (POST /v1/code/tasks/{id}/deploy)
func (c *Client) PostCodeTasksByIdDeploy(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/deploy", url.PathEscape(id)), body, nil, opts)
}

// PostCodeTasksByIdInbox: 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)
func (c *Client) PostCodeTasksByIdInbox(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/inbox", url.PathEscape(id)), body, nil, opts)
}

// PostCodeTasksByIdInboxByEventAnswer: 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)
func (c *Client) PostCodeTasksByIdInboxByEventAnswer(ctx context.Context, id string, event string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/inbox/%s/answer", url.PathEscape(id), url.PathEscape(event)), body, nil, opts)
}

// PostCodeTasksByIdPush: Push a build's code to your own repository (POST /v1/code/tasks/{id}/push)
func (c *Client) PostCodeTasksByIdPush(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/push", url.PathEscape(id)), body, nil, opts)
}

// PostCodeTasksByIdRestore: Put a build back to one of its earlier versions (POST /v1/code/tasks/{id}/restore)
func (c *Client) PostCodeTasksByIdRestore(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/restore", url.PathEscape(id)), body, nil, opts)
}

// PostCodeTasksByIdShares: 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)
func (c *Client) PostCodeTasksByIdShares(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/code/tasks/%s/shares", url.PathEscape(id)), body, nil, opts)
}

// PostCollectorsByUidDoorsByDoor: Have Xovris change one of your collectors' configuration, read it back and keep the way back (POST /v1/collectors/{uid}/doors/{door})
func (c *Client) PostCollectorsByUidDoorsByDoor(ctx context.Context, uid string, door string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/collectors/%s/doors/%s", url.PathEscape(uid), url.PathEscape(door)), body, nil, opts)
}

// PostCollectorsByUidDoorsByDoorUndo: Put a collector's configuration back exactly as it was before Xovris changed it (POST /v1/collectors/{uid}/doors/{door}/undo)
func (c *Client) PostCollectorsByUidDoorsByDoorUndo(ctx context.Context, uid string, door string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/collectors/%s/doors/%s/undo", url.PathEscape(uid), url.PathEscape(door)), body, nil, opts)
}

// PostCollectorsByUidRepair: Put back the configuration that last worked (POST /v1/collectors/{uid}/repair)
func (c *Client) PostCollectorsByUidRepair(ctx context.Context, uid string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/collectors/%s/repair", url.PathEscape(uid)), body, nil, opts)
}

// PostCollectorsConfig: Send a configuration to your collectors (POST /v1/collectors/config)
func (c *Client) PostCollectorsConfig(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/collectors/config", body, nil, opts)
}

// PostCollectorsConnect: Connect a telemetry collector you already run (POST /v1/collectors/connect)
func (c *Client) PostCollectorsConnect(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/collectors/connect", body, nil, opts)
}

// PostCompanies: Add a company under your account that shares its plan (POST /v1/companies)
func (c *Client) PostCompanies(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/companies", body, nil, opts)
}

// PostComplianceFrameworks: Read any compliance framework you name against your live evidence (POST /v1/compliance/frameworks)
func (c *Client) PostComplianceFrameworks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/compliance/frameworks", body, nil, opts)
}

// PostComputers: Start a desktop on Xovris's own cloud computer, joined to this workspace as one more of your computers (POST /v1/computers)
func (c *Client) PostComputers(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/computers", body, nil, opts)
}

// PostComputersByIdDeskAnswer: The desktop's own door: what one terminal step printed, for the step that ran it (POST /v1/computers/{id}/desk/answer)
func (c *Client) PostComputersByIdDeskAnswer(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/desk/answer", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdDeskFile: 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)
func (c *Client) PostComputersByIdDeskFile(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/desk/file", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdDeskFrame: The desktop's own door: it sends its latest screen with the key it was started with (POST /v1/computers/{id}/desk/frame)
func (c *Client) PostComputersByIdDeskFrame(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/desk/frame", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdDeskRegion: 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)
func (c *Client) PostComputersByIdDeskRegion(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/desk/region", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdDeskTree: 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)
func (c *Client) PostComputersByIdDeskTree(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/desk/tree", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdHold: Take a desktop from the agent to use it yourself (POST /v1/computers/{id}/hold)
func (c *Client) PostComputersByIdHold(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/hold", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdInput: Send your own clicks, typing and keys to a desktop you hold (POST /v1/computers/{id}/input)
func (c *Client) PostComputersByIdInput(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/input", url.PathEscape(id)), body, nil, opts)
}

// PostComputersByIdRelease: Hand a desktop you hold back to the agent (POST /v1/computers/{id}/release)
func (c *Client) PostComputersByIdRelease(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computers/%s/release", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSchedules: 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)
func (c *Client) PostComputerSchedules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/computer/schedules", body, nil, opts)
}

// PostComputerSchedulesByIdResume: Turn a stopped schedule back on - its next run one cadence from now, its runs kept (POST /v1/computer/schedules/{id}/resume)
func (c *Client) PostComputerSchedulesByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/schedules/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSchedulesByIdRun: Xovris carries out a scheduled goal at once on its own computer, its own times kept (POST /v1/computer/schedules/{id}/run)
func (c *Client) PostComputerSchedulesByIdRun(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/schedules/%s/run", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSchedulesByIdStop: Stop a schedule - it runs no more, and its runs stay (POST /v1/computer/schedules/{id}/stop)
func (c *Client) PostComputerSchedulesByIdStop(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/schedules/%s/stop", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSessions: 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)
func (c *Client) PostComputerSessions(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/computer/sessions", body, nil, opts)
}

// PostComputerSessionsByIdConfirm: 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)
func (c *Client) PostComputerSessionsByIdConfirm(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/sessions/%s/confirm", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSessionsByIdHandback: 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)
func (c *Client) PostComputerSessionsByIdHandback(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/sessions/%s/handback", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSessionsByIdSteer: 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)
func (c *Client) PostComputerSessionsByIdSteer(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/sessions/%s/steer", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSessionsByIdStop: Take a computer session back before its next step - the same as pressing Esc while it works (POST /v1/computer/sessions/{id}/stop)
func (c *Client) PostComputerSessionsByIdStop(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/sessions/%s/stop", url.PathEscape(id)), body, nil, opts)
}

// PostComputerSessionsByIdUpload: Give a working session a file - it lands in the Uploads folder of Xovris's own computer (POST /v1/computer/sessions/{id}/upload)
func (c *Client) PostComputerSessionsByIdUpload(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/computer/sessions/%s/upload", url.PathEscape(id)), body, nil, opts)
}

// PostConnect: 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)
func (c *Client) PostConnect(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connect", body, nil, opts)
}

// PostConnectFind: 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)
func (c *Client) PostConnectFind(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connect/find", body, nil, opts)
}

// PostConnectionsByIdDomainsByDomainLock: Turn a domain's transfer lock on or off at its registrar, read back after (POST /v1/connections/{id}/domains/{domain}/lock)
func (c *Client) PostConnectionsByIdDomainsByDomainLock(ctx context.Context, id string, domain string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/domains/%s/lock", url.PathEscape(id), url.PathEscape(domain)), body, nil, opts)
}

// PostConnectionsByIdDomainsByDomainTransferCode: 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)
func (c *Client) PostConnectionsByIdDomainsByDomainTransferCode(ctx context.Context, id string, domain string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/domains/%s/transfer-code", url.PathEscape(id), url.PathEscape(domain)), body, nil, opts)
}

// PostConnectionsByIdGithubDoor: Have Xovris open the GitHub step it needs, with you there (POST /v1/connections/{id}/github/door)
func (c *Client) PostConnectionsByIdGithubDoor(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/github/door", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsByIdGithubInstall: Install Xovris on your GitHub repositories (POST /v1/connections/{id}/github/install)
func (c *Client) PostConnectionsByIdGithubInstall(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/github/install", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsByIdGithubPullRequest: Have Xovris open a proven pull request on GitHub (POST /v1/connections/{id}/github/pull-request)
func (c *Client) PostConnectionsByIdGithubPullRequest(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/github/pull-request", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsByIdReassign: Move a connection to another person (POST /v1/connections/{id}/reassign)
func (c *Client) PostConnectionsByIdReassign(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/reassign", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsByIdRemove: Remove a connection (POST /v1/connections/{id}/remove)
func (c *Client) PostConnectionsByIdRemove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/remove", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsByIdRotateKey: Rotate a connection's key (POST /v1/connections/{id}/rotate-key)
func (c *Client) PostConnectionsByIdRotateKey(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/%s/rotate-key", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsDnsByIdDisconnect: Disconnect a DNS provider (POST /v1/connections/dns/{id}/disconnect)
func (c *Client) PostConnectionsDnsByIdDisconnect(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/dns/%s/disconnect", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsDnsByIdTokenCheck: Check what a DNS connection's token may read and change (POST /v1/connections/dns/{id}/token/check)
func (c *Client) PostConnectionsDnsByIdTokenCheck(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/connections/dns/%s/token/check", url.PathEscape(id)), body, nil, opts)
}

// PostConnectionsDnsCloudflareOauth: Connect Cloudflare by signing in (POST /v1/connections/dns/cloudflare/oauth)
func (c *Client) PostConnectionsDnsCloudflareOauth(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connections/dns/cloudflare/oauth", body, nil, opts)
}

// PostConnectionsDnsCloudflarePreview: Preview what a Cloudflare connection would allow (POST /v1/connections/dns/cloudflare/preview)
func (c *Client) PostConnectionsDnsCloudflarePreview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connections/dns/cloudflare/preview", body, nil, opts)
}

// PostConnectionsDnsCloudflareToken: Connect Cloudflare with an API token (POST /v1/connections/dns/cloudflare/token)
func (c *Client) PostConnectionsDnsCloudflareToken(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connections/dns/cloudflare/token", body, nil, opts)
}

// PostConnectionsDnsRoute53: Connect a Route 53 hosted zone through the workspace's AWS role (POST /v1/connections/dns/route53)
func (c *Client) PostConnectionsDnsRoute53(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connections/dns/route53", body, nil, opts)
}

// PostConnectionsSentry: Connect Sentry (POST /v1/connections/sentry)
func (c *Client) PostConnectionsSentry(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connections/sentry", body, nil, opts)
}

// PostConnectPlan: See how Xovris would connect what you name, before anything changes (POST /v1/connect/plan)
func (c *Client) PostConnectPlan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/connect/plan", body, nil, opts)
}

// PostContinuity: See who and what the business depends on, so nothing stops when one person is away (POST /v1/continuity)
func (c *Client) PostContinuity(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/continuity", body, nil, opts)
}

// PostCryptoPostQuantum: See what still has to move to encryption that holds against quantum computers (POST /v1/crypto/post-quantum)
func (c *Client) PostCryptoPostQuantum(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/crypto/post-quantum", body, nil, opts)
}

// PostDashboards: Build a dashboard from a question (POST /v1/dashboards)
func (c *Client) PostDashboards(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/dashboards", body, nil, opts)
}

// PostDashboardsByIdEmbeds: Embed one dashboard panel (POST /v1/dashboards/{id}/embeds)
func (c *Client) PostDashboardsByIdEmbeds(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/dashboards/%s/embeds", url.PathEscape(id)), body, nil, opts)
}

// PostDashboardsByIdPanelsByPanelIdSilence: Silence a dashboard panel's alerts (POST /v1/dashboards/{id}/panels/{panelId}/silence)
func (c *Client) PostDashboardsByIdPanelsByPanelIdSilence(ctx context.Context, id string, panelId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/dashboards/%s/panels/%s/silence", url.PathEscape(id), url.PathEscape(panelId)), body, nil, opts)
}

// PostDashboardsByIdReports: Send a dashboard as a daily or weekly report (POST /v1/dashboards/{id}/reports)
func (c *Client) PostDashboardsByIdReports(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/dashboards/%s/reports", url.PathEscape(id)), body, nil, opts)
}

// PostDashboardsByIdShares: Share a dashboard by an expiring link (POST /v1/dashboards/{id}/shares)
func (c *Client) PostDashboardsByIdShares(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/dashboards/%s/shares", url.PathEscape(id)), body, nil, opts)
}

// PostDashboardsByIdTv: Show a dashboard on a TV by its code (POST /v1/dashboards/{id}/tv)
func (c *Client) PostDashboardsByIdTv(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/dashboards/%s/tv", url.PathEscape(id)), body, nil, opts)
}

// PostDataScan: Check text for sensitive data; Xovris answers with masked findings and keeps nothing (POST /v1/data/scan)
func (c *Client) PostDataScan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/data/scan", body, nil, opts)
}

// PostDecisionsById: Approve or decline a change waiting for you (POST /v1/decisions/{id})
func (c *Client) PostDecisionsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/decisions/%s", url.PathEscape(id)), body, nil, opts)
}

// PostDecoys: Place decoys that open a security incident the moment anyone touches one (POST /v1/decoys)
func (c *Client) PostDecoys(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/decoys", body, nil, opts)
}

// PostDecoysTrips: Check whether anyone touched one of your decoys (POST /v1/decoys/trips)
func (c *Client) PostDecoysTrips(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/decoys/trips", body, nil, opts)
}

// PostDeliveryDeployments: Record a deployment (POST /v1/delivery/deployments)
func (c *Client) PostDeliveryDeployments(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/delivery/deployments", body, nil, opts)
}

// PostDeviceByCodeApprove: Approve a device sign-in (POST /v1/device/{code}/approve)
func (c *Client) PostDeviceByCodeApprove(ctx context.Context, code string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/device/%s/approve", url.PathEscape(code)), body, nil, opts)
}

// PostDeviceByCodeDeny: Deny a device sign-in (POST /v1/device/{code}/deny)
func (c *Client) PostDeviceByCodeDeny(ctx context.Context, code string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/device/%s/deny", url.PathEscape(code)), body, nil, opts)
}

// PostDeviceCode: Start a device sign-in (POST /v1/device/code)
func (c *Client) PostDeviceCode(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/device/code", body, nil, opts)
}

// PostDevicesAppleProfiles: Have Xovris make a configuration profile for an iPhone or iPad (POST /v1/devices/apple/profiles)
func (c *Client) PostDevicesAppleProfiles(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/devices/apple/profiles", body, nil, opts)
}

// PostDevicesAppUpdatesByIdHalt: Halt an application update's rollout (POST /v1/devices/app-updates/{id}/halt)
func (c *Client) PostDevicesAppUpdatesByIdHalt(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/app-updates/%s/halt", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesAppUpdatesByIdResume: Resume a halted application update (POST /v1/devices/app-updates/{id}/resume)
func (c *Client) PostDevicesAppUpdatesByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/app-updates/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdAppliances: Connect a device's appliance door so Xovris can read and patch it (POST /v1/devices/{id}/appliances)
func (c *Client) PostDevicesByIdAppliances(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/appliances", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdChecks: Ask a device to run a check (POST /v1/devices/{id}/checks)
func (c *Client) PostDevicesByIdChecks(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/checks", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdDoorsByDoorByOp: 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})
func (c *Client) PostDevicesByIdDoorsByDoorByOp(ctx context.Context, id string, door string, op string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/doors/%s/%s", url.PathEscape(id), url.PathEscape(door), url.PathEscape(op)), body, nil, opts)
}

// PostDevicesByIdFixesByReportIdUndo: Put back a change Xovris made on a device, exactly as it was before (POST /v1/devices/{id}/fixes/{reportId}/undo)
func (c *Client) PostDevicesByIdFixesByReportIdUndo(ctx context.Context, id string, reportId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/fixes/%s/undo", url.PathEscape(id), url.PathEscape(reportId)), body, nil, opts)
}

// PostDevicesByIdLocalTasks: Give a computer's Xovris agent a task to run through the one gate it answers to (POST /v1/devices/{id}/local-tasks)
func (c *Client) PostDevicesByIdLocalTasks(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/local-tasks", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdProviderStatus: Read a device's provider status through its agent (POST /v1/devices/{id}/provider-status)
func (c *Client) PostDevicesByIdProviderStatus(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/provider-status", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdPushInstall: Have one computer install the Xovris agent on another (POST /v1/devices/{id}/push-install)
func (c *Client) PostDevicesByIdPushInstall(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/push-install", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdRevoke: Revoke a device (POST /v1/devices/{id}/revoke)
func (c *Client) PostDevicesByIdRevoke(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/revoke", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdSettings: Change a device's settings (POST /v1/devices/{id}/settings)
func (c *Client) PostDevicesByIdSettings(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/settings", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesByIdTechnicianBrief: See the brief a technician would get for a job only a person's hand can do (POST /v1/devices/{id}/technician/brief)
func (c *Client) PostDevicesByIdTechnicianBrief(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/%s/technician/brief", url.PathEscape(id)), body, nil, opts)
}

// PostDevicesEnrolmentCodes: Make a code to add a device (POST /v1/devices/enrolment-codes)
func (c *Client) PostDevicesEnrolmentCodes(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/devices/enrolment-codes", body, nil, opts)
}

// PostDevicesGroups: Make a group of devices to watch and manage together (POST /v1/devices/groups)
func (c *Client) PostDevicesGroups(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/devices/groups", body, nil, opts)
}

// PostDevicesGroupsByGroupIdAdmins: The people who may manage a device group (POST /v1/devices/groups/{groupId}/admins)
func (c *Client) PostDevicesGroupsByGroupIdAdmins(ctx context.Context, groupId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/groups/%s/admins", url.PathEscape(groupId)), body, nil, opts)
}

// PostDevicesGroupsByGroupIdChecks: Checks that run on every device in a group (POST /v1/devices/groups/{groupId}/checks)
func (c *Client) PostDevicesGroupsByGroupIdChecks(ctx context.Context, groupId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/devices/groups/%s/checks", url.PathEscape(groupId)), body, nil, opts)
}

// PostDevicesPairFixes: Start a fix that needs two devices, its first step signed for its device (POST /v1/devices/pair-fixes)
func (c *Client) PostDevicesPairFixes(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/devices/pair-fixes", body, nil, opts)
}

// PostDevicesPairFixesNext: Get the next step of a fix across devices, with the value the step before handed on (POST /v1/devices/pair-fixes/next)
func (c *Client) PostDevicesPairFixesNext(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/devices/pair-fixes/next", body, nil, opts)
}

// PostDeviceToken: Finish a device sign-in (POST /v1/device/token)
func (c *Client) PostDeviceToken(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/device/token", body, nil, opts)
}

// PostDisposalCertificate: Get a certificate that a device was wiped, once its check proves it (POST /v1/disposal/certificate)
func (c *Client) PostDisposalCertificate(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/disposal/certificate", body, nil, opts)
}

// PostDisposalPlan: Plan how a device is wiped and disposed of safely (POST /v1/disposal/plan)
func (c *Client) PostDisposalPlan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/disposal/plan", body, nil, opts)
}

// PostDnsDanglingRepoint: Point a record that points at something nobody owns where its host expects it (POST /v1/dns/dangling/repoint)
func (c *Client) PostDnsDanglingRepoint(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/dns/dangling/repoint", body, nil, opts)
}

// PostDnsDanglingRetire: Remove a record that points at something nobody owns (POST /v1/dns/dangling/retire)
func (c *Client) PostDnsDanglingRetire(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/dns/dangling/retire", body, nil, opts)
}

// PostDnsQueryByToken: Ask a household member's protective resolver a DNS question (RFC 8484 POST) (POST /v1/dns-query/{token})
func (c *Client) PostDnsQueryByToken(ctx context.Context, token string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/dns-query/%s", url.PathEscape(token)), body, nil, opts)
}

// PostDnssecDs: Have Xovris give your registrar its DNSSEC record (POST /v1/dnssec/ds)
func (c *Client) PostDnssecDs(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/dnssec/ds", body, nil, opts)
}

// PostDoorsExtensionCatchById: Catch a key a set-up page shows, once, into Xovris (POST /v1/doors/extension/catch/{id})
func (c *Client) PostDoorsExtensionCatchById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/doors/extension/catch/%s", url.PathEscape(id)), body, nil, opts)
}

// PostDoorsExtensionPair: Pair the Xovris extension in this browser (POST /v1/doors/extension/pair)
func (c *Client) PostDoorsExtensionPair(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/doors/extension/pair", body, nil, opts)
}

// PostDoorsExtensionPairings: Start pairing a browser with the Xovris extension (POST /v1/doors/extension/pairings)
func (c *Client) PostDoorsExtensionPairings(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/doors/extension/pairings", body, nil, opts)
}

// PostDoorsExtensionResultsById: The paired extension reports a step it ran (POST /v1/doors/extension/results/{id})
func (c *Client) PostDoorsExtensionResultsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/doors/extension/results/%s", url.PathEscape(id)), body, nil, opts)
}

// PostDoorsExtensionTasks: Give the paired extension a task to run with you there (POST /v1/doors/extension/tasks)
func (c *Client) PostDoorsExtensionTasks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/doors/extension/tasks", body, nil, opts)
}

// PostEdgeProtect: 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)
func (c *Client) PostEdgeProtect(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/edge/protect", body, nil, opts)
}

// PostEfficiencyApplied: Say an efficiency change was made (POST /v1/efficiency/applied)
func (c *Client) PostEfficiencyApplied(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/efficiency/applied", body, nil, opts)
}

// PostElevations: 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)
func (c *Client) PostElevations(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/elevations", body, nil, opts)
}

// PostElevationsByIdDecide: 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)
func (c *Client) PostElevationsByIdDecide(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/elevations/%s/decide", url.PathEscape(id)), body, nil, opts)
}

// PostElevationsByIdEnd: A role given for a time ended before its end - from that second it grants nothing (POST /v1/elevations/{id}/end)
func (c *Client) PostElevationsByIdEnd(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/elevations/%s/end", url.PathEscape(id)), body, nil, opts)
}

// PostEverydayActsByIdUndo: Undo something Xovris did, with what was put back read again (POST /v1/everyday/acts/{id}/undo)
func (c *Client) PostEverydayActsByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/everyday/acts/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostExports: Export incidents, fixes and traces to your own bucket (POST /v1/exports)
func (c *Client) PostExports(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/exports", body, nil, opts)
}

// PostExposureCheck: Check for exposure now (POST /v1/exposure/check)
func (c *Client) PostExposureCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/exposure/check", body, nil, opts)
}

// PostExposureFindingsByIdDismiss: Dismiss an exposure finding (POST /v1/exposure/findings/{id}/dismiss)
func (c *Client) PostExposureFindingsByIdDismiss(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/exposure/findings/%s/dismiss", url.PathEscape(id)), body, nil, opts)
}

// PostExposureFindingsByIdRespond: Respond to an exposure finding (POST /v1/exposure/findings/{id}/respond)
func (c *Client) PostExposureFindingsByIdRespond(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/exposure/findings/%s/respond", url.PathEscape(id)), body, nil, opts)
}

// PostExposureProve: Confirm an address to watch for data breaches (POST /v1/exposure/prove)
func (c *Client) PostExposureProve(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/exposure/prove", body, nil, opts)
}

// PostExposureResponsesByIdStepsByStepDone: Mark a response step done (POST /v1/exposure/responses/{id}/steps/{step}/done)
func (c *Client) PostExposureResponsesByIdStepsByStepDone(ctx context.Context, id string, step string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/exposure/responses/%s/steps/%s/done", url.PathEscape(id), url.PathEscape(step)), body, nil, opts)
}

// PostExposureWatch: Watch an address, domain or brand (POST /v1/exposure/watch)
func (c *Client) PostExposureWatch(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/exposure/watch", body, nil, opts)
}

// PostExposureWatchByIdRemove: Stop watching for exposure (POST /v1/exposure/watch/{id}/remove)
func (c *Client) PostExposureWatchByIdRemove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/exposure/watch/%s/remove", url.PathEscape(id)), body, nil, opts)
}

// PostExposureWatchByIdVerify: Verify an exposure watch (POST /v1/exposure/watch/{id}/verify)
func (c *Client) PostExposureWatchByIdVerify(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/exposure/watch/%s/verify", url.PathEscape(id)), body, nil, opts)
}

// PostExtensionsApps: Install or update an app (POST /v1/extensions/apps)
func (c *Client) PostExtensionsApps(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/extensions/apps", body, nil, opts)
}

// PostExtensionsAppsByAppIdTest: Test that Xovris can reach an app (POST /v1/extensions/apps/{appId}/test)
func (c *Client) PostExtensionsAppsByAppIdTest(ctx context.Context, appId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/extensions/apps/%s/test", url.PathEscape(appId)), body, nil, opts)
}

// PostExtensionsByComponentIdSettings: Save an app's settings page (POST /v1/extensions/{componentId}/settings)
func (c *Client) PostExtensionsByComponentIdSettings(ctx context.Context, componentId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/extensions/%s/settings", url.PathEscape(componentId)), body, nil, opts)
}

// PostExtensionsByComponentIdSubmit: Answer an app's alert action (POST /v1/extensions/{componentId}/submit)
func (c *Client) PostExtensionsByComponentIdSubmit(ctx context.Context, componentId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/extensions/%s/submit", url.PathEscape(componentId)), body, nil, opts)
}

// PostFailoverTargets: Name a standby target for failover (POST /v1/failover-targets)
func (c *Client) PostFailoverTargets(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/failover-targets", body, nil, opts)
}

// PostFootprint: Read what a domain runs on and every host its certificates name (POST /v1/footprint)
func (c *Client) PostFootprint(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/footprint", body, nil, opts)
}

// PostForecastsRenewalCaa: See whether a certificate renewal will be refused by your CAA records (POST /v1/forecasts/renewal-caa)
func (c *Client) PostForecastsRenewalCaa(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/forecasts/renewal-caa", body, nil, opts)
}

// PostFreeExpiry: Watch a domain or certificate for its expiry, free (POST /v1/free/expiry)
func (c *Client) PostFreeExpiry(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/free/expiry", body, nil, opts)
}

// PostFreeExpiryRun: Check every confirmed free expiry watch (POST /v1/free/expiry/run)
func (c *Client) PostFreeExpiryRun(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/free/expiry/run", body, nil, opts)
}

// PostGoalsStanding: 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)
func (c *Client) PostGoalsStanding(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/goals/standing", body, nil, opts)
}

// PostGoalsStandingByIdFire: Fire a standing goal now - an API call is one of its triggers (POST /v1/goals/standing/{id}/fire)
func (c *Client) PostGoalsStandingByIdFire(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/goals/standing/%s/fire", url.PathEscape(id)), body, nil, opts)
}

// PostGoalsStandingByIdRetire: Stop holding a standing goal (POST /v1/goals/standing/{id}/retire)
func (c *Client) PostGoalsStandingByIdRetire(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/goals/standing/%s/retire", url.PathEscape(id)), body, nil, opts)
}

// PostGrants: Give Xovris a standing permission to act for you, within the limits you set (POST /v1/grants)
func (c *Client) PostGrants(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/grants", body, nil, opts)
}

// PostHelperHandoffClaim: Bring a conversation from the website into this workspace (POST /v1/helper/handoff/claim)
func (c *Client) PostHelperHandoffClaim(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/helper/handoff/claim", body, nil, opts)
}

// PostHistoryCompare: See how a system looked at another moment beside how it looks now (POST /v1/history/compare)
func (c *Client) PostHistoryCompare(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/history/compare", body, nil, opts)
}

// PostHomeNetworkKnown: Mark a device on your home network as yours (POST /v1/home-network/known)
func (c *Client) PostHomeNetworkKnown(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/home-network/known", body, nil, opts)
}

// PostHooksAlertsByTenantByConnection: Send alerts from another tool (POST /v1/hooks/alerts/{tenant}/{connection})
func (c *Client) PostHooksAlertsByTenantByConnection(ctx context.Context, tenant string, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/hooks/alerts/%s/%s", url.PathEscape(tenant), url.PathEscape(connection)), body, nil, opts)
}

// PostHooksEmail: Receive email sent to Xovris (POST /v1/hooks/email)
func (c *Client) PostHooksEmail(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/hooks/email", body, nil, opts)
}

// PostHooksSourcesByTenantByConnection: Send events from a connected source (POST /v1/hooks/sources/{tenant}/{connection})
func (c *Client) PostHooksSourcesByTenantByConnection(ctx context.Context, tenant string, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/hooks/sources/%s/%s", url.PathEscape(tenant), url.PathEscape(connection)), body, nil, opts)
}

// PostHooksSourcesByTenantByConnectionEnroll: Enrol a connected source (POST /v1/hooks/sources/{tenant}/{connection}/enroll)
func (c *Client) PostHooksSourcesByTenantByConnectionEnroll(ctx context.Context, tenant string, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/hooks/sources/%s/%s/enroll", url.PathEscape(tenant), url.PathEscape(connection)), body, nil, opts)
}

// PostHooksSourcesByTenantByConnectionLog: Send log lines from a connected source (POST /v1/hooks/sources/{tenant}/{connection}/log)
func (c *Client) PostHooksSourcesByTenantByConnectionLog(ctx context.Context, tenant string, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/hooks/sources/%s/%s/log", url.PathEscape(tenant), url.PathEscape(connection)), body, nil, opts)
}

// PostHooksToolsByTenantByConnection: Send events from a connected tool (POST /v1/hooks/tools/{tenant}/{connection})
func (c *Client) PostHooksToolsByTenantByConnection(ctx context.Context, tenant string, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/hooks/tools/%s/%s", url.PathEscape(tenant), url.PathEscape(connection)), body, nil, opts)
}

// PostHooksWatchByToken: Report to a watch (POST /v1/hooks/watch/{token})
func (c *Client) PostHooksWatchByToken(ctx context.Context, token string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/hooks/watch/%s", url.PathEscape(token)), body, nil, opts)
}

// PostHouseholdDevicesByIdOff: Switch off one household device's protected address (POST /v1/household/devices/{id}/off)
func (c *Client) PostHouseholdDevicesByIdOff(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/household/devices/%s/off", url.PathEscape(id)), body, nil, opts)
}

// PostHouseholdMembers: Add a member to your household's protection (POST /v1/household/members)
func (c *Client) PostHouseholdMembers(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/household/members", body, nil, opts)
}

// PostHouseholdMembersByIdDevices: Give a member's device its own protected address (POST /v1/household/members/{id}/devices)
func (c *Client) PostHouseholdMembersByIdDevices(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/household/members/%s/devices", url.PathEscape(id)), body, nil, opts)
}

// PostHouseholdMembersByIdRemove: Remove a household member (one press brings them back) (POST /v1/household/members/{id}/remove)
func (c *Client) PostHouseholdMembersByIdRemove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/household/members/%s/remove", url.PathEscape(id)), body, nil, opts)
}

// PostHouseholdMembersByIdRestore: Bring back a removed household member (POST /v1/household/members/{id}/restore)
func (c *Client) PostHouseholdMembersByIdRestore(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/household/members/%s/restore", url.PathEscape(id)), body, nil, opts)
}

// PostIdentityConnections: Connect a sign-in directory (POST /v1/identity/connections)
func (c *Client) PostIdentityConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/identity/connections", body, nil, opts)
}

// PostIdentityConnectionsByIdBackupByPolicyActivate: Turn on a backup policy (POST /v1/identity/connections/{id}/backup/{policy}/activate)
func (c *Client) PostIdentityConnectionsByIdBackupByPolicyActivate(ctx context.Context, id string, policy string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/connections/%s/backup/%s/activate", url.PathEscape(id), url.PathEscape(policy)), body, nil, opts)
}

// PostIdentityConnectionsByIdDevicesByDeviceApprove: 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)
func (c *Client) PostIdentityConnectionsByIdDevicesByDeviceApprove(ctx context.Context, id string, device string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/connections/%s/devices/%s/approve", url.PathEscape(id), url.PathEscape(device)), body, nil, opts)
}

// PostIdentityConnectionsByIdDevicesByDeviceSync: Sync a device from a directory (POST /v1/identity/connections/{id}/devices/{device}/sync)
func (c *Client) PostIdentityConnectionsByIdDevicesByDeviceSync(ctx context.Context, id string, device string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/connections/%s/devices/%s/sync", url.PathEscape(id), url.PathEscape(device)), body, nil, opts)
}

// PostIdentityConnectionsByIdRemove: Remove a directory connection (POST /v1/identity/connections/{id}/remove)
func (c *Client) PostIdentityConnectionsByIdRemove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/connections/%s/remove", url.PathEscape(id)), body, nil, opts)
}

// PostIdentityDoorsByKindStart: Start connecting an identity system on its own approval page (send wants to narrow the grant) (POST /v1/identity/doors/{kind}/start)
func (c *Client) PostIdentityDoorsByKindStart(ctx context.Context, kind string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/doors/%s/start", url.PathEscape(kind)), body, nil, opts)
}

// PostIdentityLeavers: Start a leaver's offboarding (POST /v1/identity/leavers)
func (c *Client) PostIdentityLeavers(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/identity/leavers", body, nil, opts)
}

// PostIdentityRefresh: Read the directories again now (POST /v1/identity/refresh)
func (c *Client) PostIdentityRefresh(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/identity/refresh", body, nil, opts)
}

// PostIdentityRunsByIdFirstPassword: Hand over a starter's first password (POST /v1/identity/runs/{id}/first-password)
func (c *Client) PostIdentityRunsByIdFirstPassword(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/runs/%s/first-password", url.PathEscape(id)), body, nil, opts)
}

// PostIdentityRunsByIdResume: Resume a starter or leaver run (POST /v1/identity/runs/{id}/resume)
func (c *Client) PostIdentityRunsByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/identity/runs/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostIdentitySignEveryoneOut: Sign every person in your workspace out at once (POST /v1/identity/sign-everyone-out)
func (c *Client) PostIdentitySignEveryoneOut(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/identity/sign-everyone-out", body, nil, opts)
}

// PostIdentityStarters: Start a starter's onboarding (POST /v1/identity/starters)
func (c *Client) PostIdentityStarters(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/identity/starters", body, nil, opts)
}

// PostIncidentsByIdAck: Acknowledge an incident from wherever its alert reached you (the place is written to its record) (POST /v1/incidents/{id}/ack)
func (c *Client) PostIncidentsByIdAck(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/ack", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdAudiencesByAudienceReviewed: Mark Xovris's draft for one reader as read by a person (POST /v1/incidents/{id}/audiences/{audience}/reviewed)
func (c *Client) PostIncidentsByIdAudiencesByAudienceReviewed(ctx context.Context, id string, audience string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/audiences/%s/reviewed", url.PathEscape(id), url.PathEscape(audience)), body, nil, opts)
}

// PostIncidentsByIdAudiencesWrite: 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)
func (c *Client) PostIncidentsByIdAudiencesWrite(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/audiences/write", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdChoice: Choose what happens next on an incident (POST /v1/incidents/{id}/choice)
func (c *Client) PostIncidentsByIdChoice(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/choice", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdGroupingByProposalReject: 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)
func (c *Client) PostIncidentsByIdGroupingByProposalReject(ctx context.Context, id string, proposal string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/grouping/%s/reject", url.PathEscape(id), url.PathEscape(proposal)), body, nil, opts)
}

// PostIncidentsByIdHere: Say you are on an incident's page, so others working it can see you (POST /v1/incidents/{id}/here)
func (c *Client) PostIncidentsByIdHere(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/here", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdMajor: Declare an incident major in one press, kept once on its own timeline (POST /v1/incidents/{id}/major)
func (c *Client) PostIncidentsByIdMajor(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/major", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdMerge: 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)
func (c *Client) PostIncidentsByIdMerge(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/merge", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdMute: Hold an incident's messages for a time (POST /v1/incidents/{id}/mute)
func (c *Client) PostIncidentsByIdMute(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/mute", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdNotes: Add a note to an incident (a paused investigation wakes on it) (POST /v1/incidents/{id}/notes)
func (c *Client) PostIncidentsByIdNotes(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/notes", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdPin: Pin the incident you are working on, so your own coding agent reads it first (POST /v1/incidents/{id}/pin)
func (c *Client) PostIncidentsByIdPin(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/pin", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdRecordCheck: 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)
func (c *Client) PostIncidentsByIdRecordCheck(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/record/check", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdRepairs: Ask Xovris to fix an incident (POST /v1/incidents/{id}/repairs)
func (c *Client) PostIncidentsByIdRepairs(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/repairs", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdSeverity: Change an incident's severity in one press, saying why, the rating Xovris first stated kept on its record (POST /v1/incidents/{id}/severity)
func (c *Client) PostIncidentsByIdSeverity(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/severity", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdShare: Share an incident's story by link (POST /v1/incidents/{id}/share)
func (c *Client) PostIncidentsByIdShare(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/share", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdShareByRefRevoke: Revoke a shared link (POST /v1/incidents/{id}/share/{ref}/revoke)
func (c *Client) PostIncidentsByIdShareByRefRevoke(ctx context.Context, id string, ref string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/share/%s/revoke", url.PathEscape(id), url.PathEscape(ref)), body, nil, opts)
}

// PostIncidentsByIdSnooze: Snooze an incident until a time, until it gets worse or until something new happens (POST /v1/incidents/{id}/snooze)
func (c *Client) PostIncidentsByIdSnooze(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/snooze", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdStakeholders: 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)
func (c *Client) PostIncidentsByIdStakeholders(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/stakeholders", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdStakeholdersTell: Send an update about a major incident now, to everyone who hears every update (POST /v1/incidents/{id}/stakeholders/tell)
func (c *Client) PostIncidentsByIdStakeholdersTell(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/stakeholders/tell", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdTopUp: 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)
func (c *Client) PostIncidentsByIdTopUp(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/top-up", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdWaitingStepsApprove: 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)
func (c *Client) PostIncidentsByIdWaitingStepsApprove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/waiting-steps/approve", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentsByIdWatch: Watch an incident (POST /v1/incidents/{id}/watch)
func (c *Client) PostIncidentsByIdWatch(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/incidents/%s/watch", url.PathEscape(id)), body, nil, opts)
}

// PostIncidentScopes: Count a window chosen on an incident’s record for its kind (POST /v1/incident-scopes)
func (c *Client) PostIncidentScopes(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/incident-scopes", body, nil, opts)
}

// PostIncidentsReplay: 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)
func (c *Client) PostIncidentsReplay(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/incidents/replay", body, nil, opts)
}

// PostIngestionKeysEnd: End a project's ingestion keys, or list the projects that have live ones (POST /v1/ingestion-keys/end)
func (c *Client) PostIngestionKeysEnd(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/ingestion-keys/end", body, nil, opts)
}

// PostInsiderDetail: Open one person's detail inside an open security incident, with your reason kept (POST /v1/insider/detail)
func (c *Client) PostInsiderDetail(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/insider/detail", body, nil, opts)
}

// PostInsiderReading: See signs of company data leaving or access being misused, each against the person's own usual (POST /v1/insider/reading)
func (c *Client) PostInsiderReading(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/insider/reading", body, nil, opts)
}

// PostInstallRuns: Record an install run (POST /v1/install-runs)
func (c *Client) PostInstallRuns(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/install-runs", body, nil, opts)
}

// PostInstallRunsByRunIdStage: Record an install run's stage (POST /v1/install-runs/{runId}/stage)
func (c *Client) PostInstallRunsByRunIdStage(ctx context.Context, runId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/install-runs/%s/stage", url.PathEscape(runId)), body, nil, opts)
}

// PostInstallRunsByRunIdStops: Read an installer stop no named rule knows (POST /v1/install-runs/{runId}/stops)
func (c *Client) PostInstallRunsByRunIdStops(ctx context.Context, runId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/install-runs/%s/stops", url.PathEscape(runId)), body, nil, opts)
}

// PostIntegrationsChatAnyByTenantByConnectionBySecret: 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})
func (c *Client) PostIntegrationsChatAnyByTenantByConnectionBySecret(ctx context.Context, tenant string, connection string, secret string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/chat/any/%s/%s/%s", url.PathEscape(tenant), url.PathEscape(connection), url.PathEscape(secret)), body, nil, opts)
}

// PostIntegrationsChatDiscordByConnection: Receive what a person asks Xovris in your Discord, checked by Discord's own signature first (POST /v1/integrations/chat/discord/{connection})
func (c *Client) PostIntegrationsChatDiscordByConnection(ctx context.Context, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/chat/discord/%s", url.PathEscape(connection)), body, nil, opts)
}

// PostIntegrationsChatGoogleChatByConnection: Receive what a person asks Xovris in your Google Chat, checked by Google's own token first (POST /v1/integrations/chat/google-chat/{connection})
func (c *Client) PostIntegrationsChatGoogleChatByConnection(ctx context.Context, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/chat/google-chat/%s", url.PathEscape(connection)), body, nil, opts)
}

// PostIntegrationsGithubWebhook: GitHub's deliveries to the Xovris GitHub App (POST /v1/integrations/github/webhook)
func (c *Client) PostIntegrationsGithubWebhook(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/integrations/github/webhook", body, nil, opts)
}

// PostIntegrationsReviewAzureDevopsByConnection: Receive Azure DevOps's pull request events for a connected repository, so the change is reviewed (POST /v1/integrations/review/azure-devops/{connection})
func (c *Client) PostIntegrationsReviewAzureDevopsByConnection(ctx context.Context, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/review/azure-devops/%s", url.PathEscape(connection)), body, nil, opts)
}

// PostIntegrationsReviewBitbucketCloudByConnection: Receive Bitbucket Cloud's pull request events for a connected repository, so the change is reviewed (POST /v1/integrations/review/bitbucket-cloud/{connection})
func (c *Client) PostIntegrationsReviewBitbucketCloudByConnection(ctx context.Context, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/review/bitbucket-cloud/%s", url.PathEscape(connection)), body, nil, opts)
}

// PostIntegrationsReviewBitbucketDcByConnection: Receive Bitbucket Data Center's pull request events for a connected repository, so the change is reviewed (POST /v1/integrations/review/bitbucket-dc/{connection})
func (c *Client) PostIntegrationsReviewBitbucketDcByConnection(ctx context.Context, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/review/bitbucket-dc/%s", url.PathEscape(connection)), body, nil, opts)
}

// PostIntegrationsReviewGitlabByConnection: Receive GitLab's merge request events for a connected project, so the change is reviewed (POST /v1/integrations/review/gitlab/{connection})
func (c *Client) PostIntegrationsReviewGitlabByConnection(ctx context.Context, connection string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/integrations/review/gitlab/%s", url.PathEscape(connection)), body, nil, opts)
}

// PostInvitationsAccept: Accept an invitation as the address it was sent to and join the workspace in its role (POST /v1/invitations/accept)
func (c *Client) PostInvitationsAccept(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/invitations/accept", body, nil, opts)
}

// PostInvitationsDecline: Decline an invitation from its own link, so it is no longer open (POST /v1/invitations/decline)
func (c *Client) PostInvitationsDecline(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/invitations/decline", body, nil, opts)
}

// PostInvitationsRead: 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)
func (c *Client) PostInvitationsRead(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/invitations/read", body, nil, opts)
}

// PostIssues: A new issue, opened by hand: what is wrong, where, what was seen, how urgent and who has it (POST /v1/issues)
func (c *Client) PostIssues(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/issues", body, nil, opts)
}

// PostIssuesByIdAsk: Ask whoever opened an issue for more, and keep it out of the queue until they answer (POST /v1/issues/{id}/ask)
func (c *Client) PostIssuesByIdAsk(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/ask", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdComments: A comment on an issue (POST /v1/issues/{id}/comments)
func (c *Client) PostIssuesByIdComments(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/comments", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdFields: Change an issue's fields, each change kept on its history (POST /v1/issues/{id}/fields)
func (c *Client) PostIssuesByIdFields(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/fields", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdFollow: Follow an issue to be told about every change to it, or stop following it (POST /v1/issues/{id}/follow)
func (c *Client) PostIssuesByIdFollow(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/follow", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdRelations: Link an issue to another: blocks, blocked by, related or duplicate of (POST /v1/issues/{id}/relations)
func (c *Client) PostIssuesByIdRelations(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/relations", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdSeen: Record that you opened an issue (POST /v1/issues/{id}/seen)
func (c *Client) PostIssuesByIdSeen(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/seen", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdStatus: Resolve, ignore or reopen an error (POST /v1/issues/{id}/status)
func (c *Client) PostIssuesByIdStatus(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/status", url.PathEscape(id)), body, nil, opts)
}

// PostIssuesByIdTriage: Set who an error is with and how urgent it is (POST /v1/issues/{id}/triage)
func (c *Client) PostIssuesByIdTriage(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/issues/%s/triage", url.PathEscape(id)), body, nil, opts)
}

// PostLaws: See the laws that apply to your business and what each asks of you (POST /v1/laws)
func (c *Client) PostLaws(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/laws", body, nil, opts)
}

// PostLiveFresh: Send how fresh the live updates read on your screen (POST /v1/live/fresh)
func (c *Client) PostLiveFresh(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/live/fresh", body, nil, opts)
}

// PostLogArchiveDestinations: Add a log archive destination (POST /v1/log-archive/destinations)
func (c *Client) PostLogArchiveDestinations(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/log-archive/destinations", body, nil, opts)
}

// PostLogArchiveDestinationsByIdLifecycle: Have Xovris set how long archived logs are kept (POST /v1/log-archive/destinations/{id}/lifecycle)
func (c *Client) PostLogArchiveDestinationsByIdLifecycle(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-archive/destinations/%s/lifecycle", url.PathEscape(id)), body, nil, opts)
}

// PostLogArchiveDestinationsByIdLifecycleUndo: Put an archive's keeping rules back as they were (POST /v1/log-archive/destinations/{id}/lifecycle/undo)
func (c *Client) PostLogArchiveDestinationsByIdLifecycleUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-archive/destinations/%s/lifecycle/undo", url.PathEscape(id)), body, nil, opts)
}

// PostLogConnections: Connect a log source (POST /v1/log-connections)
func (c *Client) PostLogConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/log-connections", body, nil, opts)
}

// PostLogConnectionsByIdDoorsByDoor: Have Xovris set up a log source through its door (POST /v1/log-connections/{id}/doors/{door})
func (c *Client) PostLogConnectionsByIdDoorsByDoor(ctx context.Context, id string, door string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-connections/%s/doors/%s", url.PathEscape(id), url.PathEscape(door)), body, nil, opts)
}

// PostLogConnectionsByIdDoorsByDoorUndo: Undo a log source Xovris set up (POST /v1/log-connections/{id}/doors/{door}/undo)
func (c *Client) PostLogConnectionsByIdDoorsByDoorUndo(ctx context.Context, id string, door string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-connections/%s/doors/%s/undo", url.PathEscape(id), url.PathEscape(door)), body, nil, opts)
}

// PostLogConnectionsByIdPause: Pause a log connection (POST /v1/log-connections/{id}/pause)
func (c *Client) PostLogConnectionsByIdPause(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-connections/%s/pause", url.PathEscape(id)), body, nil, opts)
}

// PostLogConnectionsByIdResume: Resume a log connection (POST /v1/log-connections/{id}/resume)
func (c *Client) PostLogConnectionsByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-connections/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostLogConnectionsByIdRewire: Have Xovris put a fresh endpoint and secret into a log source's sender (POST /v1/log-connections/{id}/rewire)
func (c *Client) PostLogConnectionsByIdRewire(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/log-connections/%s/rewire", url.PathEscape(id)), body, nil, opts)
}

// PostLogsExplain: Explain an error or log line (POST /v1/logs/explain)
func (c *Client) PostLogsExplain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/logs/explain", body, nil, opts)
}

// PostLogsExplainDoor: Do an explained step on the computer that saw the error (POST /v1/logs/explain/door)
func (c *Client) PostLogsExplainDoor(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/logs/explain/door", body, nil, opts)
}

// PostMailAuthenticate: Have Xovris write the next mail authentication record (POST /v1/mail/authenticate)
func (c *Client) PostMailAuthenticate(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/mail/authenticate", body, nil, opts)
}

// PostMailKeys: 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)
func (c *Client) PostMailKeys(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/mail/keys", body, nil, opts)
}

// PostMailPlan: Plan your mail authentication (POST /v1/mail/plan)
func (c *Client) PostMailPlan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/mail/plan", body, nil, opts)
}

// PostMailRepair: See the exact change for one finding, or have Xovris write it (POST /v1/mail/repair)
func (c *Client) PostMailRepair(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/mail/repair", body, nil, opts)
}

// PostMake: 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)
func (c *Client) PostMake(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/make", body, nil, opts)
}

// PostMcp: Connect an AI coding agent to Xovris over MCP and call its tools (POST /v1/mcp)
func (c *Client) PostMcp(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/mcp", body, nil, opts)
}

// PostMeLearnedForget: Erase what Xovris learned about you - or, as an owner, what it learned across the workspace (POST /v1/me/learned/forget)
func (c *Client) PostMeLearnedForget(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/me/learned/forget", body, nil, opts)
}

// PostMembersInvitations: 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)
func (c *Client) PostMembersInvitations(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/members/invitations", body, nil, opts)
}

// PostModelsOwn: Add or replace your own model - Xovris proves it answers before keeping it, and seals its key (POST /v1/models/own)
func (c *Client) PostModelsOwn(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/models/own", body, nil, opts)
}

// PostMspGrants: Grant your MSP access (POST /v1/msp/grants)
func (c *Client) PostMspGrants(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/msp/grants", body, nil, opts)
}

// PostMspGrantsByIdRevoke: Withdraw an MSP's access (POST /v1/msp/grants/{id}/revoke)
func (c *Client) PostMspGrantsByIdRevoke(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/msp/grants/%s/revoke", url.PathEscape(id)), body, nil, opts)
}

// PostNetworkDefenceEvents: Send your network sensor's events so Xovris can group them into incidents (POST /v1/network-defence/events)
func (c *Client) PostNetworkDefenceEvents(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network-defence/events", body, nil, opts)
}

// PostNetworkDefenceFirewallPolicy: 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)
func (c *Client) PostNetworkDefenceFirewallPolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network-defence/firewall-policy", body, nil, opts)
}

// PostNetworkDefenceIncidentsByIdContain: 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)
func (c *Client) PostNetworkDefenceIncidentsByIdContain(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network-defence/incidents/%s/contain", url.PathEscape(id)), body, nil, opts)
}

// PostNetworkDefenceIncidentsByIdPrevent: Plan a block for a network incident as a dry run, with its expiry and undo (POST /v1/network-defence/incidents/{id}/prevent)
func (c *Client) PostNetworkDefenceIncidentsByIdPrevent(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network-defence/incidents/%s/prevent", url.PathEscape(id)), body, nil, opts)
}

// PostNetworkDefenceIndicators: Add threat indicators for Xovris to hunt for across your network memory (POST /v1/network-defence/indicators)
func (c *Client) PostNetworkDefenceIndicators(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network-defence/indicators", body, nil, opts)
}

// PostNetworkDefencePreventionsByIdUndo: Undo a block Xovris put on one of your machines, read gone there (POST /v1/network-defence/preventions/{id}/undo)
func (c *Client) PostNetworkDefencePreventionsByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network-defence/preventions/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostNetworkDefenceSuppressions: Tell Xovris a kind of network event is expected, so it stops raising incidents for it (POST /v1/network-defence/suppressions)
func (c *Client) PostNetworkDefenceSuppressions(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network-defence/suppressions", body, nil, opts)
}

// PostNetworkDefenceSuppressionsByIdUndo: Undo an expected-traffic rule so its events raise incidents again (POST /v1/network-defence/suppressions/{id}/undo)
func (c *Client) PostNetworkDefenceSuppressionsByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network-defence/suppressions/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostNetworkDevicesConfig: Change a network device's setting through its own model's door - backed up, rehearsed, read back and undoable (POST /v1/network/devices/config)
func (c *Client) PostNetworkDevicesConfig(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/devices/config", body, nil, opts)
}

// PostNetworkDevicesConfigByCheckIdApply: Make the planned change to the device, against the very value the plan read (POST /v1/network/devices/config/{checkId}/apply)
func (c *Client) PostNetworkDevicesConfigByCheckIdApply(ctx context.Context, checkId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network/devices/config/%s/apply", url.PathEscape(checkId)), body, nil, opts)
}

// PostNetworkDevicesConfigByCheckIdUndo: Put the device's setting back from the backup Xovris took, and read it back (POST /v1/network/devices/config/{checkId}/undo)
func (c *Client) PostNetworkDevicesConfigByCheckIdUndo(ctx context.Context, checkId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network/devices/config/%s/undo", url.PathEscape(checkId)), body, nil, opts)
}

// PostNetworkDevicesRead: Read a switch, router or firewall you authorised by SNMP - its model, firmware, ports and settings (POST /v1/network/devices/read)
func (c *Client) PostNetworkDevicesRead(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/devices/read", body, nil, opts)
}

// PostNetworkFirewallPolicy: 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)
func (c *Client) PostNetworkFirewallPolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/firewall-policy", body, nil, opts)
}

// PostNetworkReview: Have Xovris review a network device's configuration against what its own model expects (POST /v1/network/review)
func (c *Client) PostNetworkReview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/review", body, nil, opts)
}

// PostNetworkReviewByCheckIdFix: Have Xovris put right what a network device's review found, read back with its way back kept (POST /v1/network/review/{checkId}/fix)
func (c *Client) PostNetworkReviewByCheckIdFix(ctx context.Context, checkId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network/review/%s/fix", url.PathEscape(checkId)), body, nil, opts)
}

// PostNetworkSourcesNetbox: Have Xovris read your NetBox - its devices, ports, cables and ranges - through NetBox's own API (POST /v1/network/sources/netbox)
func (c *Client) PostNetworkSourcesNetbox(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/sources/netbox", body, nil, opts)
}

// PostNetworkSourcesNetboxWrite: Have Xovris write what it found on your network back into your NetBox, each change read back (POST /v1/network/sources/netbox/write)
func (c *Client) PostNetworkSourcesNetboxWrite(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/sources/netbox/write", body, nil, opts)
}

// PostNetworkTroubleshoot: Have Xovris troubleshoot a network device from a computer on its network - the path, its ports and its configuration (POST /v1/network/troubleshoot)
func (c *Client) PostNetworkTroubleshoot(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/network/troubleshoot", body, nil, opts)
}

// PostNetworkTroubleshootByCheckIdAgain: Run a network troubleshoot again, from the same computer, and see what changed (POST /v1/network/troubleshoot/{checkId}/again)
func (c *Client) PostNetworkTroubleshootByCheckIdAgain(ctx context.Context, checkId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network/troubleshoot/%s/again", url.PathEscape(checkId)), body, nil, opts)
}

// PostNetworkTroubleshootByCheckIdFix: Have Xovris make the fix a network troubleshoot found, then read the device again to prove it (POST /v1/network/troubleshoot/{checkId}/fix)
func (c *Client) PostNetworkTroubleshootByCheckIdFix(ctx context.Context, checkId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/network/troubleshoot/%s/fix", url.PathEscape(checkId)), body, nil, opts)
}

// PostOauthApps: Publish an OAuth app (POST /v1/oauth/apps)
func (c *Client) PostOauthApps(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oauth/apps", body, nil, opts)
}

// PostOauthAppsByIdSecret: Make a new client secret for an OAuth app (POST /v1/oauth/apps/{id}/secret)
func (c *Client) PostOauthAppsByIdSecret(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oauth/apps/%s/secret", url.PathEscape(id)), body, nil, opts)
}

// PostOauthAuthorize: Allow or decline an app (POST /v1/oauth/authorize)
func (c *Client) PostOauthAuthorize(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oauth/authorize", body, nil, opts)
}

// PostOauthDeviceAuthorization: Start a sign-in on a device with no browser (POST /v1/oauth/device_authorization)
func (c *Client) PostOauthDeviceAuthorization(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oauth/device_authorization", body, nil, opts)
}

// PostOauthDeviceByCodeApprove: Approve a device's sign-in (POST /v1/oauth/device/{code}/approve)
func (c *Client) PostOauthDeviceByCodeApprove(ctx context.Context, code string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oauth/device/%s/approve", url.PathEscape(code)), body, nil, opts)
}

// PostOauthDeviceByCodeDeny: Decline a device's sign-in (POST /v1/oauth/device/{code}/deny)
func (c *Client) PostOauthDeviceByCodeDeny(ctx context.Context, code string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oauth/device/%s/deny", url.PathEscape(code)), body, nil, opts)
}

// PostOauthGrantsByIdRevoke: Unlink an app (POST /v1/oauth/grants/{id}/revoke)
func (c *Client) PostOauthGrantsByIdRevoke(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oauth/grants/%s/revoke", url.PathEscape(id)), body, nil, opts)
}

// PostOauthRegister: Register an app or an AI client that signs in with Xovris (POST /v1/oauth/register)
func (c *Client) PostOauthRegister(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oauth/register", body, nil, opts)
}

// PostOauthRevoke: Revoke an OAuth token (POST /v1/oauth/revoke)
func (c *Client) PostOauthRevoke(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oauth/revoke", body, nil, opts)
}

// PostOauthToken: Exchange a code, a refresh token, a device code or a client secret for an access token (POST /v1/oauth/token)
func (c *Client) PostOauthToken(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oauth/token", body, nil, opts)
}

// PostOncallAssign: Hand an alert to the right person on call (POST /v1/oncall/assign)
func (c *Client) PostOncallAssign(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/assign", body, nil, opts)
}

// PostOncallAway: Bring in who is away, so nobody is paged on leave (POST /v1/oncall/away)
func (c *Client) PostOncallAway(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/away", body, nil, opts)
}

// PostOncallCodeowners: Route alerts by a repository's code owners (POST /v1/oncall/codeowners)
func (c *Client) PostOncallCodeowners(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/codeowners", body, nil, opts)
}

// PostOncallCover: Ask for someone to cover your on-call time (POST /v1/oncall/cover)
func (c *Client) PostOncallCover(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/cover", body, nil, opts)
}

// PostOncallCoverByIdAnswer: Answer a request to cover on-call time (POST /v1/oncall/cover/{id}/answer)
func (c *Client) PostOncallCoverByIdAnswer(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oncall/cover/%s/answer", url.PathEscape(id)), body, nil, opts)
}

// PostOncallDrills: Rehearse an escalation policy with a drill that pages its people, hop by hop (POST /v1/oncall/drills)
func (c *Client) PostOncallDrills(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/drills", body, nil, opts)
}

// PostOncallEscalations: Save an escalation policy (POST /v1/oncall/escalations)
func (c *Client) PostOncallEscalations(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/escalations", body, nil, opts)
}

// PostOncallImportByIdUndo: Undo an on-call import (POST /v1/oncall/import/{id}/undo)
func (c *Client) PostOncallImportByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oncall/import/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostOncallImportOpsgenie: Import your Opsgenie on-call set-up (POST /v1/oncall/import/opsgenie)
func (c *Client) PostOncallImportOpsgenie(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/import/opsgenie", body, nil, opts)
}

// PostOncallImportPagerduty: 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)
func (c *Client) PostOncallImportPagerduty(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/import/pagerduty", body, nil, opts)
}

// PostOncallImportPagerdutyGrant: 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)
func (c *Client) PostOncallImportPagerdutyGrant(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/import/pagerduty/grant", body, nil, opts)
}

// PostOncallImportSplunkOncall: 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)
func (c *Client) PostOncallImportSplunkOncall(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/import/splunk-oncall", body, nil, opts)
}

// PostOncallMembersByMemberId: Save an on-call member's country, hours, skills and teams (POST /v1/oncall/members/{memberId})
func (c *Client) PostOncallMembersByMemberId(ctx context.Context, memberId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oncall/members/%s", url.PathEscape(memberId)), body, nil, opts)
}

// PostOncallOpsgenieImport: Import an Opsgenie export, matched to your members (POST /v1/oncall/opsgenie/import)
func (c *Client) PostOncallOpsgenieImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/opsgenie/import", body, nil, opts)
}

// PostOncallOpsgeniePlan: See what an Opsgenie export would bring in before importing it (POST /v1/oncall/opsgenie/plan)
func (c *Client) PostOncallOpsgeniePlan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/opsgenie/plan", body, nil, opts)
}

// PostOncallSchedules: Save an on-call schedule (POST /v1/oncall/schedules)
func (c *Client) PostOncallSchedules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/schedules", body, nil, opts)
}

// PostOncallSchedulesByIdOverrides: Put someone else on call for a stretch of a schedule (POST /v1/oncall/schedules/{id}/overrides)
func (c *Client) PostOncallSchedulesByIdOverrides(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oncall/schedules/%s/overrides", url.PathEscape(id)), body, nil, opts)
}

// PostOncallSchedulesByIdShadows: Let someone shadow a schedule to learn it (POST /v1/oncall/schedules/{id}/shadows)
func (c *Client) PostOncallSchedulesByIdShadows(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/oncall/schedules/%s/shadows", url.PathEscape(id)), body, nil, opts)
}

// PostOncallSchedulesPreview: See the rota a draft schedule would make over the next fortnight, before it is saved (POST /v1/oncall/schedules/preview)
func (c *Client) PostOncallSchedulesPreview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/oncall/schedules/preview", body, nil, opts)
}

// PostOpamp: OpAMP for your collectors (POST /v1/opamp)
func (c *Client) PostOpamp(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/opamp", body, nil, opts)
}

// PostOtlpV1Logs: Send OpenTelemetry logs (POST /v1/otlp/v1/logs)
func (c *Client) PostOtlpV1Logs(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/otlp/v1/logs", body, nil, opts)
}

// PostOtlpV1Metrics: Send OpenTelemetry metrics (POST /v1/otlp/v1/metrics)
func (c *Client) PostOtlpV1Metrics(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/otlp/v1/metrics", body, nil, opts)
}

// PostOtlpV1Traces: Send OpenTelemetry traces (POST /v1/otlp/v1/traces)
func (c *Client) PostOtlpV1Traces(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/otlp/v1/traces", body, nil, opts)
}

// PostPartners: Make a partner key for the embedded check (POST /v1/partners)
func (c *Client) PostPartners(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/partners", body, nil, opts)
}

// PostPartnersAccounts: Provision an account for your customer, in one signed call (POST /v1/partners/accounts)
func (c *Client) PostPartnersAccounts(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/partners/accounts", body, nil, opts)
}

// PostPartnersAccountsByIdDeprovision: Remove an account you provisioned, its export made ready first (POST /v1/partners/accounts/{id}/deprovision)
func (c *Client) PostPartnersAccountsByIdDeprovision(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/partners/accounts/%s/deprovision", url.PathEscape(id)), body, nil, opts)
}

// PostPartnersAccountsByIdResume: Resume an account you suspended (POST /v1/partners/accounts/{id}/resume)
func (c *Client) PostPartnersAccountsByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/partners/accounts/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostPartnersAccountsByIdSuspend: Suspend an account you provisioned (POST /v1/partners/accounts/{id}/suspend)
func (c *Client) PostPartnersAccountsByIdSuspend(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/partners/accounts/%s/suspend", url.PathEscape(id)), body, nil, opts)
}

// PostPartnersAttribute: Credit the partner who sent you (POST /v1/partners/attribute)
func (c *Client) PostPartnersAttribute(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/partners/attribute", body, nil, opts)
}

// PostPartnersByIdRevoke: Revoke a partner key (POST /v1/partners/{id}/revoke)
func (c *Client) PostPartnersByIdRevoke(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/partners/%s/revoke", url.PathEscape(id)), body, nil, opts)
}

// PostPartnersSandboxKeys: Make a provisioning sandbox key (POST /v1/partners/sandbox-keys)
func (c *Client) PostPartnersSandboxKeys(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/partners/sandbox-keys", body, nil, opts)
}

// PostPasswordsHealth: See the company's password health without any password being sent (POST /v1/passwords/health)
func (c *Client) PostPasswordsHealth(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/passwords/health", body, nil, opts)
}

// PostPaymentsConnections: Connect any payment provider by its own API description (POST /v1/payments/connections)
func (c *Client) PostPaymentsConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/payments/connections", body, nil, opts)
}

// PostPaymentsVoiceCheck: Check a payment request for signs of a cloned voice before any money moves (POST /v1/payments/voice-check)
func (c *Client) PostPaymentsVoiceCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/payments/voice-check", body, nil, opts)
}

// PostPeopleMeLeave: 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)
func (c *Client) PostPeopleMeLeave(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/people/me/leave", body, nil, opts)
}

// PostPhishingPractice: See what a phishing practice showed and who needs help next (POST /v1/phishing/practice)
func (c *Client) PostPhishingPractice(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/phishing/practice", body, nil, opts)
}

// PostPipelinesDerived: Make a metric from log lines (POST /v1/pipelines/derived)
func (c *Client) PostPipelinesDerived(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/pipelines/derived", body, nil, opts)
}

// PostPipelinesDerivedByIdMonitors: Watch a metric made from log lines (POST /v1/pipelines/derived/{id}/monitors)
func (c *Client) PostPipelinesDerivedByIdMonitors(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/pipelines/derived/%s/monitors", url.PathEscape(id)), body, nil, opts)
}

// PostPipelinesDestinations: Send logs on to another destination (POST /v1/pipelines/destinations)
func (c *Client) PostPipelinesDestinations(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/pipelines/destinations", body, nil, opts)
}

// PostPipelinesRules: Add log pipeline rules in plain words (POST /v1/pipelines/rules)
func (c *Client) PostPipelinesRules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/pipelines/rules", body, nil, opts)
}

// PostPipelinesRulesPreview: Preview log pipeline rules (POST /v1/pipelines/rules/preview)
func (c *Client) PostPipelinesRulesPreview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/pipelines/rules/preview", body, nil, opts)
}

// PostPostMortem: Draft a post-mortem of an incident from its timeline (POST /v1/post-mortem)
func (c *Client) PostPostMortem(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/post-mortem", body, nil, opts)
}

// PostProceduresByIdVersionsByVersionApprove: Approve one exact version of a runbook so it may run (POST /v1/procedures/{id}/versions/{version}/approve)
func (c *Client) PostProceduresByIdVersionsByVersionApprove(ctx context.Context, id string, version string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/procedures/%s/versions/%s/approve", url.PathEscape(id), url.PathEscape(version)), body, nil, opts)
}

// PostProceduresImport: Import a runbook as a draft that waits for the owner's approval (POST /v1/procedures/import)
func (c *Client) PostProceduresImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/procedures/import", body, nil, opts)
}

// PostProceduresLibraryAdopt: Adopt a procedure from your account's library as a candidate here (POST /v1/procedures/library/adopt)
func (c *Client) PostProceduresLibraryAdopt(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/procedures/library/adopt", body, nil, opts)
}

// PostProfiles: Send a profile from a profiler, folded stacks or pprof, to keep for a service (POST /v1/profiles)
func (c *Client) PostProfiles(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/profiles", body, nil, opts)
}

// PostPrometheusWrite: Send your Prometheus's remote_write (POST /v1/prometheus/write)
func (c *Client) PostPrometheusWrite(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/prometheus/write", body, nil, opts)
}

// PostProtocolChangesByIdUndo: Undo one change Xovris made through a protocol door, read back from the system itself (POST /v1/protocol-changes/{id}/undo)
func (c *Client) PostProtocolChangesByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/protocol-changes/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostProtocolConnections: Connect a broker, store, mailbox, calendar or directory from its address alone - its secret sealed, never shown again (POST /v1/protocol-connections)
func (c *Client) PostProtocolConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/protocol-connections", body, nil, opts)
}

// PostProtocolConnectionsByIdChange: 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)
func (c *Client) PostProtocolConnectionsByIdChange(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/protocol-connections/%s/change", url.PathEscape(id)), body, nil, opts)
}

// PostProtocolConnectionsByIdRead: Read a connected system through its own protocol - messages, files, mail, events or directory entries (POST /v1/protocol-connections/{id}/read)
func (c *Client) PostProtocolConnectionsByIdRead(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/protocol-connections/%s/read", url.PathEscape(id)), body, nil, opts)
}

// PostProtocolConnectionsByIdReading: 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)
func (c *Client) PostProtocolConnectionsByIdReading(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/protocol-connections/%s/reading", url.PathEscape(id)), body, nil, opts)
}

// PostProtocolConnectionsKey: 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)
func (c *Client) PostProtocolConnectionsKey(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/protocol-connections/key", body, nil, opts)
}

// PostPublicBuildHost: Read a host's own prices page for its free allowance and first paid plan (POST /v1/public/build/host)
func (c *Client) PostPublicBuildHost(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/build/host", body, nil, opts)
}

// PostPublicBuildPublish: Put a page made on /build live as a project of your own (POST /v1/public/build/publish)
func (c *Client) PostPublicBuildPublish(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/build/publish", body, nil, opts)
}

// PostPublicBuildPublishByIdLive: Put a built page live on Xovris's own hosting (POST /v1/public/build/publish/{id}/live)
func (c *Client) PostPublicBuildPublishByIdLive(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/build/publish/%s/live", url.PathEscape(id)), body, nil, opts)
}

// PostPublicCheck: Check a website for free (POST /v1/public/check)
func (c *Client) PostPublicCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/check", body, nil, opts)
}

// PostPublicDemoBook: Book a demo with a person from Xovris (POST /v1/public/demo/book)
func (c *Client) PostPublicDemoBook(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/demo/book", body, nil, opts)
}

// PostPublicDemoCancel: Cancel a demo you booked (POST /v1/public/demo/cancel)
func (c *Client) PostPublicDemoCancel(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/demo/cancel", body, nil, opts)
}

// PostPublicDesignImport: Bring a design into a build with no account - a picture, a Figma frame or a page (POST /v1/public/design/import)
func (c *Client) PostPublicDesignImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/design/import", body, nil, opts)
}

// PostPublicDocuments: Make an answer into a file with no account - Word, Excel, PowerPoint or PDF (POST /v1/public/documents)
func (c *Client) PostPublicDocuments(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/documents", body, nil, opts)
}

// PostPublicExplain: Explain an error for free (POST /v1/public/explain)
func (c *Client) PostPublicExplain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/explain", body, nil, opts)
}

// PostPublicFilesRead: Send a file for the site's Ask to read with no account, and ask about it (POST /v1/public/files/read)
func (c *Client) PostPublicFilesRead(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/files/read", body, nil, opts)
}

// PostPublicFingerprint: Read a public website from outside and name the stack, host, DNS and mail provider it runs on (POST /v1/public/fingerprint)
func (c *Client) PostPublicFingerprint(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/fingerprint", body, nil, opts)
}

// PostPublicHandoffByToken: Carry a waiting job on from its notice - the person who asked, or the approval chain at their turn (POST /v1/public/handoff/{token})
func (c *Client) PostPublicHandoffByToken(ctx context.Context, token string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/handoff/%s", url.PathEscape(token)), body, nil, opts)
}

// PostPublicHelper: Ask Xovris on the website (POST /v1/public/helper)
func (c *Client) PostPublicHelper(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/helper", body, nil, opts)
}

// PostPublicHelperHandoff: Carry your conversation with Xovris on the website into the account you are making, on your recorded consent (POST /v1/public/helper/handoff)
func (c *Client) PostPublicHelperHandoff(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/helper/handoff", body, nil, opts)
}

// PostPublicHostsIdentify: Ask who runs the outside scripts no list names yet - addresses only, never their query (POST /v1/public/hosts/identify)
func (c *Client) PostPublicHostsIdentify(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/hosts/identify", body, nil, opts)
}

// PostPublicKeysRevoke: End an ingestion key with the key itself, no sign-in needed (POST /v1/public/keys/revoke)
func (c *Client) PostPublicKeysRevoke(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/keys/revoke", body, nil, opts)
}

// PostPublicLivePreviews: 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)
func (c *Client) PostPublicLivePreviews(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/live-previews", body, nil, opts)
}

// PostPublicLivePreviewsById: Send the next version of a shared page - every phone on its link shows it within a second (POST /v1/public/live-previews/{id})
func (c *Client) PostPublicLivePreviewsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/live-previews/%s", url.PathEscape(id)), body, nil, opts)
}

// PostPublicLivePreviewsByIdEnd: End a shared page's link - the page is deleted at once (POST /v1/public/live-previews/{id}/end)
func (c *Client) PostPublicLivePreviewsByIdEnd(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/live-previews/%s/end", url.PathEscape(id)), body, nil, opts)
}

// PostPublicMailCheck: An email check: an address of your own for a day, which reads the message you send to it (POST /v1/public/mail-check)
func (c *Client) PostPublicMailCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/mail-check", body, nil, opts)
}

// PostPublicMcp: Run the free website check from an MCP client (POST /v1/public/mcp)
func (c *Client) PostPublicMcp(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/mcp", body, nil, opts)
}

// PostPublicRouterExposure: 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)
func (c *Client) PostPublicRouterExposure(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/router-exposure", body, nil, opts)
}

// PostPublicRunLessons: Keep what a run on the signed-in person's own computer learned, in their workspace (POST /v1/public/run-lessons)
func (c *Client) PostPublicRunLessons(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/run-lessons", body, nil, opts)
}

// PostPublicSample: Open the sample workspace with no sign-up (POST /v1/public/sample)
func (c *Client) PostPublicSample(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/sample", body, nil, opts)
}

// PostPublicSampleEnd: Leave the sample workspace (POST /v1/public/sample/end)
func (c *Client) PostPublicSampleEnd(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/sample/end", body, nil, opts)
}

// PostPublicScamCheck: Check a message for a scam, free (POST /v1/public/scam-check)
func (c *Client) PostPublicScamCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/scam-check", body, nil, opts)
}

// PostPublicSignInCode: Send a sign-in code to an email address (POST /v1/public/sign-in/code)
func (c *Client) PostPublicSignInCode(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/sign-in/code", body, nil, opts)
}

// PostPublicSignInCodeCheck: Check a sign-in code and start the session (POST /v1/public/sign-in/code/check)
func (c *Client) PostPublicSignInCodeCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/sign-in/code/check", body, nil, opts)
}

// PostPublicSignOut: Sign out of this page's session (POST /v1/public/sign-out)
func (c *Client) PostPublicSignOut(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/sign-out", body, nil, opts)
}

// PostPublicSiteErrors: Report the website's own browser errors (POST /v1/public/site-errors)
func (c *Client) PostPublicSiteErrors(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/site-errors", body, nil, opts)
}

// PostPublicSiteReports: Receive the browser's reports for the website (POST /v1/public/site-reports)
func (c *Client) PostPublicSiteReports(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/site-reports", body, nil, opts)
}

// PostPublicStatusBySlugConfirm: Confirm a subscription to a workspace's status page (POST /v1/public/status/{slug}/confirm)
func (c *Client) PostPublicStatusBySlugConfirm(ctx context.Context, slug string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/status/%s/confirm", url.PathEscape(slug)), body, nil, opts)
}

// PostPublicStatusBySlugSubscribe: Subscribe to a workspace's status page (POST /v1/public/status/{slug}/subscribe)
func (c *Client) PostPublicStatusBySlugSubscribe(ctx context.Context, slug string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/status/%s/subscribe", url.PathEscape(slug)), body, nil, opts)
}

// PostPublicStatusBySlugUnlock: 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)
func (c *Client) PostPublicStatusBySlugUnlock(ctx context.Context, slug string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/status/%s/unlock", url.PathEscape(slug)), body, nil, opts)
}

// PostPublicStatusBySlugUnsubscribe: Unsubscribe from a workspace's status page (POST /v1/public/status/{slug}/unsubscribe)
func (c *Client) PostPublicStatusBySlugUnsubscribe(ctx context.Context, slug string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/status/%s/unsubscribe", url.PathEscape(slug)), body, nil, opts)
}

// PostPublicStatusConfirm: Confirm a status subscription (POST /v1/public/status/confirm)
func (c *Client) PostPublicStatusConfirm(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/status/confirm", body, nil, opts)
}

// PostPublicStatusSubscribe: Subscribe to Xovris's status (POST /v1/public/status/subscribe)
func (c *Client) PostPublicStatusSubscribe(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/status/subscribe", body, nil, opts)
}

// PostPublicStatusUnsubscribe: Unsubscribe from Xovris's status (POST /v1/public/status/unsubscribe)
func (c *Client) PostPublicStatusUnsubscribe(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/status/unsubscribe", body, nil, opts)
}

// PostPublicTvPairings: Ask for a code to pair a TV (POST /v1/public/tv/pairings)
func (c *Client) PostPublicTvPairings(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/public/tv/pairings", body, nil, opts)
}

// PostPublicTvPairingsByPairingIdSignIn: Send a TV's sign-in to its account's email or phone (POST /v1/public/tv/pairings/{pairingId}/sign-in)
func (c *Client) PostPublicTvPairingsByPairingIdSignIn(ctx context.Context, pairingId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/tv/pairings/%s/sign-in", url.PathEscape(pairingId)), body, nil, opts)
}

// PostPublicTvPairingsByPairingIdSignInCode: Sign a TV in with the code from its message (POST /v1/public/tv/pairings/{pairingId}/sign-in/code)
func (c *Client) PostPublicTvPairingsByPairingIdSignInCode(ctx context.Context, pairingId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/public/tv/pairings/%s/sign-in/code", url.PathEscape(pairingId)), body, nil, opts)
}

// PostQrCheck: Check a QR code before anyone scans it (POST /v1/qr/check)
func (c *Client) PostQrCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/qr/check", body, nil, opts)
}

// PostQueries: Save a query (POST /v1/queries)
func (c *Client) PostQueries(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/queries", body, nil, opts)
}

// PostQueriesByIdRun: Run a saved query (POST /v1/queries/{id}/run)
func (c *Client) PostQueriesByIdRun(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/queries/%s/run", url.PathEscape(id)), body, nil, opts)
}

// PostQuery: Run a query over logs, metrics or traces (POST /v1/query)
func (c *Client) PostQuery(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/query", body, nil, opts)
}

// PostQueryCheck: Explain a query and check it for mistakes (POST /v1/query/check)
func (c *Client) PostQueryCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/query/check", body, nil, opts)
}

// PostReadings: Ask Xovris to read a subject now (POST /v1/readings)
func (c *Client) PostReadings(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/readings", body, nil, opts)
}

// PostRecoveries: Record money that came back for an incident, with its proof (POST /v1/recoveries)
func (c *Client) PostRecoveries(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/recoveries", body, nil, opts)
}

// PostRepairsByIdApprove: Approve a fix (POST /v1/repairs/{id}/approve)
func (c *Client) PostRepairsByIdApprove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/repairs/%s/approve", url.PathEscape(id)), body, nil, opts)
}

// PostRepairsByIdReject: Decline a fix (POST /v1/repairs/{id}/reject)
func (c *Client) PostRepairsByIdReject(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/repairs/%s/reject", url.PathEscape(id)), body, nil, opts)
}

// PostRepairsByIdRevise: Ask for a fix to be changed (POST /v1/repairs/{id}/revise)
func (c *Client) PostRepairsByIdRevise(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/repairs/%s/revise", url.PathEscape(id)), body, nil, opts)
}

// PostRescueKit: Get the steps that rescue a device from what it is doing wrong (POST /v1/rescue-kit)
func (c *Client) PostRescueKit(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/rescue-kit", body, nil, opts)
}

// PostReviewsAsk: 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)
func (c *Client) PostReviewsAsk(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/ask", body, nil, opts)
}

// PostReviewsBillImport: Xovris reads a CycloneDX or SPDX bill you already have as your own - licences, policy and exports included (POST /v1/reviews/bill/import)
func (c *Client) PostReviewsBillImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/bill/import", body, nil, opts)
}

// PostReviewsConflicts: 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)
func (c *Client) PostReviewsConflicts(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/conflicts", body, nil, opts)
}

// PostReviewsIssues: 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)
func (c *Client) PostReviewsIssues(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/issues", body, nil, opts)
}

// PostReviewsLicencePolicy: Xovris keeps the licences your workspace allows, reviews or refuses, with who chose them (POST /v1/reviews/licence-policy)
func (c *Client) PostReviewsLicencePolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/licence-policy", body, nil, opts)
}

// PostReviewsMergeQueue: 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)
func (c *Client) PostReviewsMergeQueue(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/merge-queue", body, nil, opts)
}

// PostReviewsPreferences: Set a code review preference for a repository, or for every repository (POST /v1/reviews/preferences)
func (c *Client) PostReviewsPreferences(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/preferences", body, nil, opts)
}

// PostReviewsPreferencesImport: Bring in the review rules a repository already writes down, as preferences (POST /v1/reviews/preferences/import)
func (c *Client) PostReviewsPreferencesImport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/preferences/import", body, nil, opts)
}

// PostReviewsRun: Have Xovris review everything you connected now (POST /v1/reviews/run)
func (c *Client) PostReviewsRun(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/run", body, nil, opts)
}

// PostReviewsSchedules: 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)
func (c *Client) PostReviewsSchedules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/schedules", body, nil, opts)
}

// PostReviewsTasks: Hand Xovris a coding task on a connected repository; it answers with the task to follow (POST /v1/reviews/tasks)
func (c *Client) PostReviewsTasks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/tasks", body, nil, opts)
}

// PostReviewsViews: Save a view of the code review findings under a name (POST /v1/reviews/views)
func (c *Client) PostReviewsViews(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/reviews/views", body, nil, opts)
}

// PostRoleGrants: 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)
func (c *Client) PostRoleGrants(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/role-grants", body, nil, opts)
}

// PostRoles: Make a custom role from single permissions and groups - never more than the person making it holds (POST /v1/roles)
func (c *Client) PostRoles(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/roles", body, nil, opts)
}

// PostRolesByIdRestore: Restore a deleted custom role with its permissions (POST /v1/roles/{id}/restore)
func (c *Client) PostRolesByIdRestore(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/roles/%s/restore", url.PathEscape(id)), body, nil, opts)
}

// PostRum: Real-user signals from the browser SDK, masked again and kept for the session (POST /v1/rum)
func (c *Client) PostRum(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/rum", body, nil, opts)
}

// PostRumExternal: Connect a replay tool with a token that reads its replays (POST /v1/rum/external)
func (c *Client) PostRumExternal(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/rum/external", body, nil, opts)
}

// PostRumFeedback: A visitor's note, linked to the session it came from (POST /v1/rum/feedback)
func (c *Client) PostRumFeedback(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/rum/feedback", body, nil, opts)
}

// PostRumReplay: A masked replay chunk, kept with consent and within the plan's replays (POST /v1/rum/replay)
func (c *Client) PostRumReplay(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/rum/replay", body, nil, opts)
}

// PostSandbox: Make your developer sandbox (POST /v1/sandbox)
func (c *Client) PostSandbox(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sandbox", body, nil, opts)
}

// PostScamCheck: Check a message for a scam (POST /v1/scam/check)
func (c *Client) PostScamCheck(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/scam/check", body, nil, opts)
}

// PostScamPhone: 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)
func (c *Client) PostScamPhone(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/scam/phone", body, nil, opts)
}

// PostScamReport: Report a scam site for its takedown (POST /v1/scam/report)
func (c *Client) PostScamReport(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/scam/report", body, nil, opts)
}

// PostScimV2Groups: 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)
func (c *Client) PostScimV2Groups(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/scim/v2/Groups", body, nil, opts)
}

// PostScimV2Users: 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)
func (c *Client) PostScimV2Users(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/scim/v2/Users", body, nil, opts)
}

// PostSearches: Save a search on a list, for you or for your workspace (POST /v1/searches)
func (c *Client) PostSearches(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/searches", body, nil, opts)
}

// PostSecretScanningGithub: Where GitHub reports an Xovris key found in public, so it is revoked at once (POST /v1/secret-scanning/github)
func (c *Client) PostSecretScanningGithub(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/secret-scanning/github", body, nil, opts)
}

// PostSecurityEmergency: Start emergency mode: an incident, the records preserved, the steps and the people paged (POST /v1/security/emergency)
func (c *Client) PostSecurityEmergency(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/security/emergency", body, nil, opts)
}

// PostSecurityPostureFixesByIdState: 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)
func (c *Client) PostSecurityPostureFixesByIdState(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/security/posture/fixes/%s/state", url.PathEscape(id)), body, nil, opts)
}

// PostSecurityStackConnections: Connect a security tool you already use (POST /v1/security-stack/connections)
func (c *Client) PostSecurityStackConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/security-stack/connections", body, nil, opts)
}

// PostSecurityStackConnectionsByIdActions: Have Xovris act through a security tool, such as containing a device (POST /v1/security-stack/connections/{id}/actions)
func (c *Client) PostSecurityStackConnectionsByIdActions(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/security-stack/connections/%s/actions", url.PathEscape(id)), body, nil, opts)
}

// PostSecurityStackConnectionsByIdRead: Have Xovris read a security tool's devices and findings now (POST /v1/security-stack/connections/{id}/read)
func (c *Client) PostSecurityStackConnectionsByIdRead(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/security-stack/connections/%s/read", url.PathEscape(id)), body, nil, opts)
}

// PostSecurityZeroDaysByIdReport: Send a zero-day's report to its maker's own security contact (an owner or admin) (POST /v1/security/zero-days/{id}/report)
func (c *Client) PostSecurityZeroDaysByIdReport(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/security/zero-days/%s/report", url.PathEscape(id)), body, nil, opts)
}

// PostSentryIssuesByOrgByIssueIdResolve: Mark one Sentry issue resolved from Xovris once its fix is proven (POST /v1/sentry/issues/{org}/{issueId}/resolve)
func (c *Client) PostSentryIssuesByOrgByIssueIdResolve(ctx context.Context, org string, issueId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/sentry/issues/%s/%s/resolve", url.PathEscape(org), url.PathEscape(issueId)), body, nil, opts)
}

// PostSessions: Start an AI work session in the cloud that you can follow from any device (POST /v1/sessions)
func (c *Client) PostSessions(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions", body, nil, opts)
}

// PostSessionsActivities: Follow a session on a phone's lock screen as it works (POST /v1/sessions/activities)
func (c *Client) PostSessionsActivities(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions/activities", body, nil, opts)
}

// PostSessionsByIdAnswers: Answer a session's question so its work carries on (POST /v1/sessions/{id}/answers)
func (c *Client) PostSessionsByIdAnswers(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/sessions/%s/answers", url.PathEscape(id)), body, nil, opts)
}

// PostSessionsByIdMessages: Send a running session a message - it reads it at its next step (POST /v1/sessions/{id}/messages)
func (c *Client) PostSessionsByIdMessages(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/sessions/%s/messages", url.PathEscape(id)), body, nil, opts)
}

// PostSessionsByIdStop: Stop a running session (POST /v1/sessions/{id}/stop)
func (c *Client) PostSessionsByIdStop(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/sessions/%s/stop", url.PathEscape(id)), body, nil, opts)
}

// PostSessionsDevices: Add a device that follows your sessions (POST /v1/sessions/devices)
func (c *Client) PostSessionsDevices(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions/devices", body, nil, opts)
}

// PostSessionsDevicesExchange: Finish pairing a device with the code it was shown (POST /v1/sessions/devices/exchange)
func (c *Client) PostSessionsDevicesExchange(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions/devices/exchange", body, nil, opts)
}

// PostSessionsDevicesLinks: Make a one-time link that pairs a device with your sessions (POST /v1/sessions/devices/links)
func (c *Client) PostSessionsDevicesLinks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions/devices/links", body, nil, opts)
}

// PostSessionsPresence: Say which device you are on now, so a session tells you there first (POST /v1/sessions/presence)
func (c *Client) PostSessionsPresence(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions/presence", body, nil, opts)
}

// PostSessionsTell: Tell your devices, in your order, that a session needs you (POST /v1/sessions/tell)
func (c *Client) PostSessionsTell(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sessions/tell", body, nil, opts)
}

// PostSettingsAutonomySuggestionsByIdByChoice: Accept or dismiss a suggestion to trust Xovris more (POST /v1/settings/autonomy/suggestions/{id}/{choice})
func (c *Client) PostSettingsAutonomySuggestionsByIdByChoice(ctx context.Context, id string, choice string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/settings/autonomy/suggestions/%s/%s", url.PathEscape(id), url.PathEscape(choice)), body, nil, opts)
}

// PostSettingsBillingEligibility: Have Xovris read your school or your charity's register and keep the verdict (POST /v1/settings/billing/eligibility)
func (c *Client) PostSettingsBillingEligibility(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/billing/eligibility", body, nil, opts)
}

// PostSettingsBusyPeriods: Add a busy period that holds risky changes (POST /v1/settings/busy-periods)
func (c *Client) PostSettingsBusyPeriods(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/busy-periods", body, nil, opts)
}

// PostSettingsCalendars: Connect a calendar of busy periods (POST /v1/settings/calendars)
func (c *Client) PostSettingsCalendars(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/calendars", body, nil, opts)
}

// PostSettingsChangeWindows: Set a maintenance window or a freeze on changes (POST /v1/settings/change-windows)
func (c *Client) PostSettingsChangeWindows(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/change-windows", body, nil, opts)
}

// PostSettingsPlan: Ask to change your plan; it takes effect once payment is confirmed (POST /v1/settings/plan)
func (c *Client) PostSettingsPlan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/plan", body, nil, opts)
}

// PostSettingsPlanCheckout: A plan's checkout, at its one approved price (POST /v1/settings/plan/checkout)
func (c *Client) PostSettingsPlanCheckout(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/plan/checkout", body, nil, opts)
}

// PostSettingsPlanPacksCheckout: A pack of fixes for this month, bought ahead at its one approved price (POST /v1/settings/plan/packs/checkout)
func (c *Client) PostSettingsPlanPacksCheckout(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/plan/packs/checkout", body, nil, opts)
}

// PostSettingsPlanPreview: See exactly what a plan change would cost before you choose (POST /v1/settings/plan/preview)
func (c *Client) PostSettingsPlanPreview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/settings/plan/preview", body, nil, opts)
}

// PostSetupGrants: Give Xovris standing permission (POST /v1/setup/grants)
func (c *Client) PostSetupGrants(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/setup/grants", body, nil, opts)
}

// PostSetupRecipesByIdResearch: Draft the research a connection recipe needs, from its own sources (POST /v1/setup/recipes/{id}/research)
func (c *Client) PostSetupRecipesByIdResearch(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/recipes/%s/research", url.PathEscape(id)), body, nil, opts)
}

// PostSetupResearch: Ask Xovris to research a provider it does not know yet (POST /v1/setup/research)
func (c *Client) PostSetupResearch(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/setup/research", body, nil, opts)
}

// PostSetupResearchByIdStart: Start the researched plan for a connection, tested by reading before it changes anything (POST /v1/setup/research/{id}/start)
func (c *Client) PostSetupResearchByIdStart(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/research/%s/start", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRuns: Start a set-up (POST /v1/setup/runs)
func (c *Client) PostSetupRuns(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/setup/runs", body, nil, opts)
}

// PostSetupRunsByIdBudget: Answer a set-up's AI budget question (POST /v1/setup/runs/{id}/budget)
func (c *Client) PostSetupRunsByIdBudget(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/budget", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdConsent: Agree to (or refuse) a set-up's changes (POST /v1/setup/runs/{id}/consent)
func (c *Client) PostSetupRunsByIdConsent(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/consent", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdContinue: Continue a stopped set-up without redoing what still stands (POST /v1/setup/runs/{id}/continue)
func (c *Client) PostSetupRunsByIdContinue(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/continue", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdCredential: 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)
func (c *Client) PostSetupRunsByIdCredential(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/credential", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdDisconnect: Disconnect a set-up (POST /v1/setup/runs/{id}/disconnect)
func (c *Client) PostSetupRunsByIdDisconnect(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/disconnect", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdPause: Pause a set-up (POST /v1/setup/runs/{id}/pause)
func (c *Client) PostSetupRunsByIdPause(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/pause", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdReconnected: Continue a set-up after reconnecting its provider (POST /v1/setup/runs/{id}/reconnected)
func (c *Client) PostSetupRunsByIdReconnected(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/reconnected", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdResume: Resume a set-up (POST /v1/setup/runs/{id}/resume)
func (c *Client) PostSetupRunsByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostSetupRunsByIdStepsByStepIdApprove: Approve a set-up step (POST /v1/setup/runs/{id}/steps/{stepId}/approve)
func (c *Client) PostSetupRunsByIdStepsByStepIdApprove(ctx context.Context, id string, stepId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/steps/%s/approve", url.PathEscape(id), url.PathEscape(stepId)), body, nil, opts)
}

// PostSetupRunsByIdStepsByStepIdConnection: Hand a set-up the connection you signed in with, proved by reading it back (POST /v1/setup/runs/{id}/steps/{stepId}/connection)
func (c *Client) PostSetupRunsByIdStepsByStepIdConnection(ctx context.Context, id string, stepId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/steps/%s/connection", url.PathEscape(id), url.PathEscape(stepId)), body, nil, opts)
}

// PostSetupRunsByIdStepsByStepIdDone: Say a physical step of a set-up is done (Xovris then proves it) (POST /v1/setup/runs/{id}/steps/{stepId}/done)
func (c *Client) PostSetupRunsByIdStepsByStepIdDone(ctx context.Context, id string, stepId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/steps/%s/done", url.PathEscape(id), url.PathEscape(stepId)), body, nil, opts)
}

// PostSetupRunsByIdStop: Stop a set-up and undo it (POST /v1/setup/runs/{id}/stop)
func (c *Client) PostSetupRunsByIdStop(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/runs/%s/stop", url.PathEscape(id)), body, nil, opts)
}

// PostSetupStepsByStepByAction: Do or skip a setup step (POST /v1/setup/steps/{step}/{action})
func (c *Client) PostSetupStepsByStepByAction(ctx context.Context, step string, action string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/steps/%s/%s", url.PathEscape(step), url.PathEscape(action)), body, nil, opts)
}

// PostSetupTakeovers: Hand a setup step to Xovris (POST /v1/setup/takeovers)
func (c *Client) PostSetupTakeovers(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/setup/takeovers", body, nil, opts)
}

// PostSetupTakeoversByIdAnswer: Answer a hand-over's question (POST /v1/setup/takeovers/{id}/answer)
func (c *Client) PostSetupTakeoversByIdAnswer(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/answer", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdApprove: Approve a hand-over's next step (POST /v1/setup/takeovers/{id}/approve)
func (c *Client) PostSetupTakeoversByIdApprove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/approve", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdCatch: Catch the value a set-up page shows, once, into Xovris (POST /v1/setup/takeovers/{id}/catch)
func (c *Client) PostSetupTakeoversByIdCatch(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/catch", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdContinue: Continue a hand-over (POST /v1/setup/takeovers/{id}/continue)
func (c *Client) PostSetupTakeoversByIdContinue(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/continue", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdEvidenceByRunRedrive: Replay a recorded set-up against the site, step by step (POST /v1/setup/takeovers/{id}/evidence/{run}/redrive)
func (c *Client) PostSetupTakeoversByIdEvidenceByRunRedrive(ctx context.Context, id string, run string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/evidence/%s/redrive", url.PathEscape(id), url.PathEscape(run)), body, nil, opts)
}

// PostSetupTakeoversByIdHandover: Hand a takeover back to the person, with what Xovris did so far (POST /v1/setup/takeovers/{id}/handover)
func (c *Client) PostSetupTakeoversByIdHandover(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/handover", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdInput: Type into a hand-over (POST /v1/setup/takeovers/{id}/input)
func (c *Client) PostSetupTakeoversByIdInput(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/input", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdKey: Give a guided set-up the key you made, kept only once the provider accepts it (POST /v1/setup/takeovers/{id}/key)
func (c *Client) PostSetupTakeoversByIdKey(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/key", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdResume: Resume a paused takeover from where it stopped (POST /v1/setup/takeovers/{id}/resume)
func (c *Client) PostSetupTakeoversByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdSignedIn: Say you have signed in during a hand-over (POST /v1/setup/takeovers/{id}/signed-in)
func (c *Client) PostSetupTakeoversByIdSignedIn(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/signed-in", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdStepsByStepIdDone: Mark a hand-over step done (POST /v1/setup/takeovers/{id}/steps/{stepId}/done)
func (c *Client) PostSetupTakeoversByIdStepsByStepIdDone(ctx context.Context, id string, stepId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/steps/%s/done", url.PathEscape(id), url.PathEscape(stepId)), body, nil, opts)
}

// PostSetupTakeoversByIdStop: Stop a hand-over (POST /v1/setup/takeovers/{id}/stop)
func (c *Client) PostSetupTakeoversByIdStop(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/stop", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdTakeBack: Take back control from Xovris while it is setting something up for you (POST /v1/setup/takeovers/{id}/take-back)
func (c *Client) PostSetupTakeoversByIdTakeBack(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/take-back", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTakeoversByIdUndo: Undo a hand-over (POST /v1/setup/takeovers/{id}/undo)
func (c *Client) PostSetupTakeoversByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/setup/takeovers/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostSetupTestAlert: Send a test alert (POST /v1/setup/test-alert)
func (c *Client) PostSetupTestAlert(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/setup/test-alert", body, nil, opts)
}

// PostSimSwap: See which accounts are at risk if someone takes over a phone number (POST /v1/sim-swap)
func (c *Client) PostSimSwap(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sim-swap", body, nil, opts)
}

// PostSlaCredit: See the credit a provider owes you for its downtime, in your own currency (POST /v1/sla/credit)
func (c *Client) PostSlaCredit(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sla/credit", body, nil, opts)
}

// PostSsoProviders: Xovris connects your company's identity provider (OpenID Connect or SAML) for the email domain your people sign in with (POST /v1/sso/providers)
func (c *Client) PostSsoProviders(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/sso/providers", body, nil, opts)
}

// PostSsoProvidersByProviderIdTest: Test a company sign-in to its identity provider and back - nobody is created, signed in or joined (POST /v1/sso/providers/{providerId}/test)
func (c *Client) PostSsoProvidersByProviderIdTest(ctx context.Context, providerId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/sso/providers/%s/test", url.PathEscape(providerId)), body, nil, opts)
}

// PostSsoProvidersByProviderIdVerify: 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)
func (c *Client) PostSsoProvidersByProviderIdVerify(ctx context.Context, providerId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/sso/providers/%s/verify", url.PathEscape(providerId)), body, nil, opts)
}

// PostStatementSaved: See the time and money Xovris saved this month, measured fix by fix at your own rates (POST /v1/statement/saved)
func (c *Client) PostStatementSaved(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/statement/saved", body, nil, opts)
}

// PostStatusPages: A new status page beside the ones the workspace keeps - its own address, parts, followers and updates (POST /v1/status-pages)
func (c *Client) PostStatusPages(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/status-pages", body, nil, opts)
}

// PostStatusPagesByIdAudiences: 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)
func (c *Client) PostStatusPagesByIdAudiences(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/status-pages/%s/audiences", url.PathEscape(id)), body, nil, opts)
}

// PostStatusPagesByIdMaintenance: 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)
func (c *Client) PostStatusPagesByIdMaintenance(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/status-pages/%s/maintenance", url.PathEscape(id)), body, nil, opts)
}

// PostStatusPagesByIdOpen: 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)
func (c *Client) PostStatusPagesByIdOpen(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/status-pages/%s/open", url.PathEscape(id)), body, nil, opts)
}

// PostStatusPageUpdates: Post an update on your status page (POST /v1/status-page/updates)
func (c *Client) PostStatusPageUpdates(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/status-page/updates", body, nil, opts)
}

// PostStorageInventoryFields: Have Xovris add the fields a bucket's inventory is missing, written and read back from S3 (POST /v1/storage/inventory-fields)
func (c *Client) PostStorageInventoryFields(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/storage/inventory-fields", body, nil, opts)
}

// PostStorageInventoryFieldsByIdUndo: Put a bucket's inventory configuration back exactly as it was (POST /v1/storage/inventory-fields/{id}/undo)
func (c *Client) PostStorageInventoryFieldsByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/storage/inventory-fields/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostStorageWaste: Find wasted object storage and plan the saving (POST /v1/storage/waste)
func (c *Client) PostStorageWaste(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/storage/waste", body, nil, opts)
}

// PostStorageWasteByIdVerify: Prove a storage saving 30 days on (POST /v1/storage/waste/{id}/verify)
func (c *Client) PostStorageWasteByIdVerify(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/storage/waste/%s/verify", url.PathEscape(id)), body, nil, opts)
}

// PostStorageWasteRead: Have Xovris read each bucket's own inventory report and plan every saving it finds, changing nothing (POST /v1/storage/waste/read)
func (c *Client) PostStorageWasteRead(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/storage/waste/read", body, nil, opts)
}

// PostStripeConnect: Connect Stripe (POST /v1/stripe/connect)
func (c *Client) PostStripeConnect(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/stripe/connect", body, nil, opts)
}

// PostStripeRefunds: Refund a payment (POST /v1/stripe/refunds)
func (c *Client) PostStripeRefunds(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/stripe/refunds", body, nil, opts)
}

// PostStripeReviewsApprove: Approve a payment held for review (POST /v1/stripe/reviews/approve)
func (c *Client) PostStripeReviewsApprove(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/stripe/reviews/approve", body, nil, opts)
}

// PostSubscriptionsSaver: Find what you pay for and do not use, and cancel or downgrade each one on your yes (POST /v1/subscriptions/saver)
func (c *Client) PostSubscriptionsSaver(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/subscriptions/saver", body, nil, opts)
}

// PostSuppliersImpact: See what a supplier's incident means for you, and have Xovris act on it (POST /v1/suppliers/impact)
func (c *Client) PostSuppliersImpact(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/suppliers/impact", body, nil, opts)
}

// PostSystems: Connect any system by its address - Xovris reads what it says about itself and looks after what is on it (POST /v1/systems)
func (c *Client) PostSystems(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/systems", body, nil, opts)
}

// PostSystemsGeneralRuns: Ask Xovris to do a job on any system it can reach (POST /v1/systems/general-runs)
func (c *Client) PostSystemsGeneralRuns(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/systems/general-runs", body, nil, opts)
}

// PostSystemsGeneralRunsByJobFeedback: Tell Xovris how a job went - undone, a complaint or thanks (POST /v1/systems/general-runs/{job}/feedback)
func (c *Client) PostSystemsGeneralRunsByJobFeedback(ctx context.Context, job string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/systems/general-runs/%s/feedback", url.PathEscape(job)), body, nil, opts)
}

// PostSystemsGeneralRunsJobsByJobRecordCheck: Check that a job's signed recording is whole and unchanged (POST /v1/systems/general-runs/jobs/{job}/record/check)
func (c *Client) PostSystemsGeneralRunsJobsByJobRecordCheck(ctx context.Context, job string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/systems/general-runs/jobs/%s/record/check", url.PathEscape(job)), body, nil, opts)
}

// PostSystemsGeneralRunsMemoryCorrections: Tell Xovris what you meant, as a rule kept only for you (POST /v1/systems/general-runs/memory/corrections)
func (c *Client) PostSystemsGeneralRunsMemoryCorrections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/systems/general-runs/memory/corrections", body, nil, opts)
}

// PostSystemsGeneralRunsSchedules: Have Xovris check something on a system unasked and tell you only what changed (POST /v1/systems/general-runs/schedules)
func (c *Client) PostSystemsGeneralRunsSchedules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/systems/general-runs/schedules", body, nil, opts)
}

// PostSystemsGeneralRunsStandingByIdByAct: Accept a standing yes Xovris offered, or take one back (POST /v1/systems/general-runs/standing/{id}/{act})
func (c *Client) PostSystemsGeneralRunsStandingByIdByAct(ctx context.Context, id string, act string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/systems/general-runs/standing/%s/%s", url.PathEscape(id), url.PathEscape(act)), body, nil, opts)
}

// PostSystemsProfiles: Connect a system by what it publishes (POST /v1/systems/profiles)
func (c *Client) PostSystemsProfiles(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/systems/profiles", body, nil, opts)
}

// PostTeams: 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)
func (c *Client) PostTeams(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/teams", body, nil, opts)
}

// PostTelemetryDietByIdApply: Apply a telemetry diet (POST /v1/telemetry/diet/{id}/apply)
func (c *Client) PostTelemetryDietByIdApply(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/telemetry/diet/%s/apply", url.PathEscape(id)), body, nil, opts)
}

// PostTelemetryDietPropose: Propose a safe cut to metric and trace volume (POST /v1/telemetry/diet/propose)
func (c *Client) PostTelemetryDietPropose(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/telemetry/diet/propose", body, nil, opts)
}

// PostTelemetryDietRevert: Put the telemetry diet back (POST /v1/telemetry/diet/revert)
func (c *Client) PostTelemetryDietRevert(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/telemetry/diet/revert", body, nil, opts)
}

// PostThings: Have Xovris meet a thing by its address (POST /v1/things)
func (c *Client) PostThings(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/things", body, nil, opts)
}

// PostThingsByIdChanges: Rehearse a change to a thing on a copy (POST /v1/things/{id}/changes)
func (c *Client) PostThingsByIdChanges(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/things/%s/changes", url.PathEscape(id)), body, nil, opts)
}

// PostThingsByIdChangesApprove: Approve a rehearsed change to a thing (POST /v1/things/{id}/changes/approve)
func (c *Client) PostThingsByIdChangesApprove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/things/%s/changes/approve", url.PathEscape(id)), body, nil, opts)
}

// PostThingsByIdChangesUndo: Put back the last change to a thing (POST /v1/things/{id}/changes/undo)
func (c *Client) PostThingsByIdChangesUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/things/%s/changes/undo", url.PathEscape(id)), body, nil, opts)
}

// PostThingsByIdNormal: Tell Xovris what a thing reads now is its new normal (POST /v1/things/{id}/normal)
func (c *Client) PostThingsByIdNormal(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/things/%s/normal", url.PathEscape(id)), body, nil, opts)
}

// PostThingsByIdPace: 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)
func (c *Client) PostThingsByIdPace(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/things/%s/pace", url.PathEscape(id)), body, nil, opts)
}

// PostThingsByIdWatch: Have Xovris look at a thing again now (POST /v1/things/{id}/watch)
func (c *Client) PostThingsByIdWatch(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/things/%s/watch", url.PathEscape(id)), body, nil, opts)
}

// PostTokens: Create an API token (POST /v1/tokens)
func (c *Client) PostTokens(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/tokens", body, nil, opts)
}

// PostTokensByIdAlerts: Turn on or off being told when an API key is used in an unusual way (POST /v1/tokens/{id}/alerts)
func (c *Client) PostTokensByIdAlerts(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tokens/%s/alerts", url.PathEscape(id)), body, nil, opts)
}

// PostTokensByIdRenew: Renew an API token before it ends, with the same name and permissions (POST /v1/tokens/{id}/renew)
func (c *Client) PostTokensByIdRenew(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tokens/%s/renew", url.PathEscape(id)), body, nil, opts)
}

// PostTokensByIdReplace: Replace an API key that was found in public, with the same name and permissions (POST /v1/tokens/{id}/replace)
func (c *Client) PostTokensByIdReplace(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tokens/%s/replace", url.PathEscape(id)), body, nil, opts)
}

// PostTokensByIdRotate: Replace an API token with a new one (POST /v1/tokens/{id}/rotate)
func (c *Client) PostTokensByIdRotate(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tokens/%s/rotate", url.PathEscape(id)), body, nil, opts)
}

// PostTokensByIdWiden: Make an API key again with the one thing a refused call needed, every other limit kept (POST /v1/tokens/{id}/widen)
func (c *Client) PostTokensByIdWiden(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tokens/%s/widen", url.PathEscape(id)), body, nil, opts)
}

// PostToolConnections: Connect a tool (POST /v1/tool-connections)
func (c *Client) PostToolConnections(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/tool-connections", body, nil, opts)
}

// PostToolConnectionsByIdPause: Pause a tool connection (POST /v1/tool-connections/{id}/pause)
func (c *Client) PostToolConnectionsByIdPause(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tool-connections/%s/pause", url.PathEscape(id)), body, nil, opts)
}

// PostToolConnectionsByIdResume: Resume a tool connection (POST /v1/tool-connections/{id}/resume)
func (c *Client) PostToolConnectionsByIdResume(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tool-connections/%s/resume", url.PathEscape(id)), body, nil, opts)
}

// PostToolConnectionsByIdRewire: Have Xovris put a fresh webhook and secret into a connected tool (POST /v1/tool-connections/{id}/rewire)
func (c *Client) PostToolConnectionsByIdRewire(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tool-connections/%s/rewire", url.PathEscape(id)), body, nil, opts)
}

// PostToolServers: Connect an AI tool server by its address (POST /v1/tool-servers)
func (c *Client) PostToolServers(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/tool-servers", body, nil, opts)
}

// PostToolServersByIdToolsByNameApprove: Approve one tool on a tool server (POST /v1/tool-servers/{id}/tools/{name}/approve)
func (c *Client) PostToolServersByIdToolsByNameApprove(ctx context.Context, id string, name string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/tool-servers/%s/tools/%s/approve", url.PathEscape(id), url.PathEscape(name)), body, nil, opts)
}

// PostTracesSamplingRaise: Keep every trace on one path for a while (POST /v1/traces/sampling/raise)
func (c *Client) PostTracesSamplingRaise(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/traces/sampling/raise", body, nil, opts)
}

// PostTravelPlan: Plan how each device is locked down for a trip, with a snapshot kept to compare on return (POST /v1/travel/plan)
func (c *Client) PostTravelPlan(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/travel/plan", body, nil, opts)
}

// PostTravelReturn: Check a device back from a trip against its snapshot from before (POST /v1/travel/return)
func (c *Client) PostTravelReturn(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/travel/return", body, nil, opts)
}

// PostUploads: Start sending a large file in parts (POST /v1/uploads)
func (c *Client) PostUploads(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/uploads", body, nil, opts)
}

// PostUploadsByIdComplete: Finish a large file's upload once every part has arrived (POST /v1/uploads/{id}/complete)
func (c *Client) PostUploadsByIdComplete(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/uploads/%s/complete", url.PathEscape(id)), body, nil, opts)
}

// PostVendorFixes: Send your company's fix to Xovris, to be rehearsed and offered to every customer it helps (POST /v1/vendor-fixes)
func (c *Client) PostVendorFixes(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/vendor-fixes", body, nil, opts)
}

// PostVulnerabilitiesDevicesByIdImportance: Say how important a device is, so its risk is weighed right (POST /v1/vulnerabilities/devices/{id}/importance)
func (c *Client) PostVulnerabilitiesDevicesByIdImportance(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/devices/%s/importance", url.PathEscape(id)), body, nil, opts)
}

// PostVulnerabilitiesDevicesByIdPackagesMove: Have Xovris install a supported line of a package beside the one past its support (POST /v1/vulnerabilities/devices/{id}/packages/move)
func (c *Client) PostVulnerabilitiesDevicesByIdPackagesMove(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/devices/%s/packages/move", url.PathEscape(id)), body, nil, opts)
}

// PostVulnerabilitiesDevicesByIdPackagesOffers: Ask a computer which supported line of a package its own package managers offer (POST /v1/vulnerabilities/devices/{id}/packages/offers)
func (c *Client) PostVulnerabilitiesDevicesByIdPackagesOffers(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/devices/%s/packages/offers", url.PathEscape(id)), body, nil, opts)
}

// PostVulnerabilitiesDevicesByIdPatch: Have Xovris patch a device (POST /v1/vulnerabilities/devices/{id}/patch)
func (c *Client) PostVulnerabilitiesDevicesByIdPatch(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/devices/%s/patch", url.PathEscape(id)), body, nil, opts)
}

// PostVulnerabilitiesDevicesIdsBlocksByIdUndo: Put a sensor rule Xovris switched to drop back as it was (POST /v1/vulnerabilities/devices/ids-blocks/{id}/undo)
func (c *Client) PostVulnerabilitiesDevicesIdsBlocksByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/devices/ids-blocks/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostVulnerabilitiesDevicesVirtualPatchesByIdUndo: Undo a virtual patch Xovris put in place (POST /v1/vulnerabilities/devices/virtual-patches/{id}/undo)
func (c *Client) PostVulnerabilitiesDevicesVirtualPatchesByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/devices/virtual-patches/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostVulnerabilitiesUpgradesByIdFix: Ask Xovris to make an upgrade (POST /v1/vulnerabilities/upgrades/{id}/fix)
func (c *Client) PostVulnerabilitiesUpgradesByIdFix(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/vulnerabilities/upgrades/%s/fix", url.PathEscape(id)), body, nil, opts)
}

// PostWatches: Watch something, in your own words (POST /v1/watches)
func (c *Client) PostWatches(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/watches", body, nil, opts)
}

// PostWatchesByIdOff: Turn a watch off (POST /v1/watches/{id}/off)
func (c *Client) PostWatchesByIdOff(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/watches/%s/off", url.PathEscape(id)), body, nil, opts)
}

// PostWatchesByIdRestore: Put a watched record set back as Xovris kept it before the change (POST /v1/watches/{id}/restore)
func (c *Client) PostWatchesByIdRestore(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/watches/%s/restore", url.PathEscape(id)), body, nil, opts)
}

// PostWatchesPreview: Preview a watch before adding it (POST /v1/watches/preview)
func (c *Client) PostWatchesPreview(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/watches/preview", body, nil, opts)
}

// PostWatchesTest: Test a watch now (POST /v1/watches/test)
func (c *Client) PostWatchesTest(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/watches/test", body, nil, opts)
}

// PostWebFilterAppeals: Ask for a blocked web name to be allowed (POST /v1/web-filter/appeals)
func (c *Client) PostWebFilterAppeals(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/web-filter/appeals", body, nil, opts)
}

// PostWebFilterAppealsByIdAnswer: Answer a request to allow a blocked web name (POST /v1/web-filter/appeals/{id}/answer)
func (c *Client) PostWebFilterAppealsByIdAnswer(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/web-filter/appeals/%s/answer", url.PathEscape(id)), body, nil, opts)
}

// PostWebFilterJudge: Check how your web filter treats a web name, and why (POST /v1/web-filter/judge)
func (c *Client) PostWebFilterJudge(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/web-filter/judge", body, nil, opts)
}

// PostWebFilterPolicy: Change your web filter policy (POST /v1/web-filter/policy)
func (c *Client) PostWebFilterPolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/web-filter/policy", body, nil, opts)
}

// PostWebhooks: Add a webhook (POST /v1/webhooks)
func (c *Client) PostWebhooks(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/webhooks", body, nil, opts)
}

// PostWebhooksByIdCheck: Have Xovris check that your receiver refuses forged, changed and replayed deliveries (POST /v1/webhooks/{id}/check)
func (c *Client) PostWebhooksByIdCheck(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/webhooks/%s/check", url.PathEscape(id)), body, nil, opts)
}

// PostWebhooksByIdDeliveriesByDeliveryIdReplay: Send a webhook delivery again (POST /v1/webhooks/{id}/deliveries/{deliveryId}/replay)
func (c *Client) PostWebhooksByIdDeliveriesByDeliveryIdReplay(ctx context.Context, id string, deliveryId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/webhooks/%s/deliveries/%s/replay", url.PathEscape(id), url.PathEscape(deliveryId)), body, nil, opts)
}

// PostWebhooksByIdEnable: Switch a webhook back on (POST /v1/webhooks/{id}/enable)
func (c *Client) PostWebhooksByIdEnable(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/webhooks/%s/enable", url.PathEscape(id)), body, nil, opts)
}

// PostWebhooksByIdRecover: Send again every delivery that failed since a time (POST /v1/webhooks/{id}/recover)
func (c *Client) PostWebhooksByIdRecover(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/webhooks/%s/recover", url.PathEscape(id)), body, nil, opts)
}

// PostWebhooksByIdRotate: Rotate a webhook's signing secret (POST /v1/webhooks/{id}/rotate)
func (c *Client) PostWebhooksByIdRotate(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/webhooks/%s/rotate", url.PathEscape(id)), body, nil, opts)
}

// PostWebhooksByIdTest: Send a test event to a webhook (POST /v1/webhooks/{id}/test)
func (c *Client) PostWebhooksByIdTest(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/webhooks/%s/test", url.PathEscape(id)), body, nil, opts)
}

// PostWhatIfByIdUndo: Undo a change made from a what-if (POST /v1/what-if/{id}/undo)
func (c *Client) PostWhatIfByIdUndo(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/what-if/%s/undo", url.PathEscape(id)), body, nil, opts)
}

// PostWorkspaceDomains: Point a domain you own at this workspace and get the records to add (POST /v1/workspace/domains)
func (c *Client) PostWorkspaceDomains(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/workspace/domains", body, nil, opts)
}

// PostWorkspaceDomainsByHostnameCheck: Check a domain's records and certificate again now (POST /v1/workspace/domains/{hostname}/check)
func (c *Client) PostWorkspaceDomainsByHostnameCheck(ctx context.Context, hostname string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", fmt.Sprintf("/v1/workspace/domains/%s/check", url.PathEscape(hostname)), body, nil, opts)
}

// PostWorkspaceErase: Erase this workspace and everything in it, with a signed receipt (POST /v1/workspace/erase)
func (c *Client) PostWorkspaceErase(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/workspace/erase", body, nil, opts)
}

// PostWorkspaces: Create a workspace (POST /v1/workspaces)
func (c *Client) PostWorkspaces(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "POST", "/v1/workspaces", body, nil, opts)
}

// PutAccessLevel: Set how far Xovris may act, for the whole workspace or one connection, on the one four-level slider (PUT /v1/access/level)
func (c *Client) PutAccessLevel(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/access/level", body, nil, opts)
}

// PutAlertsMailServer: Alert and status email through the workspace's own mail server (PUT /v1/alerts/mail-server)
func (c *Client) PutAlertsMailServer(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/alerts/mail-server", body, nil, opts)
}

// PutAlertsSendingDomain: Alert and status email from the workspace's own domain (PUT /v1/alerts/sending-domain)
func (c *Client) PutAlertsSendingDomain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/alerts/sending-domain", body, nil, opts)
}

// PutAutonomyApprovalChain: Set the approval chain: the members Xovris asks in turn, each with how long it waits for them (PUT /v1/autonomy/approval-chain)
func (c *Client) PutAutonomyApprovalChain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/autonomy/approval-chain", body, nil, opts)
}

// PutAutonomyFactsByKey: Tell Xovris a fact once, so every later setup reads it instead of asking (PUT /v1/autonomy/facts/{key})
func (c *Client) PutAutonomyFactsByKey(ctx context.Context, key string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/autonomy/facts/%s", url.PathEscape(key)), body, nil, opts)
}

// PutAutonomyMeLevel: Choose how much Xovris takes over for you (PUT /v1/autonomy/me/level)
func (c *Client) PutAutonomyMeLevel(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/autonomy/me/level", body, nil, opts)
}

// PutAutonomySpendPolicy: Change the spend policy Xovris cleans up spending under (PUT /v1/autonomy/spend/policy)
func (c *Client) PutAutonomySpendPolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/autonomy/spend/policy", body, nil, opts)
}

// PutBoardLayout: Keep where your dashboard's tiles sit and how big they are (PUT /v1/board/layout)
func (c *Client) PutBoardLayout(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/board/layout", body, nil, opts)
}

// PutChecksByIdPromise: Set how much of the time a check must be up (PUT /v1/checks/{id}/promise)
func (c *Client) PutChecksByIdPromise(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/checks/%s/promise", url.PathEscape(id)), body, nil, opts)
}

// PutCodeProjectsByIdNetwork: 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)
func (c *Client) PutCodeProjectsByIdNetwork(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/code/projects/%s/network", url.PathEscape(id)), body, nil, opts)
}

// PutCodeProjectsByIdSecretsByName: Keep a secret a build needs - a key or a password - out of its code (PUT /v1/code/projects/{id}/secrets/{name})
func (c *Client) PutCodeProjectsByIdSecretsByName(ctx context.Context, id string, name string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/code/projects/%s/secrets/%s", url.PathEscape(id), url.PathEscape(name)), body, nil, opts)
}

// PutCodeSpendLimit: Set how much your builds may spend in a month (PUT /v1/code/spend-limit)
func (c *Client) PutCodeSpendLimit(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/code/spend-limit", body, nil, opts)
}

// PutCodeTasksByIdPlan: Change a build's plan before it is built (PUT /v1/code/tasks/{id}/plan)
func (c *Client) PutCodeTasksByIdPlan(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/code/tasks/%s/plan", url.PathEscape(id)), body, nil, opts)
}

// PutCodeTasksByIdWait: 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)
func (c *Client) PutCodeTasksByIdWait(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/code/tasks/%s/wait", url.PathEscape(id)), body, nil, opts)
}

// PutComputerPolicy: What Xovris may do on a computer in this workspace, as this workspace rules it (PUT /v1/computer/policy)
func (c *Client) PutComputerPolicy(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/computer/policy", body, nil, opts)
}

// PutComputersByIdDeskProfile: 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)
func (c *Client) PutComputersByIdDeskProfile(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/computers/%s/desk/profile", url.PathEscape(id)), body, nil, opts)
}

// PutHouseholdMembersById: Change a household member's age band, quiet hours, services or allowed names (PUT /v1/household/members/{id})
func (c *Client) PutHouseholdMembersById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/household/members/%s", url.PathEscape(id)), body, nil, opts)
}

// PutIncidentsByIdOwner: Set or clear who owns an incident (PUT /v1/incidents/{id}/owner)
func (c *Client) PutIncidentsByIdOwner(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/incidents/%s/owner", url.PathEscape(id)), body, nil, opts)
}

// PutIncidentsByIdWorkspace: Save an incident's working notes (an out-of-date copy is refused, never overwritten) (PUT /v1/incidents/{id}/workspace)
func (c *Client) PutIncidentsByIdWorkspace(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/incidents/%s/workspace", url.PathEscape(id)), body, nil, opts)
}

// PutIssuesTriageSettings: How triage works: who new issues go to, whether a priority is needed, and its rules (PUT /v1/issues/triage/settings)
func (c *Client) PutIssuesTriageSettings(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/issues/triage/settings", body, nil, opts)
}

// PutLogsRetention: Change how long logs are kept (PUT /v1/logs/retention)
func (c *Client) PutLogsRetention(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/logs/retention", body, nil, opts)
}

// PutMajorCommsRules: 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)
func (c *Client) PutMajorCommsRules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/major-comms/rules", body, nil, opts)
}

// PutMePreferences: Save your own appearance and notification choices for every device (PUT /v1/me/preferences)
func (c *Client) PutMePreferences(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/me/preferences", body, nil, opts)
}

// PutPeopleByUserIdEnd: 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)
func (c *Client) PutPeopleByUserIdEnd(ctx context.Context, userId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/people/%s/end", url.PathEscape(userId)), body, nil, opts)
}

// PutPeopleOutsideRule: 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)
func (c *Client) PutPeopleOutsideRule(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/people/outside/rule", body, nil, opts)
}

// PutPipelinesDiet: Change which log lines are kept (PUT /v1/pipelines/diet)
func (c *Client) PutPipelinesDiet(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/pipelines/diet", body, nil, opts)
}

// PutProjectsByIdDebugFilesNative: 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)
func (c *Client) PutProjectsByIdDebugFilesNative(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/projects/%s/debug-files/native", url.PathEscape(id)), body, nil, opts)
}

// PutProjectsByIdDebugFilesProguard: 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)
func (c *Client) PutProjectsByIdDebugFilesProguard(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/projects/%s/debug-files/proguard", url.PathEscape(id)), body, nil, opts)
}

// PutProjectsByIdSourcemapsByDebugId: Send a build's source map so its stack traces read as your own code (PUT /v1/projects/{id}/sourcemaps/{debugId})
func (c *Client) PutProjectsByIdSourcemapsByDebugId(ctx context.Context, id string, debugId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/projects/%s/sourcemaps/%s", url.PathEscape(id), url.PathEscape(debugId)), body, nil, opts)
}

// PutQueriesById: Change a saved query (PUT /v1/queries/{id})
func (c *Client) PutQueriesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/queries/%s", url.PathEscape(id)), body, nil, opts)
}

// PutReviewsCadence: Choose how often Xovris reviews everything, or one thing (PUT /v1/reviews/cadence)
func (c *Client) PutReviewsCadence(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/reviews/cadence", body, nil, opts)
}

// PutReviewsChats: Connect your own Discord application or Google Chat app, so people ask Xovris there (PUT /v1/reviews/chats)
func (c *Client) PutReviewsChats(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/reviews/chats", body, nil, opts)
}

// PutReviewsHosts: Connect your own GitLab, Bitbucket or Azure DevOps, so every change there is reviewed and its fixes proved (PUT /v1/reviews/hosts)
func (c *Client) PutReviewsHosts(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/reviews/hosts", body, nil, opts)
}

// PutReviewsPreferencesById: Change a code review preference you set (PUT /v1/reviews/preferences/{id})
func (c *Client) PutReviewsPreferencesById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/reviews/preferences/%s", url.PathEscape(id)), body, nil, opts)
}

// PutReviewsTracker: 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)
func (c *Client) PutReviewsTracker(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/reviews/tracker", body, nil, opts)
}

// PutRolesByIdElevation: 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)
func (c *Client) PutRolesByIdElevation(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/roles/%s/elevation", url.PathEscape(id)), body, nil, opts)
}

// PutScimV2GroupsById: A provisioned team's name and the people the provider keeps in it, replaced together (PUT /v1/scim/v2/Groups/{id})
func (c *Client) PutScimV2GroupsById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/scim/v2/Groups/%s", url.PathEscape(id)), body, nil, opts)
}

// PutScimV2UsersById: A person replaced at the identity provider - turned off, they lose this workspace at once (PUT /v1/scim/v2/Users/{id})
func (c *Client) PutScimV2UsersById(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/scim/v2/Users/%s", url.PathEscape(id)), body, nil, opts)
}

// PutSentryIssuesByOrgById: Change one Sentry issue - its status, owner or priority - from Xovris (PUT /v1/sentry/issues/{org}/{id})
func (c *Client) PutSentryIssuesByOrgById(ctx context.Context, org string, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/sentry/issues/%s/%s", url.PathEscape(org), url.PathEscape(id)), body, nil, opts)
}

// PutSessionsOrder: Set the order your devices are told in when a session needs you (PUT /v1/sessions/order)
func (c *Client) PutSessionsOrder(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/sessions/order", body, nil, opts)
}

// PutSettingsNotifyRules: Set who is told what, and on which channels (PUT /v1/settings/notify-rules)
func (c *Client) PutSettingsNotifyRules(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/settings/notify-rules", body, nil, opts)
}

// PutSettingsQuietHours: Set your quiet hours and what a high alert does during them (PUT /v1/settings/quiet-hours)
func (c *Client) PutSettingsQuietHours(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/settings/quiet-hours", body, nil, opts)
}

// PutSettingsSignIn: Require a passkey for every member, or allow other sign-ins (PUT /v1/settings/sign-in)
func (c *Client) PutSettingsSignIn(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/settings/sign-in", body, nil, opts)
}

// PutSettingsSpendLimit: Set your monthly spending limit on AI fixes (PUT /v1/settings/spend-limit)
func (c *Client) PutSettingsSpendLimit(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/settings/spend-limit", body, nil, opts)
}

// PutSettingsTwoPersonRulesByKind: Set the two-person rule for a kind of change (PUT /v1/settings/two-person-rules/{kind})
func (c *Client) PutSettingsTwoPersonRulesByKind(ctx context.Context, kind string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/settings/two-person-rules/%s", url.PathEscape(kind)), body, nil, opts)
}

// PutStatusPage: Create or change your status page (PUT /v1/status-page)
func (c *Client) PutStatusPage(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/status-page", body, nil, opts)
}

// PutStatusPageDomain: Serve your status page on your own domain (PUT /v1/status-page/domain)
func (c *Client) PutStatusPageDomain(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/status-page/domain", body, nil, opts)
}

// PutStatusPagesByIdAccess: 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)
func (c *Client) PutStatusPagesByIdAccess(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/status-pages/%s/access", url.PathEscape(id)), body, nil, opts)
}

// PutStatusPagesByIdAudiencesByAudience: 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})
func (c *Client) PutStatusPagesByIdAudiencesByAudience(ctx context.Context, id string, audience string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/status-pages/%s/audiences/%s", url.PathEscape(id), url.PathEscape(audience)), body, nil, opts)
}

// PutStatusPagesByIdMaintenanceByMaintenance: 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})
func (c *Client) PutStatusPagesByIdMaintenanceByMaintenance(ctx context.Context, id string, maintenance string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/status-pages/%s/maintenance/%s", url.PathEscape(id), url.PathEscape(maintenance)), body, nil, opts)
}

// PutSystemsGeneralRunsMemoryConsent: Agree to Xovris remembering your corrections, or withdraw and delete them all (PUT /v1/systems/general-runs/memory/consent)
func (c *Client) PutSystemsGeneralRunsMemoryConsent(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/systems/general-runs/memory/consent", body, nil, opts)
}

// PutTeamsByIdPeopleByUserId: A member put in a team by hand - they hold its role from their next step (PUT /v1/teams/{id}/people/{userId})
func (c *Client) PutTeamsByIdPeopleByUserId(ctx context.Context, id string, userId string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/teams/%s/people/%s", url.PathEscape(id), url.PathEscape(userId)), body, nil, opts)
}

// PutUploadsByIdChunks: Send one part of a large file (PUT /v1/uploads/{id}/chunks)
func (c *Client) PutUploadsByIdChunks(ctx context.Context, id string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/uploads/%s/chunks", url.PathEscape(id)), body, nil, opts)
}

// PutViewsBySurface: Save a view of a page under a name, for you or for the workspace (PUT /v1/views/{surface})
func (c *Client) PutViewsBySurface(ctx context.Context, surface string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/views/%s", url.PathEscape(surface)), body, nil, opts)
}

// PutWatchByFeatureSetup: Turn the app inventory or the insider risk watch on, with its assessment accepted and staff told (PUT /v1/watch/{feature}/setup)
func (c *Client) PutWatchByFeatureSetup(ctx context.Context, feature string, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", fmt.Sprintf("/v1/watch/%s/setup", url.PathEscape(feature)), body, nil, opts)
}

// PutWorkspaceAiChecksModel: 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)
func (c *Client) PutWorkspaceAiChecksModel(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/workspace/ai-checks/model", body, nil, opts)
}

// PutWorkspaceAiChecksSchedule: Choose when Xovris's AI reviews your workspace: adaptive (whenever something changes) or a fixed schedule (PUT /v1/workspace/ai-checks/schedule)
func (c *Client) PutWorkspaceAiChecksSchedule(ctx context.Context, body any, opts *CallOptions) (any, error) {
	return c.call(ctx, "PUT", "/v1/workspace/ai-checks/schedule", body, nil, opts)
}
