@iblai/iblai-api 3.47.2-core → 3.48.0-ai-plus

package/src/services/CoreService.ts

@@ -3,20 +3,33 @@
 /* tslint:disable */
 /* eslint-disable */
 import type { CeleryHeartbeat } from '../models/CeleryHeartbeat';
-import type { CheckPermissionRequest } from '../models/CheckPermissionRequest';
 import type { EdxSignalReceiverRequest } from '../models/EdxSignalReceiverRequest';
 import type { ImageUpload } from '../models/ImageUpload';
 import type { LauncherViewPostRequest } from '../models/LauncherViewPostRequest';
 import type { LtiKey } from '../models/LtiKey';
 import type { LtiTool } from '../models/LtiTool';
+import type { PaginatedRbacGroupList } from '../models/PaginatedRbacGroupList';
+import type { PaginatedRbacGroupRoleList } from '../models/PaginatedRbacGroupRoleList';
+import type { PaginatedRbacPolicyList } from '../models/PaginatedRbacPolicyList';
+import type { PaginatedRbacRoleList } from '../models/PaginatedRbacRoleList';
+import type { PaginatedRbacUserRoleList } from '../models/PaginatedRbacUserRoleList';
 import type { PatchedPlatformPublicMetadata } from '../models/PatchedPlatformPublicMetadata';
+import type { PatchedRbacGroup } from '../models/PatchedRbacGroup';
+import type { PatchedRbacGroupRole } from '../models/PatchedRbacGroupRole';
+import type { PatchedRbacPolicy } from '../models/PatchedRbacPolicy';
+import type { PatchedRbacRole } from '../models/PatchedRbacRole';
+import type { PatchedRbacUserRole } from '../models/PatchedRbacUserRole';
 import type { PlatformApiKey } from '../models/PlatformApiKey';
 import type { PlatformList } from '../models/PlatformList';
 import type { PlatformPublicMetadata } from '../models/PlatformPublicMetadata';
 import type { PlatformUpdatePostRequest } from '../models/PlatformUpdatePostRequest';
+import type { RbacGroup } from '../models/RbacGroup';
+import type { RbacGroupRole } from '../models/RbacGroupRole';
+import type { RbacPolicy } from '../models/RbacPolicy';
+import type { RbacRole } from '../models/RbacRole';
+import type { RbacUserRole } from '../models/RbacUserRole';
 import type { RedirectTokenRequest } from '../models/RedirectTokenRequest';
 import type { RedirectTokenResponse } from '../models/RedirectTokenResponse';
-import type { RolePermissions } from '../models/RolePermissions';
 import type { TokenProxyInput } from '../models/TokenProxyInput';
 import type { TokenProxyOutput } from '../models/TokenProxyOutput';
 import type { UserDeleteAPIRequest } from '../models/UserDeleteAPIRequest';
@@ -28,7 +41,6 @@ import type { UserProxyBulkRequest } from '../models/UserProxyBulkRequest';
 import type { UserProxyGetResponse } from '../models/UserProxyGetResponse';
 import type { UserProxyPostRequest } from '../models/UserProxyPostRequest';
 import type { UserProxyPostResponse } from '../models/UserProxyPostResponse';
-import type { UserRole } from '../models/UserRole';
 import type { UserSearchViewGetResponse } from '../models/UserSearchViewGetResponse';
 import type { WhitelistedDomain } from '../models/WhitelistedDomain';
 import type { CancelablePromise } from '../core/CancelablePromise';
@@ -954,207 +966,725 @@ export class CoreService {
         });
     }
     /**
-     * Check if a user has permission to perform an action on a resource.
+     * List group role assignments
+     * Retrieve a list of group role assignments. Can be filtered by platform_key, group_id, or role_id.
+     * @param groupId Filter group roles by group ID
+     * @param page A page number within the paginated result set.
+     * @param pageSize Number of results to return per page.
+     * @param platformKey Filter group roles by platform key
+     * @param roleId Filter group roles by role ID
+     * @returns PaginatedRbacGroupRoleList
+     * @throws ApiError
+     */
+    public static coreRbacGroupRolesList(
+        groupId?: number,
+        page?: number,
+        pageSize?: number,
+        platformKey?: string,
+        roleId?: number,
+    ): CancelablePromise<PaginatedRbacGroupRoleList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/rbac/group-roles/',
+            query: {
+                'group_id': groupId,
+                'page': page,
+                'page_size': pageSize,
+                'platform_key': platformKey,
+                'role_id': roleId,
+            },
+        });
+    }
+    /**
+     * Create group role assignment
+     * Assign a role to a group. The group and role must belong to the same platform.
      * @param requestBody
-     * @returns any User has permission to perform the action on the resource.
+     * @returns RbacGroupRole
      * @throws ApiError
      */
-    public static coreRbacCheckPermissionsCreate(
-        requestBody: CheckPermissionRequest,
-    ): CancelablePromise<any> {
+    public static coreRbacGroupRolesCreate(
+        requestBody: RbacGroupRole,
+    ): CancelablePromise<RbacGroupRole> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/core/rbac/check-permissions/',
+            url: '/api/core/rbac/group-roles/',
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                403: `User does not have permission to perform the action on the resource.`,
-                404: `Platform not found.`,
+                400: `Invalid input data. Common errors include:
+                - Group does not belong to the specified platform
+                - Role does not belong to the specified platform
+                - Group and role belong to different platforms`,
             },
         });
     }
     /**
-     * Get all associations for a resource.
-     * @returns any No response body
+     * Retrieve group role assignment
+     * Retrieve details of a specific group role assignment.
+     * @param id A unique integer value identifying this RBAC Group Role.
+     * @returns RbacGroupRole
      * @throws ApiError
      */
-    public static coreRbacResourceAssociationRetrieve(): CancelablePromise<any> {
+    public static coreRbacGroupRolesRetrieve(
+        id: number,
+    ): CancelablePromise<RbacGroupRole> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/core/rbac/resource/association/',
+            url: '/api/core/rbac/group-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Group role assignment not found`,
+            },
         });
     }
     /**
-     * Associate a resource with a resource.
-     * @returns any No response body
+     * Update group role assignment
+     * Update an existing group role assignment. Platform validation applies.
+     * @param id A unique integer value identifying this RBAC Group Role.
+     * @param requestBody
+     * @returns RbacGroupRole
      * @throws ApiError
      */
-    public static coreRbacResourceAssociationCreate(): CancelablePromise<any> {
+    public static coreRbacGroupRolesUpdate(
+        id: number,
+        requestBody: RbacGroupRole,
+    ): CancelablePromise<RbacGroupRole> {
         return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/core/rbac/resource/association/',
+            method: 'PUT',
+            url: '/api/core/rbac/group-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data. Common errors include:
+                - Group does not belong to the specified platform
+                - Role does not belong to the specified platform
+                - Group and role belong to different platforms`,
+                404: `Group role assignment not found`,
+            },
+        });
+    }
+    /**
+     * Partially update group role assignment
+     * Partially update an existing group role assignment. Platform validation applies.
+     * @param id A unique integer value identifying this RBAC Group Role.
+     * @param requestBody
+     * @returns RbacGroupRole
+     * @throws ApiError
+     */
+    public static coreRbacGroupRolesPartialUpdate(
+        id: number,
+        requestBody?: PatchedRbacGroupRole,
+    ): CancelablePromise<RbacGroupRole> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/core/rbac/group-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data. Common errors include:
+                - Group does not belong to the specified platform
+                - Role does not belong to the specified platform
+                - Group and role belong to different platforms`,
+                404: `Group role assignment not found`,
+            },
         });
     }
     /**
-     * Disassociate a resource from a resource.
+     * Delete group role assignment
+     * Remove a role assignment from a group.
+     * @param id A unique integer value identifying this RBAC Group Role.
      * @returns void
      * @throws ApiError
      */
-    public static coreRbacResourceAssociationDestroy(): CancelablePromise<void> {
+    public static coreRbacGroupRolesDestroy(
+        id: number,
+    ): CancelablePromise<void> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/core/rbac/resource/association/',
+            url: '/api/core/rbac/group-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Group role assignment not found`,
+            },
         });
     }
     /**
-     * Get all permissions for a role.
-     * @returns any List of permissions for the role.
+     * List RBAC groups
+     * Retrieve a list of RBAC groups. Can be filtered by platform_key.
+     * @param page A page number within the paginated result set.
+     * @param pageSize Number of results to return per page.
+     * @param platformKey Filter groups by platform key
+     * @returns PaginatedRbacGroupList
      * @throws ApiError
      */
-    public static coreRbacRolePermissionsRetrieve(): CancelablePromise<any> {
+    public static coreRbacGroupsList(
+        page?: number,
+        pageSize?: number,
+        platformKey?: string,
+    ): CancelablePromise<PaginatedRbacGroupList> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/core/rbac/role/permissions/',
-            errors: {
-                404: `Platform not found.`,
+            url: '/api/core/rbac/groups/',
+            query: {
+                'page': page,
+                'page_size': pageSize,
+                'platform_key': platformKey,
             },
         });
     }
     /**
-     * Add a permission to a role.
+     * Create RBAC group
+     * Create a new RBAC group for a platform. Users can be assigned during creation.
      * @param requestBody
-     * @returns any Permission already exists for this role.
+     * @returns RbacGroup
      * @throws ApiError
      */
-    public static coreRbacRolePermissionsCreate(
-        requestBody: RolePermissions,
-    ): CancelablePromise<any> {
+    public static coreRbacGroupsCreate(
+        requestBody: RbacGroup,
+    ): CancelablePromise<RbacGroup> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/core/rbac/role/permissions/',
+            url: '/api/core/rbac/groups/',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data. Common errors include:
+                - Users do not belong to the specified platform
+                - Invalid user IDs provided`,
+            },
+        });
+    }
+    /**
+     * Retrieve RBAC group
+     * Retrieve details of a specific RBAC group including assigned users.
+     * @param id A unique integer value identifying this RBAC Group.
+     * @returns RbacGroup
+     * @throws ApiError
+     */
+    public static coreRbacGroupsRetrieve(
+        id: number,
+    ): CancelablePromise<RbacGroup> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/rbac/groups/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Group not found`,
+            },
+        });
+    }
+    /**
+     * Update RBAC group
+     * Update an existing RBAC group. Platform validation applies for user assignments.
+     * @param id A unique integer value identifying this RBAC Group.
+     * @param requestBody
+     * @returns RbacGroup
+     * @throws ApiError
+     */
+    public static coreRbacGroupsUpdate(
+        id: number,
+        requestBody: RbacGroup,
+    ): CancelablePromise<RbacGroup> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/core/rbac/groups/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data. Common errors include:
+                - Users do not belong to the specified platform
+                - Invalid user IDs provided`,
+                404: `Group not found`,
+            },
+        });
+    }
+    /**
+     * Partially update RBAC group
+     * Partially update an existing RBAC group. Platform validation applies for user assignments.
+     * @param id A unique integer value identifying this RBAC Group.
+     * @param requestBody
+     * @returns RbacGroup
+     * @throws ApiError
+     */
+    public static coreRbacGroupsPartialUpdate(
+        id: number,
+        requestBody?: PatchedRbacGroup,
+    ): CancelablePromise<RbacGroup> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/core/rbac/groups/{id}/',
+            path: {
+                'id': id,
+            },
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Invalid request data.`,
-                404: `Platform not found.`,
+                400: `Invalid input data. Common errors include:
+                - Users do not belong to the specified platform
+                - Invalid user IDs provided`,
+                404: `Group not found`,
             },
         });
     }
     /**
-     * Remove a permission from a role.
-     * @returns any Permission does not exist for this role.
+     * Delete RBAC group
+     * Delete an RBAC group and all associated group role assignments.
+     * @param id A unique integer value identifying this RBAC Group.
+     * @returns void
      * @throws ApiError
      */
-    public static coreRbacRolePermissionsDestroy(): CancelablePromise<any> {
+    public static coreRbacGroupsDestroy(
+        id: number,
+    ): CancelablePromise<void> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/core/rbac/role/permissions/',
+            url: '/api/core/rbac/groups/{id}/',
+            path: {
+                'id': id,
+            },
             errors: {
-                400: `Invalid request data.`,
-                404: `Platform not found.`,
+                404: `Group not found`,
             },
         });
     }
     /**
-     * Get all users in a role.
-     * @returns any List of users in the role.
+     * List RBAC policies
+     * Retrieve a list of RBAC policies. Can be filtered by platform_key or role_id.
+     * @param page A page number within the paginated result set.
+     * @param pageSize Number of results to return per page.
+     * @param platformKey Filter policies by platform key
+     * @param roleId Filter policies by role ID
+     * @returns PaginatedRbacPolicyList
      * @throws ApiError
      */
-    public static coreRbacRoleUsersRetrieve(): CancelablePromise<any> {
+    public static coreRbacPoliciesList(
+        page?: number,
+        pageSize?: number,
+        platformKey?: string,
+        roleId?: number,
+    ): CancelablePromise<PaginatedRbacPolicyList> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/core/rbac/role/users/',
+            url: '/api/core/rbac/policies/',
+            query: {
+                'page': page,
+                'page_size': pageSize,
+                'platform_key': platformKey,
+                'role_id': roleId,
+            },
+        });
+    }
+    /**
+     * Create RBAC policy
+     * Create a new RBAC policy that defines resource access for a role.
+     * @param requestBody
+     * @returns RbacPolicy
+     * @throws ApiError
+     */
+    public static coreRbacPoliciesCreate(
+        requestBody: RbacPolicy,
+    ): CancelablePromise<RbacPolicy> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/rbac/policies/',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                404: `Platform not found.`,
+                400: `Invalid input data`,
             },
         });
     }
     /**
-     * Get all roles for a platform.
-     * @returns any List of roles for the platform.
+     * Retrieve RBAC policy
+     * Retrieve details of a specific RBAC policy.
+     * @param id A unique integer value identifying this RBAC Policy.
+     * @returns RbacPolicy
      * @throws ApiError
      */
-    public static coreRbacRolesRetrieve(): CancelablePromise<any> {
+    public static coreRbacPoliciesRetrieve(
+        id: number,
+    ): CancelablePromise<RbacPolicy> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/core/rbac/roles/',
+            url: '/api/core/rbac/policies/{id}/',
+            path: {
+                'id': id,
+            },
             errors: {
-                404: `Platform not found.`,
+                404: `Policy not found`,
             },
         });
     }
     /**
-     * Create a new role.
-     * @returns any No response body
+     * Update RBAC policy
+     * Update an existing RBAC policy.
+     * @param id A unique integer value identifying this RBAC Policy.
+     * @param requestBody
+     * @returns RbacPolicy
      * @throws ApiError
      */
-    public static coreRbacRolesCreate(): CancelablePromise<any> {
+    public static coreRbacPoliciesUpdate(
+        id: number,
+        requestBody: RbacPolicy,
+    ): CancelablePromise<RbacPolicy> {
         return __request(OpenAPI, {
-            method: 'POST',
-            url: '/api/core/rbac/roles/',
+            method: 'PUT',
+            url: '/api/core/rbac/policies/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Policy not found`,
+            },
         });
     }
     /**
-     * Delete a role.
+     * Partially update RBAC policy
+     * Partially update an existing RBAC policy.
+     * @param id A unique integer value identifying this RBAC Policy.
+     * @param requestBody
+     * @returns RbacPolicy
+     * @throws ApiError
+     */
+    public static coreRbacPoliciesPartialUpdate(
+        id: number,
+        requestBody?: PatchedRbacPolicy,
+    ): CancelablePromise<RbacPolicy> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/core/rbac/policies/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Policy not found`,
+            },
+        });
+    }
+    /**
+     * Delete RBAC policy
+     * Delete an RBAC policy.
+     * @param id A unique integer value identifying this RBAC Policy.
      * @returns void
      * @throws ApiError
      */
-    public static coreRbacRolesDestroy(): CancelablePromise<void> {
+    public static coreRbacPoliciesDestroy(
+        id: number,
+    ): CancelablePromise<void> {
         return __request(OpenAPI, {
             method: 'DELETE',
+            url: '/api/core/rbac/policies/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Policy not found`,
+            },
+        });
+    }
+    /**
+     * List RBAC roles
+     * Retrieve a list of RBAC roles. Can be filtered by platform_key.
+     * @param page A page number within the paginated result set.
+     * @param pageSize Number of results to return per page.
+     * @param platformKey Filter roles by platform key
+     * @returns PaginatedRbacRoleList
+     * @throws ApiError
+     */
+    public static coreRbacRolesList(
+        page?: number,
+        pageSize?: number,
+        platformKey?: string,
+    ): CancelablePromise<PaginatedRbacRoleList> {
+        return __request(OpenAPI, {
+            method: 'GET',
             url: '/api/core/rbac/roles/',
+            query: {
+                'page': page,
+                'page_size': pageSize,
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Create RBAC role
+     * Create a new RBAC role for a platform.
+     * @param requestBody
+     * @returns RbacRole
+     * @throws ApiError
+     */
+    public static coreRbacRolesCreate(
+        requestBody: RbacRole,
+    ): CancelablePromise<RbacRole> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/rbac/roles/',
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                400: `Invalid request data.`,
-                404: `Platform not found or role does not exist.`,
+                400: `Invalid input data`,
             },
         });
     }
     /**
-     * Get all roles for a user.
-     * @returns any List of roles for the user.
+     * Retrieve RBAC role
+     * Retrieve details of a specific RBAC role.
+     * @param id A unique integer value identifying this RBAC Role.
+     * @returns RbacRole
      * @throws ApiError
      */
-    public static coreRbacUserRolesRetrieve(): CancelablePromise<any> {
+    public static coreRbacRolesRetrieve(
+        id: number,
+    ): CancelablePromise<RbacRole> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/core/rbac/user/roles/',
+            url: '/api/core/rbac/roles/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Role not found`,
+            },
+        });
+    }
+    /**
+     * Update RBAC role
+     * Update an existing RBAC role.
+     * @param id A unique integer value identifying this RBAC Role.
+     * @param requestBody
+     * @returns RbacRole
+     * @throws ApiError
+     */
+    public static coreRbacRolesUpdate(
+        id: number,
+        requestBody: RbacRole,
+    ): CancelablePromise<RbacRole> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/core/rbac/roles/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
             errors: {
-                404: `Platform not found.`,
+                400: `Invalid input data`,
+                404: `Role not found`,
             },
         });
     }
     /**
-     * Add a user to a role.
+     * Partially update RBAC role
+     * Partially update an existing RBAC role.
+     * @param id A unique integer value identifying this RBAC Role.
      * @param requestBody
-     * @returns any Role already exists for this user.
+     * @returns RbacRole
+     * @throws ApiError
+     */
+    public static coreRbacRolesPartialUpdate(
+        id: number,
+        requestBody?: PatchedRbacRole,
+    ): CancelablePromise<RbacRole> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/core/rbac/roles/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data`,
+                404: `Role not found`,
+            },
+        });
+    }
+    /**
+     * Delete RBAC role
+     * Delete an RBAC role.
+     * @param id A unique integer value identifying this RBAC Role.
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreRbacRolesDestroy(
+        id: number,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/rbac/roles/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Role not found`,
+            },
+        });
+    }
+    /**
+     * List user role assignments
+     * Retrieve a list of user role assignments. Can be filtered by platform_key or user_id.
+     * @param page A page number within the paginated result set.
+     * @param pageSize Number of results to return per page.
+     * @param platformKey Filter user roles by platform key
+     * @param userId Filter user roles by user ID
+     * @returns PaginatedRbacUserRoleList
+     * @throws ApiError
+     */
+    public static coreRbacUserRolesList(
+        page?: number,
+        pageSize?: number,
+        platformKey?: string,
+        userId?: number,
+    ): CancelablePromise<PaginatedRbacUserRoleList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/rbac/user-roles/',
+            query: {
+                'page': page,
+                'page_size': pageSize,
+                'platform_key': platformKey,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * Create user role assignment
+     * Assign a role to a user. The user must belong to the same platform as the role.
+     * @param requestBody
+     * @returns RbacUserRole
      * @throws ApiError
      */
     public static coreRbacUserRolesCreate(
-        requestBody: UserRole,
-    ): CancelablePromise<any> {
+        requestBody: RbacUserRole,
+    ): CancelablePromise<RbacUserRole> {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/api/core/rbac/user/roles/',
+            url: '/api/core/rbac/user-roles/',
             body: requestBody,
             mediaType: 'application/json',
             errors: {
-                400: `Invalid request data.`,
-                404: `Platform not found.`,
+                400: `Invalid input data. Common errors include:
+                - User does not belong to the specified platform
+                - Role platform does not match provided platform_key`,
             },
         });
     }
     /**
-     * Remove a user from a role.
-     * @returns any Role does not exist for this user.
+     * Retrieve user role assignment
+     * Retrieve details of a specific user role assignment.
+     * @param id A unique integer value identifying this RBAC User Role.
+     * @returns RbacUserRole
      * @throws ApiError
      */
-    public static coreRbacUserRolesDestroy(): CancelablePromise<any> {
+    public static coreRbacUserRolesRetrieve(
+        id: number,
+    ): CancelablePromise<RbacUserRole> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/rbac/user-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `User role assignment not found`,
+            },
+        });
+    }
+    /**
+     * Update user role assignment
+     * Update an existing user role assignment. Platform validation applies.
+     * @param id A unique integer value identifying this RBAC User Role.
+     * @param requestBody
+     * @returns RbacUserRole
+     * @throws ApiError
+     */
+    public static coreRbacUserRolesUpdate(
+        id: number,
+        requestBody: RbacUserRole,
+    ): CancelablePromise<RbacUserRole> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/core/rbac/user-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data. Common errors include:
+                - User does not belong to the specified platform
+                - Role platform does not match provided platform_key`,
+                404: `User role assignment not found`,
+            },
+        });
+    }
+    /**
+     * Partially update user role assignment
+     * Partially update an existing user role assignment. Platform validation applies.
+     * @param id A unique integer value identifying this RBAC User Role.
+     * @param requestBody
+     * @returns RbacUserRole
+     * @throws ApiError
+     */
+    public static coreRbacUserRolesPartialUpdate(
+        id: number,
+        requestBody?: PatchedRbacUserRole,
+    ): CancelablePromise<RbacUserRole> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/core/rbac/user-roles/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                400: `Invalid input data. Common errors include:
+                - User does not belong to the specified platform
+                - Role platform does not match provided platform_key`,
+                404: `User role assignment not found`,
+            },
+        });
+    }
+    /**
+     * Delete user role assignment
+     * Remove a role assignment from a user.
+     * @param id A unique integer value identifying this RBAC User Role.
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreRbacUserRolesDestroy(
+        id: number,
+    ): CancelablePromise<void> {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/api/core/rbac/user/roles/',
+            url: '/api/core/rbac/user-roles/{id}/',
+            path: {
+                'id': id,
+            },
             errors: {
-                400: `Invalid request data.`,
-                404: `Platform not found.`,
+                404: `User role assignment not found`,
             },
         });
     }