@iblai/iblai-api 4.251.0-core → 4.252.0-core

package/src/services/CoreService.ts

@@ -19,6 +19,9 @@ import type { PaginatedRbacGroupList } from '../models/PaginatedRbacGroupList';
 import type { PaginatedRbacPolicyList } from '../models/PaginatedRbacPolicyList';
 import type { PaginatedRbacRoleList } from '../models/PaginatedRbacRoleList';
 import type { PaginatedUserGroupList } from '../models/PaginatedUserGroupList';
+import type { PaginatedWatchedGroupListList } from '../models/PaginatedWatchedGroupListList';
+import type { PaginatedWatchedUserReadList } from '../models/PaginatedWatchedUserReadList';
+import type { PaginatedWatcherReadList } from '../models/PaginatedWatcherReadList';
 import type { PatchedDemographicsFieldDefinitionWrite } from '../models/PatchedDemographicsFieldDefinitionWrite';
 import type { PatchedPlatformPublicImageAsset } from '../models/PatchedPlatformPublicImageAsset';
 import type { PatchedPlatformPublicMetadata } from '../models/PatchedPlatformPublicMetadata';
@@ -27,6 +30,8 @@ import type { PatchedRbacPolicy } from '../models/PatchedRbacPolicy';
 import type { PatchedRbacRole } from '../models/PatchedRbacRole';
 import type { PatchedUserGroup } from '../models/PatchedUserGroup';
 import type { PatchedUserPlatformMetadataUpdate } from '../models/PatchedUserPlatformMetadataUpdate';
+import type { PatchedWatchedGroupUpdate } from '../models/PatchedWatchedGroupUpdate';
+import type { PatchedWatcherUpdate } from '../models/PatchedWatcherUpdate';
 import type { PermissionCheckRequest } from '../models/PermissionCheckRequest';
 import type { PlatformApiKey } from '../models/PlatformApiKey';
 import type { PlatformConfigurationList } from '../models/PlatformConfigurationList';
@@ -71,6 +76,14 @@ import type { UserProxyGetResponse } from '../models/UserProxyGetResponse';
 import type { UserProxyPostRequest } from '../models/UserProxyPostRequest';
 import type { UserProxyPostResponse } from '../models/UserProxyPostResponse';
 import type { UserSearchViewGetResponse } from '../models/UserSearchViewGetResponse';
+import type { WatchedGroupCreate } from '../models/WatchedGroupCreate';
+import type { WatchedGroupDetail } from '../models/WatchedGroupDetail';
+import type { WatchedGroupUpdate } from '../models/WatchedGroupUpdate';
+import type { WatchedUserRead } from '../models/WatchedUserRead';
+import type { WatchedUserWrite } from '../models/WatchedUserWrite';
+import type { WatcherRead } from '../models/WatcherRead';
+import type { WatcherUpdate } from '../models/WatcherUpdate';
+import type { WatcherWrite } from '../models/WatcherWrite';
 import type { WhitelistedDomain } from '../models/WhitelistedDomain';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
@@ -3302,6 +3315,704 @@ export class CoreService {
                 },
             });
         }
+        /**
+         * List watched groups visible to the caller
+         * CRUD for WatchedGroup. Watcher mutations live on the nested /watchers/ endpoint;
+         * POST here accepts an optional `watchers` array as a create-time convenience.
+         * @returns PaginatedWatchedGroupListList
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsList({
+            limit,
+            offset,
+            platformKey,
+        }: {
+            /**
+             * Number of results to return per page.
+             */
+            limit?: number,
+            /**
+             * The initial index from which to return the results.
+             */
+            offset?: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<PaginatedWatchedGroupListList> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/watched-groups/',
+                query: {
+                    'limit': limit,
+                    'offset': offset,
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Platform not found`,
+                },
+            });
+        }
+        /**
+         * Create a watched group
+         * CRUD for WatchedGroup. Watcher mutations live on the nested /watchers/ endpoint;
+         * POST here accepts an optional `watchers` array as a create-time convenience.
+         * @returns WatchedGroupDetail
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsCreate({
+            requestBody,
+            platformKey,
+            watchedUserLimit,
+            watcherLimit,
+        }: {
+            requestBody: WatchedGroupCreate,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+            /**
+             * Inline up to N watched users in the response (0 = none, max 100). Use the nested /watched-users/ endpoint for paginated walks.
+             */
+            watchedUserLimit?: number,
+            /**
+             * Inline up to N watchers in the response (0 = none, max 100). Use the nested /watchers/ endpoint for paginated walks.
+             */
+            watcherLimit?: number,
+        }): CancelablePromise<WatchedGroupDetail> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/core/watched-groups/',
+                query: {
+                    'platform_key': platformKey,
+                    'watched_user_limit': watchedUserLimit,
+                    'watcher_limit': watcherLimit,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid request`,
+                    403: `Permission denied`,
+                },
+            });
+        }
+        /**
+         * Retrieve a watched group
+         * CRUD for WatchedGroup. Watcher mutations live on the nested /watchers/ endpoint;
+         * POST here accepts an optional `watchers` array as a create-time convenience.
+         * @returns WatchedGroupDetail
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsRetrieve({
+            id,
+            platformKey,
+            watchedUserLimit,
+            watcherLimit,
+        }: {
+            /**
+             * A unique integer value identifying this Watched Group.
+             */
+            id: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+            /**
+             * Inline up to N watched users in the response (0 = none, max 100). Use the nested /watched-users/ endpoint for paginated walks.
+             */
+            watchedUserLimit?: number,
+            /**
+             * Inline up to N watchers in the response (0 = none, max 100). Use the nested /watchers/ endpoint for paginated walks.
+             */
+            watcherLimit?: number,
+        }): CancelablePromise<WatchedGroupDetail> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/watched-groups/{id}/',
+                path: {
+                    'id': id,
+                },
+                query: {
+                    'platform_key': platformKey,
+                    'watched_user_limit': watchedUserLimit,
+                    'watcher_limit': watcherLimit,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Update a watched group's name
+         * CRUD for WatchedGroup. Watcher mutations live on the nested /watchers/ endpoint;
+         * POST here accepts an optional `watchers` array as a create-time convenience.
+         * @returns WatchedGroupDetail
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsUpdate({
+            id,
+            platformKey,
+            watchedUserLimit,
+            watcherLimit,
+            requestBody,
+        }: {
+            /**
+             * A unique integer value identifying this Watched Group.
+             */
+            id: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+            /**
+             * Inline up to N watched users in the response (0 = none, max 100). Use the nested /watched-users/ endpoint for paginated walks.
+             */
+            watchedUserLimit?: number,
+            /**
+             * Inline up to N watchers in the response (0 = none, max 100). Use the nested /watchers/ endpoint for paginated walks.
+             */
+            watcherLimit?: number,
+            requestBody?: WatchedGroupUpdate,
+        }): CancelablePromise<WatchedGroupDetail> {
+            return __request(OpenAPI, {
+                method: 'PUT',
+                url: '/api/core/watched-groups/{id}/',
+                path: {
+                    'id': id,
+                },
+                query: {
+                    'platform_key': platformKey,
+                    'watched_user_limit': watchedUserLimit,
+                    'watcher_limit': watcherLimit,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid request`,
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Partially update a watched group's name
+         * CRUD for WatchedGroup. Watcher mutations live on the nested /watchers/ endpoint;
+         * POST here accepts an optional `watchers` array as a create-time convenience.
+         * @returns WatchedGroupDetail
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsPartialUpdate({
+            id,
+            platformKey,
+            watchedUserLimit,
+            watcherLimit,
+            requestBody,
+        }: {
+            /**
+             * A unique integer value identifying this Watched Group.
+             */
+            id: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+            /**
+             * Inline up to N watched users in the response (0 = none, max 100). Use the nested /watched-users/ endpoint for paginated walks.
+             */
+            watchedUserLimit?: number,
+            /**
+             * Inline up to N watchers in the response (0 = none, max 100). Use the nested /watchers/ endpoint for paginated walks.
+             */
+            watcherLimit?: number,
+            requestBody?: PatchedWatchedGroupUpdate,
+        }): CancelablePromise<WatchedGroupDetail> {
+            return __request(OpenAPI, {
+                method: 'PATCH',
+                url: '/api/core/watched-groups/{id}/',
+                path: {
+                    'id': id,
+                },
+                query: {
+                    'platform_key': platformKey,
+                    'watched_user_limit': watchedUserLimit,
+                    'watcher_limit': watcherLimit,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid request`,
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Delete a watched group
+         * CRUD for WatchedGroup. Watcher mutations live on the nested /watchers/ endpoint;
+         * POST here accepts an optional `watchers` array as a create-time convenience.
+         * @returns void
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsDestroy({
+            id,
+            platformKey,
+        }: {
+            /**
+             * A unique integer value identifying this Watched Group.
+             */
+            id: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<void> {
+            return __request(OpenAPI, {
+                method: 'DELETE',
+                url: '/api/core/watched-groups/{id}/',
+                path: {
+                    'id': id,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * List watched users in a watched group (paginated)
+         * CRUD-minus-update for watched users (UserGroupLink rows) under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchedusers/{link_id}/
+         * No PATCH/PUT — there's nothing meaningful to update on a UserGroupLink for
+         * this feature. Add via POST, remove via DELETE.
+         * @returns PaginatedWatchedUserReadList
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchedUsersList({
+            watchedGroupPk,
+            limit,
+            offset,
+            platformKey,
+        }: {
+            watchedGroupPk: number,
+            /**
+             * Number of results to return per page.
+             */
+            limit?: number,
+            /**
+             * The initial index from which to return the results.
+             */
+            offset?: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<PaginatedWatchedUserReadList> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/watched-groups/{watched_group_pk}/watched-users/',
+                path: {
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'limit': limit,
+                    'offset': offset,
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `WatchedGroup not found`,
+                },
+            });
+        }
+        /**
+         * Add a user to the watched group
+         * CRUD-minus-update for watched users (UserGroupLink rows) under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchedusers/{link_id}/
+         * No PATCH/PUT — there's nothing meaningful to update on a UserGroupLink for
+         * this feature. Add via POST, remove via DELETE.
+         * @returns WatchedUserRead
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchedUsersCreate({
+            watchedGroupPk,
+            requestBody,
+            platformKey,
+        }: {
+            watchedGroupPk: number,
+            requestBody: WatchedUserWrite,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<WatchedUserRead> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/core/watched-groups/{watched_group_pk}/watched-users/',
+                path: {
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid payload`,
+                    403: `Permission denied`,
+                    404: `WatchedGroup not found`,
+                },
+            });
+        }
+        /**
+         * Retrieve a single watched-user link
+         * CRUD-minus-update for watched users (UserGroupLink rows) under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchedusers/{link_id}/
+         * No PATCH/PUT — there's nothing meaningful to update on a UserGroupLink for
+         * this feature. Add via POST, remove via DELETE.
+         * @returns WatchedUserRead
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchedUsersRetrieve({
+            id,
+            watchedGroupPk,
+            platformKey,
+        }: {
+            id: number,
+            watchedGroupPk: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<WatchedUserRead> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/watched-groups/{watched_group_pk}/watched-users/{id}/',
+                path: {
+                    'id': id,
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Remove a user from the watched group
+         * CRUD-minus-update for watched users (UserGroupLink rows) under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchedusers/{link_id}/
+         * No PATCH/PUT — there's nothing meaningful to update on a UserGroupLink for
+         * this feature. Add via POST, remove via DELETE.
+         * @returns void
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchedUsersDestroy({
+            id,
+            watchedGroupPk,
+            platformKey,
+        }: {
+            id: number,
+            watchedGroupPk: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<void> {
+            return __request(OpenAPI, {
+                method: 'DELETE',
+                url: '/api/core/watched-groups/{watched_group_pk}/watched-users/{id}/',
+                path: {
+                    'id': id,
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * List watchers of a watched group (paginated)
+         * CRUD for watchers nested under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchers/{watcher_id}/
+         * `is_owner` here covers two cases that both deserve owner-level perms on a
+         * watcher row:
+         * - the watcher themselves (WATCHER_OWNER well-known role)
+         * - the parent WatchedGroup's owner (WATCHED_GROUP_OWNER role grants
+         * `Ibl.Core/Watchers*`)
+         * @returns PaginatedWatcherReadList
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchersList({
+            watchedGroupPk,
+            limit,
+            offset,
+            platformKey,
+        }: {
+            watchedGroupPk: number,
+            /**
+             * Number of results to return per page.
+             */
+            limit?: number,
+            /**
+             * The initial index from which to return the results.
+             */
+            offset?: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<PaginatedWatcherReadList> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/watched-groups/{watched_group_pk}/watchers/',
+                path: {
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'limit': limit,
+                    'offset': offset,
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `WatchedGroup not found`,
+                },
+            });
+        }
+        /**
+         * Add a watcher to a watched group
+         * CRUD for watchers nested under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchers/{watcher_id}/
+         * `is_owner` here covers two cases that both deserve owner-level perms on a
+         * watcher row:
+         * - the watcher themselves (WATCHER_OWNER well-known role)
+         * - the parent WatchedGroup's owner (WATCHED_GROUP_OWNER role grants
+         * `Ibl.Core/Watchers*`)
+         * @returns WatcherRead
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchersCreate({
+            watchedGroupPk,
+            requestBody,
+            platformKey,
+        }: {
+            watchedGroupPk: number,
+            requestBody: WatcherWrite,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<WatcherRead> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/core/watched-groups/{watched_group_pk}/watchers/',
+                path: {
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid payload`,
+                    403: `Permission denied`,
+                    404: `WatchedGroup not found`,
+                },
+            });
+        }
+        /**
+         * Retrieve a single watcher
+         * CRUD for watchers nested under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchers/{watcher_id}/
+         * `is_owner` here covers two cases that both deserve owner-level perms on a
+         * watcher row:
+         * - the watcher themselves (WATCHER_OWNER well-known role)
+         * - the parent WatchedGroup's owner (WATCHED_GROUP_OWNER role grants
+         * `Ibl.Core/Watchers*`)
+         * @returns WatcherRead
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchersRetrieve({
+            id,
+            watchedGroupPk,
+            platformKey,
+        }: {
+            id: number,
+            watchedGroupPk: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<WatcherRead> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/watched-groups/{watched_group_pk}/watchers/{id}/',
+                path: {
+                    'id': id,
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Replace a watcher's events
+         * CRUD for watchers nested under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchers/{watcher_id}/
+         * `is_owner` here covers two cases that both deserve owner-level perms on a
+         * watcher row:
+         * - the watcher themselves (WATCHER_OWNER well-known role)
+         * - the parent WatchedGroup's owner (WATCHED_GROUP_OWNER role grants
+         * `Ibl.Core/Watchers*`)
+         * @returns WatcherRead
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchersUpdate({
+            id,
+            watchedGroupPk,
+            requestBody,
+            platformKey,
+        }: {
+            id: number,
+            watchedGroupPk: number,
+            requestBody: WatcherUpdate,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<WatcherRead> {
+            return __request(OpenAPI, {
+                method: 'PUT',
+                url: '/api/core/watched-groups/{watched_group_pk}/watchers/{id}/',
+                path: {
+                    'id': id,
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid payload`,
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Update a watcher's events
+         * CRUD for watchers nested under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchers/{watcher_id}/
+         * `is_owner` here covers two cases that both deserve owner-level perms on a
+         * watcher row:
+         * - the watcher themselves (WATCHER_OWNER well-known role)
+         * - the parent WatchedGroup's owner (WATCHED_GROUP_OWNER role grants
+         * `Ibl.Core/Watchers*`)
+         * @returns WatcherRead
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchersPartialUpdate({
+            id,
+            watchedGroupPk,
+            platformKey,
+            requestBody,
+        }: {
+            id: number,
+            watchedGroupPk: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+            requestBody?: PatchedWatcherUpdate,
+        }): CancelablePromise<WatcherRead> {
+            return __request(OpenAPI, {
+                method: 'PATCH',
+                url: '/api/core/watched-groups/{watched_group_pk}/watchers/{id}/',
+                path: {
+                    'id': id,
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+                errors: {
+                    400: `Invalid payload`,
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
+        /**
+         * Remove (or unsubscribe) a watcher from a watched group
+         * CRUD for watchers nested under a WatchedGroup.
+         *
+         * Resource path: /platforms/{pk}/watchedgroups/{wg_id}/watchers/{watcher_id}/
+         * `is_owner` here covers two cases that both deserve owner-level perms on a
+         * watcher row:
+         * - the watcher themselves (WATCHER_OWNER well-known role)
+         * - the parent WatchedGroup's owner (WATCHED_GROUP_OWNER role grants
+         * `Ibl.Core/Watchers*`)
+         * @returns void
+         * @throws ApiError
+         */
+        public static coreWatchedGroupsWatchersDestroy({
+            id,
+            watchedGroupPk,
+            platformKey,
+        }: {
+            id: number,
+            watchedGroupPk: number,
+            /**
+             * Service-account only: target platform key. Non-SA callers' platform is sourced from the auth token and this is ignored.
+             */
+            platformKey?: string,
+        }): CancelablePromise<void> {
+            return __request(OpenAPI, {
+                method: 'DELETE',
+                url: '/api/core/watched-groups/{watched_group_pk}/watchers/{id}/',
+                path: {
+                    'id': id,
+                    'watched_group_pk': watchedGroupPk,
+                },
+                query: {
+                    'platform_key': platformKey,
+                },
+                errors: {
+                    403: `Permission denied`,
+                    404: `Not found`,
+                },
+            });
+        }
         /**
          * Get a list of departments with metrics and filtering options.
          *