@iblai/iblai-api 3.35.2-ai-plus → 3.35.3-core

package/src/services/SearchService.ts

@@ -6,68 +6,6 @@ import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
 export class SearchService {
-    /**
-     * Legacy endpoint for backward compatible mentor search
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param filterFacet If present, return only facets without results
-     * @param id Retrieve a specific mentor by ID
-     * @param limit Number of results per page
-     * @param llm Filter by language model type
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param page Page number (1-based, used with page_size)
-     * @param pageSize Number of results per page
-     * @param query Search term to filter mentors by name or description
-     * @param tags Filter by tags
-     * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
-     * @returns any
-     * @throws ApiError
-     */
-    public static searchAiSearchRetrieve(
-        audience?: Array<string>,
-        category?: Array<string>,
-        createdBy?: string,
-        filterFacet: boolean = false,
-        id?: number,
-        limit: number = 12,
-        llm?: Array<string>,
-        offset?: number,
-        orderBy?: string,
-        orderDirection: string = 'desc',
-        page?: number,
-        pageSize?: number,
-        query?: string,
-        tags?: Array<string>,
-        tenant?: string,
-        uniqueId?: string,
-    ): CancelablePromise<Record<string, any>> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/search/ai-search/',
-            query: {
-                'audience': audience,
-                'category': category,
-                'created_by': createdBy,
-                'filter_facet': filterFacet,
-                'id': id,
-                'limit': limit,
-                'llm': llm,
-                'offset': offset,
-                'order_by': orderBy,
-                'order_direction': orderDirection,
-                'page': page,
-                'page_size': pageSize,
-                'query': query,
-                'tags': tags,
-                'tenant': tenant,
-                'unique_id': uniqueId,
-            },
-        });
-    }
     /**
      * Search and filter content across the learning catalog
      * @param allowSkillSearch Enable skill-based search
@@ -170,615 +108,225 @@ export class SearchService {
         });
     }
     /**
-     * Get AI mentors based on search criteria
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param id Retrieve a specific mentor by ID
+     * Get personalized content for a specific user
+     * @param username
+     * @param allowSkillSearch Enable skill-based search
+     * @param alphabetical Sort alphabetically by name
+     * @param certificate Filter by certificate type
+     * @param content Content types to include in results
+     * @param courseId Retrieve a specific course by ID
+     * @param duration Filter by course duration range
+     * @param language Filter by content language
+     * @param level Filter by difficulty level
      * @param limit Number of results per page
-     * @param llm Filter by language model type
      * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param query Search term to filter mentors by name or description
+     * @param orderAscending Sort direction
+     * @param orderBy Field to sort results by
+     * @param pathwayId Retrieve a specific pathway by ID
+     * @param price Filter by price/audit status
+     * @param programId Retrieve a specific program by ID
+     * @param programType Filter by program type
+     * @param promotion Filter by promotion status
+     * @param query Search term to filter content by name or description
+     * @param recommended Show only recommended content
+     * @param resourceId Retrieve a specific resource by ID
+     * @param resourceType Filter by resource type
+     * @param returnFacet Include facet data in response
+     * @param returnItems Include items in programs/pathways
+     * @param roleId Retrieve a specific role by ID
+     * @param selfPaced Filter by course format
+     * @param skillId Retrieve a specific skill by ID
+     * @param skills Filter by skills
+     * @param subject Filter by subject areas
      * @param tags Filter by tags
      * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
+     * @param topics Filter by topic areas
+     * @param updateFacet Force facet update
      * @returns any
      * @throws ApiError
      */
-    public static searchMentorsRetrieve(
-        audience?: Array<string>,
-        category?: Array<string>,
-        createdBy?: string,
-        id?: number,
+    public static searchPersonalizedCatalogRetrieve(
+        username: string,
+        allowSkillSearch: boolean = false,
+        alphabetical: boolean = false,
+        certificate?: Array<string>,
+        content?: Array<string>,
+        courseId?: string,
+        duration?: Array<string>,
+        language?: Array<string>,
+        level?: Array<string>,
         limit: number = 12,
-        llm?: Array<string>,
         offset?: number,
+        orderAscending: boolean = false,
         orderBy?: string,
-        orderDirection: string = 'desc',
+        pathwayId?: string,
+        price?: string,
+        programId?: string,
+        programType?: Array<string>,
+        promotion?: Array<string>,
         query?: string,
+        recommended: boolean = false,
+        resourceId?: string,
+        resourceType?: Array<string>,
+        returnFacet: boolean = true,
+        returnItems: boolean = false,
+        roleId?: string,
+        selfPaced?: Array<string>,
+        skillId?: string,
+        skills?: Array<string>,
+        subject?: Array<string>,
         tags?: Array<string>,
-        tenant?: string,
-        uniqueId?: string,
+        tenant?: Array<string>,
+        topics?: Array<string>,
+        updateFacet?: string,
     ): CancelablePromise<Record<string, any>> {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/api/search/mentors/',
+            url: '/api/search/personalized-catalog/{username}/',
+            path: {
+                'username': username,
+            },
             query: {
-                'audience': audience,
-                'category': category,
-                'created_by': createdBy,
-                'id': id,
+                'allow_skill_search': allowSkillSearch,
+                'alphabetical': alphabetical,
+                'certificate': certificate,
+                'content': content,
+                'course_id': courseId,
+                'duration': duration,
+                'language': language,
+                'level': level,
                 'limit': limit,
-                'llm': llm,
                 'offset': offset,
+                'order_ascending': orderAscending,
                 'order_by': orderBy,
-                'order_direction': orderDirection,
+                'pathway_id': pathwayId,
+                'price': price,
+                'program_id': programId,
+                'program_type': programType,
+                'promotion': promotion,
                 'query': query,
+                'recommended': recommended,
+                'resource_id': resourceId,
+                'resource_type': resourceType,
+                'return_facet': returnFacet,
+                'return_items': returnItems,
+                'role_id': roleId,
+                'self_paced': selfPaced,
+                'skill_id': skillId,
+                'skills': skills,
+                'subject': subject,
                 'tags': tags,
                 'tenant': tenant,
-                'unique_id': uniqueId,
+                'topics': topics,
+                'update_facet': updateFacet,
             },
         });
     }
     /**
-     * Search and filter documents associated with a specific mentor.
+     * Search and filter users within a specific organization/tenant.
      *
-     * This endpoint allows searching and filtering documents that are linked to a
-     * particular mentor, with support for pagination, sorting, and faceted filtering.
+     * This endpoint provides a search interface for discovering users within an organization,
+     * with support for filtering by departments, pagination, and faceted filtering.
      *
      * Path Parameters:
-     * mentor_unique_id (uuid): The unique identifier of the mentor
+     * org (str): The organization/tenant identifier
+     * username (str): The username of the user making the request
      *
      * Query Parameters:
-     * query (str, optional): Search term to filter documents by name or content
-     * document_type (str, optional): Filter by document type (e.g., 'pdf', 'text')
-     * access (str, optional): Filter by access level (e.g., 'public', 'private')
-     * training_status (str, optional): Filter by training status (e.g., 'trained', 'pending')
-     * platform_key (str, optional): Filter by platform key
-     * order_by (str, optional): Field to sort results by ('date_created', 'last_modified', 'document_name')
-     * order_direction (str, optional): Sort direction ('asc' or 'desc', default: 'desc')
-     * limit (int, optional): Number of results per page (default: 12, max: 100)
+     * # Search parameters
+     * query (str, optional): Search term to filter users by name, username, or email
+     *
+     * # Department filtering
+     * department_mode (bool, optional): Enable department-based filtering (default: false)
+     * user_department (bool, optional): Legacy parameter for department_mode (default: false)
+     * department (list, optional): Filter by specific departments
+     *
+     * # Additional filters
+     * role (list, optional): Filter by user role
+     * status (list, optional): Filter by user status (active, inactive)
+     * joined_date (list, optional): Filter by join date range
+     * last_login (list, optional): Filter by last login date range
+     *
+     * # Pagination
+     * limit (int, optional): Number of results per page (default: 10)
      * offset (int, optional): Starting position for pagination
      *
      * Returns:
      * A JSON response containing:
+     * ```
      * {
          * "results": [
              * {
-                 * "id": 789,
-                 * "document_name": "Introduction to Algorithms.pdf",
-                 * "document_type": "pdf",
-                 * "access": "public",
-                 * "training_status": "trained",
-                 * "date_created": "2023-03-15T10:30:00Z",
-                 * "last_modified": "2023-04-20T14:45:00Z",
-                 * "url": "https://example.com/documents/intro-algorithms.pdf",
+                 * "id": 123,
+                 * "username": "john.doe",
+                 * "email": "john.doe@example.com",
+                 * "first_name": "John",
+                 * "last_name": "Doe",
+                 * "full_name": "John Doe",
+                 * "profile_image": "https://example.com/profiles/john-doe.jpg",
+                 * "role": "Student",
+                 * "departments": ["Computer Science", "Data Science"],
+                 * "status": "active",
+                 * "joined_date": "2023-01-15T12:00:00Z",
+                 * "last_login": "2023-06-20T15:30:00Z",
                  * "metadata": {
-                     * "page_count": 45,
-                     * "author": "John Smith",
-                     * "keywords": ["algorithms", "computer science", "data structures"],
-                     * "description": "Comprehensive introduction to fundamental algorithms"
+                     * "location": "New York",
+                     * "title": "Software Engineer",
+                     * "bio": "Experienced software engineer with a passion for education"
                      * }
                      * },
-                     * // Additional document objects...
+                     * // Additional user objects...
                      * ],
-                     * "count": 25,
-                     * "next": "https://api.example.com/api/search/mentors/550e8400-e29b-41d4-a716-446655440000/documents/?limit=12&offset=12",
+                     * "count": 50,
+                     * "next": "https://api.example.com/api/search/users/example-org/admin/?limit=10&offset=10",
                      * "previous": null,
                      * "current_page": 1,
-                     * "total_pages": 3,
+                     * "total_pages": 5,
                      * "facets": {
-                         * "document_type": [
-                             * {"key": "pdf", "doc_count": 15},
-                             * {"key": "text", "doc_count": 5},
-                             * {"key": "docx", "doc_count": 5}
+                         * "role": [
+                             * {"key": "Student", "doc_count": 30},
+                             * {"key": "Instructor", "doc_count": 15},
+                             * {"key": "Admin", "doc_count": 5}
                              * ],
-                             * "access": [
-                                 * {"key": "public", "doc_count": 20},
-                                 * {"key": "private", "doc_count": 5}
+                             * "department": [
+                                 * {"key": "Computer Science", "doc_count": 20},
+                                 * {"key": "Data Science", "doc_count": 15},
+                                 * {"key": "Business", "doc_count": 10},
+                                 * {"key": "Engineering", "doc_count": 5}
                                  * ],
-                                 * "training_status": [
-                                     * {"key": "trained", "doc_count": 18},
-                                     * {"key": "pending", "doc_count": 5},
-                                     * {"key": "failed", "doc_count": 2}
+                                 * "status": [
+                                     * {"key": "active", "doc_count": 45},
+                                     * {"key": "inactive", "doc_count": 5}
                                      * ]
                                      * }
                                      * }
-                                     *
-                                     * Error Responses:
-                                     * 400 Bad Request: If the request parameters are invalid
-                                     * 404 Not Found: If the mentor doesn't exist
-                                     * 500 Internal Server Error: If an unexpected error occurs during processing
-                                     *
-                                     * Access Control:
-                                     * - Requires platform membership
-                                     * - Only documents associated with the specified mentor are returned
-                                     * - Access level filtering respects user permissions
-                                     * @param mentorUniqueId
-                                     * @returns any No response body
-                                     * @throws ApiError
-                                     */
-                                    public static searchMentorsDocumentsRetrieve(
-                                        mentorUniqueId: string,
-                                    ): CancelablePromise<any> {
-                                        return __request(OpenAPI, {
-                                            method: 'GET',
-                                            url: '/api/search/mentors/{mentor_unique_id}/documents/',
-                                            path: {
-                                                'mentor_unique_id': mentorUniqueId,
-                                            },
-                                        });
-                                    }
-                                    /**
-                                     * Get AI mentors for a specific tenant and user
-                                     * @param org
-                                     * @param username
-                                     * @param audience Filter by target audience
-                                     * @param category Filter by mentor category
-                                     * @param createdBy Filter mentors created by specific user
-                                     * @param id Retrieve a specific mentor by ID
-                                     * @param limit Number of results per page
-                                     * @param llm Filter by language model type
-                                     * @param offset Starting position for pagination
-                                     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-                                     * @param orderDirection Sort direction ('asc' or 'desc')
-                                     * @param query Search term to filter mentors by name or description
-                                     * @param tags Filter by tags
-                                     * @param tenant Filter by tenant/organization
-                                     * @param uniqueId Retrieve a specific mentor by UUID
-                                     * @returns any
-                                     * @throws ApiError
-                                     */
-                                    public static searchOrgsUsersMentorsRetrieve(
-                                        org: string,
-                                        username: string,
-                                        audience?: Array<string>,
-                                        category?: Array<string>,
-                                        createdBy?: string,
-                                        id?: number,
-                                        limit: number = 12,
-                                        llm?: Array<string>,
-                                        offset?: number,
-                                        orderBy?: string,
-                                        orderDirection: string = 'desc',
-                                        query?: string,
-                                        tags?: Array<string>,
-                                        tenant?: string,
-                                        uniqueId?: string,
-                                    ): CancelablePromise<Record<string, any>> {
-                                        return __request(OpenAPI, {
-                                            method: 'GET',
-                                            url: '/api/search/orgs/{org}/users/{username}/mentors/',
-                                            path: {
-                                                'org': org,
-                                                'username': username,
-                                            },
-                                            query: {
-                                                'audience': audience,
-                                                'category': category,
-                                                'created_by': createdBy,
-                                                'id': id,
-                                                'limit': limit,
-                                                'llm': llm,
-                                                'offset': offset,
-                                                'order_by': orderBy,
-                                                'order_direction': orderDirection,
-                                                'query': query,
-                                                'tags': tags,
-                                                'tenant': tenant,
-                                                'unique_id': uniqueId,
-                                            },
-                                        });
-                                    }
-                                    /**
-                                     * Search and filter AI prompts for a specific user within a tenant.
-                                     *
-                                     * This endpoint extends the base prompt search functionality but filters results
-                                     * to only show prompts that are available to a specific user within a specific
-                                     * organization/tenant.
-                                     *
-                                     * Path Parameters:
-                                     * org (str): The organization/tenant identifier
-                                     * username (str): The username to filter prompts for
-                                     *
-                                     * Query Parameters:
-                                     * Same as PromptSearchView, plus:
-                                     *
-                                     * # Identification parameters (for detail view)
-                                     * id (int, optional): Retrieve a specific prompt by ID
-                                     *
-                                     * Returns:
-                                     * Same format as PromptSearchView, but filtered to only include prompts
-                                     * that the specified user has access to within the specified organization.
-                                     *
+                                     * ```
                                      * Error Responses:
                                      * 400 Bad Request: If the request parameters are invalid
-                                     * 403 Forbidden: If the requested prompt exists but the user doesn't have access
-                                     * 404 Not Found: If the requested prompt doesn't exist
+                                     * 403 Forbidden: If the user doesn't have department admin privileges (when using department_mode)
+                                     * 404 Not Found: If the user or organization doesn't exist
                                      * 500 Internal Server Error: If an unexpected error occurs
                                      *
                                      * Access Control:
-                                     * - Results are filtered based on user's permissions within the organization
-                                     * - Private prompts are only visible to authorized users
-                                     * @param org
-                                     * @param username
-                                     * @returns any No response body
-                                     * @throws ApiError
-                                     */
-                                    public static searchOrgsUsersPromptsRetrieve(
-                                        org: string,
-                                        username: string,
-                                    ): CancelablePromise<any> {
-                                        return __request(OpenAPI, {
-                                            method: 'GET',
-                                            url: '/api/search/orgs/{org}/users/{username}/prompts/',
-                                            path: {
-                                                'org': org,
-                                                'username': username,
-                                            },
-                                        });
-                                    }
-                                    /**
-                                     * Determine whether to serve a detail view or a list view.
+                                     * - The requesting user must have an active account in the specified organization
+                                     * - When department_mode is enabled, the user must be an admin of at least one department
+                                     * - Department filtering restricts results to users in departments where the requesting user is an admin
                                      * @param org
                                      * @param username
                                      * @returns any No response body
                                      * @throws ApiError
                                      */
-                                    public static searchOrgsUsersRecommendedRetrieve(
+                                    public static searchUsersOrgsUsersRetrieve(
                                         org: string,
                                         username: string,
                                     ): CancelablePromise<any> {
                                         return __request(OpenAPI, {
                                             method: 'GET',
-                                            url: '/api/search/orgs/{org}/users/{username}/recommended/',
+                                            url: '/api/search/users/orgs/{org}/users/{username}/',
                                             path: {
                                                 'org': org,
                                                 'username': username,
                                             },
                                         });
                                     }
-                                    /**
-                                     * Get personalized content for a specific user
-                                     * @param username
-                                     * @param allowSkillSearch Enable skill-based search
-                                     * @param alphabetical Sort alphabetically by name
-                                     * @param certificate Filter by certificate type
-                                     * @param content Content types to include in results
-                                     * @param courseId Retrieve a specific course by ID
-                                     * @param duration Filter by course duration range
-                                     * @param language Filter by content language
-                                     * @param level Filter by difficulty level
-                                     * @param limit Number of results per page
-                                     * @param offset Starting position for pagination
-                                     * @param orderAscending Sort direction
-                                     * @param orderBy Field to sort results by
-                                     * @param pathwayId Retrieve a specific pathway by ID
-                                     * @param price Filter by price/audit status
-                                     * @param programId Retrieve a specific program by ID
-                                     * @param programType Filter by program type
-                                     * @param promotion Filter by promotion status
-                                     * @param query Search term to filter content by name or description
-                                     * @param recommended Show only recommended content
-                                     * @param resourceId Retrieve a specific resource by ID
-                                     * @param resourceType Filter by resource type
-                                     * @param returnFacet Include facet data in response
-                                     * @param returnItems Include items in programs/pathways
-                                     * @param roleId Retrieve a specific role by ID
-                                     * @param selfPaced Filter by course format
-                                     * @param skillId Retrieve a specific skill by ID
-                                     * @param skills Filter by skills
-                                     * @param subject Filter by subject areas
-                                     * @param tags Filter by tags
-                                     * @param tenant Filter by tenant/organization
-                                     * @param topics Filter by topic areas
-                                     * @param updateFacet Force facet update
-                                     * @returns any
-                                     * @throws ApiError
-                                     */
-                                    public static searchPersonalizedCatalogRetrieve(
-                                        username: string,
-                                        allowSkillSearch: boolean = false,
-                                        alphabetical: boolean = false,
-                                        certificate?: Array<string>,
-                                        content?: Array<string>,
-                                        courseId?: string,
-                                        duration?: Array<string>,
-                                        language?: Array<string>,
-                                        level?: Array<string>,
-                                        limit: number = 12,
-                                        offset?: number,
-                                        orderAscending: boolean = false,
-                                        orderBy?: string,
-                                        pathwayId?: string,
-                                        price?: string,
-                                        programId?: string,
-                                        programType?: Array<string>,
-                                        promotion?: Array<string>,
-                                        query?: string,
-                                        recommended: boolean = false,
-                                        resourceId?: string,
-                                        resourceType?: Array<string>,
-                                        returnFacet: boolean = true,
-                                        returnItems: boolean = false,
-                                        roleId?: string,
-                                        selfPaced?: Array<string>,
-                                        skillId?: string,
-                                        skills?: Array<string>,
-                                        subject?: Array<string>,
-                                        tags?: Array<string>,
-                                        tenant?: Array<string>,
-                                        topics?: Array<string>,
-                                        updateFacet?: string,
-                                    ): CancelablePromise<Record<string, any>> {
-                                        return __request(OpenAPI, {
-                                            method: 'GET',
-                                            url: '/api/search/personalized-catalog/{username}/',
-                                            path: {
-                                                'username': username,
-                                            },
-                                            query: {
-                                                'allow_skill_search': allowSkillSearch,
-                                                'alphabetical': alphabetical,
-                                                'certificate': certificate,
-                                                'content': content,
-                                                'course_id': courseId,
-                                                'duration': duration,
-                                                'language': language,
-                                                'level': level,
-                                                'limit': limit,
-                                                'offset': offset,
-                                                'order_ascending': orderAscending,
-                                                'order_by': orderBy,
-                                                'pathway_id': pathwayId,
-                                                'price': price,
-                                                'program_id': programId,
-                                                'program_type': programType,
-                                                'promotion': promotion,
-                                                'query': query,
-                                                'recommended': recommended,
-                                                'resource_id': resourceId,
-                                                'resource_type': resourceType,
-                                                'return_facet': returnFacet,
-                                                'return_items': returnItems,
-                                                'role_id': roleId,
-                                                'self_paced': selfPaced,
-                                                'skill_id': skillId,
-                                                'skills': skills,
-                                                'subject': subject,
-                                                'tags': tags,
-                                                'tenant': tenant,
-                                                'topics': topics,
-                                                'update_facet': updateFacet,
-                                            },
-                                        });
-                                    }
-                                    /**
-                                     * Search and filter AI prompts across the platform.
-                                     *
-                                     * This endpoint provides a search interface for discovering AI prompts
-                                     * with support for filtering, pagination, and detailed prompt information.
-                                     *
-                                     * Query Parameters:
-                                     * # Identification parameters (for detail view)
-                                     * id (int, optional): Retrieve a specific prompt by ID
-                                     *
-                                     * # Search and filtering parameters
-                                     * query (str, optional): Search term to filter prompts by name or content
-                                     * category (str, optional): Filter by prompt category
-                                     * language (str, optional): Filter by prompt language
-                                     * style (str, optional): Filter by writing style
-                                     * tone (str, optional): Filter by tone
-                                     * tenant (str, optional): Filter by tenant/organization
-                                     * mentor (str, optional): Filter by associated mentor (UUID)
-                                     *
-                                     * # Sorting and pagination
-                                     * sort_by (str, optional): Field to sort results by
-                                     * order_direction (str, optional): Sort direction ('asc' or 'desc', default: 'desc')
-                                     * alphabetical (bool, optional): Sort alphabetically by name (default: false)
-                                     * limit (int, optional): Number of results per page (default: 10)
-                                     * offset (int, optional): Starting position for pagination
-                                     *
-                                     * # Special parameters
-                                     * filter_facet (any, optional): If present, return only facets without results
-                                     *
-                                     * Returns:
-                                     * For detail view (when id is provided):
-                                     * A JSON response containing a single prompt's details:
-                                     * {
-                                         * "id": 456,
-                                         * "name": "Essay Writing Guide",
-                                         * "content": "Write a well-structured essay on the following topic: {{topic}}...",
-                                         * "category": "Academic Writing",
-                                         * "language": "English",
-                                         * "style": "Formal",
-                                         * "tone": "Professional",
-                                         * "mentor": {
-                                             * "id": 123,
-                                             * "unique_id": "550e8400-e29b-41d4-a716-446655440000",
-                                             * "name": "Professor Smith"
-                                             * },
-                                             * "platform": {
-                                                 * "id": 1,
-                                                 * "name": "Example University",
-                                                 * "key": "example-university"
-                                                 * },
-                                                 * "created_at": "2023-02-10T09:15:00Z",
-                                                 * "updated_at": "2023-05-05T14:20:00Z",
-                                                 * "visibility": "public",
-                                                 * "variables": ["topic", "length", "style"]
-                                                 * }
-                                                 *
-                                                 * For list view:
-                                                 * A JSON response containing:
-                                                 * {
-                                                     * "results": [
-                                                         * {
-                                                             * "id": 456,
-                                                             * "name": "Essay Writing Guide",
-                                                             * "content": "Write a well-structured essay on the following topic: {{topic}}...",
-                                                             * "category": "Academic Writing",
-                                                             * "language": "English",
-                                                             * "style": "Formal",
-                                                             * "tone": "Professional",
-                                                             * "mentor": {"id": 123, "name": "Professor Smith"},
-                                                             * "created_at": "2023-02-10T09:15:00Z",
-                                                             * "updated_at": "2023-05-05T14:20:00Z"
-                                                             * },
-                                                             * // Additional prompt objects...
-                                                             * ],
-                                                             * "count": 30,
-                                                             * "next": "?limit=10&offset=10",
-                                                             * "previous": null,
-                                                             * "current_page": 1,
-                                                             * "num_pages": 3,
-                                                             * "facets": {
-                                                                 * "category": [
-                                                                     * {"key": "Academic Writing", "doc_count": 15},
-                                                                     * {"key": "Creative Writing", "doc_count": 10},
-                                                                     * {"key": "Technical Documentation", "doc_count": 5}
-                                                                     * ],
-                                                                     * "language": [
-                                                                         * {"key": "English", "doc_count": 25},
-                                                                         * {"key": "Spanish", "doc_count": 5}
-                                                                         * ],
-                                                                         * "style": [
-                                                                             * {"key": "Formal", "doc_count": 20},
-                                                                             * {"key": "Casual", "doc_count": 10}
-                                                                             * ],
-                                                                             * "tone": [
-                                                                                 * {"key": "Professional", "doc_count": 15},
-                                                                                 * {"key": "Friendly", "doc_count": 10},
-                                                                                 * {"key": "Technical", "doc_count": 5}
-                                                                                 * ]
-                                                                                 * }
-                                                                                 * }
-                                                                                 *
-                                                                                 * Error Responses:
-                                                                                 * 400 Bad Request: If the request parameters are invalid
-                                                                                 * 403 Forbidden: If the requested prompt exists but is not publicly available
-                                                                                 * 404 Not Found: If the requested prompt doesn't exist
-                                                                                 * 500 Internal Server Error: If an unexpected error occurs
-                                                                                 *
-                                                                                 * Notes:
-                                                                                 * - Only publicly available prompts are returned by default
-                                                                                 * - When filtering by mentor, the mentor ID must be a valid UUID
-                                                                                 * @returns any No response body
-                                                                                 * @throws ApiError
-                                                                                 */
-                                                                                public static searchPromptsRetrieve(): CancelablePromise<any> {
-                                                                                    return __request(OpenAPI, {
-                                                                                        method: 'GET',
-                                                                                        url: '/api/search/prompts/',
-                                                                                    });
-                                                                                }
-                                                                                /**
-                                                                                 * Search and filter users within a specific organization/tenant.
-                                                                                 *
-                                                                                 * This endpoint provides a search interface for discovering users within an organization,
-                                                                                 * with support for filtering by departments, pagination, and faceted filtering.
-                                                                                 *
-                                                                                 * Path Parameters:
-                                                                                 * org (str): The organization/tenant identifier
-                                                                                 * username (str): The username of the user making the request
-                                                                                 *
-                                                                                 * Query Parameters:
-                                                                                 * # Search parameters
-                                                                                 * query (str, optional): Search term to filter users by name, username, or email
-                                                                                 *
-                                                                                 * # Department filtering
-                                                                                 * department_mode (bool, optional): Enable department-based filtering (default: false)
-                                                                                 * user_department (bool, optional): Legacy parameter for department_mode (default: false)
-                                                                                 * department (list, optional): Filter by specific departments
-                                                                                 *
-                                                                                 * # Additional filters
-                                                                                 * role (list, optional): Filter by user role
-                                                                                 * status (list, optional): Filter by user status (active, inactive)
-                                                                                 * joined_date (list, optional): Filter by join date range
-                                                                                 * last_login (list, optional): Filter by last login date range
-                                                                                 *
-                                                                                 * # Pagination
-                                                                                 * limit (int, optional): Number of results per page (default: 10)
-                                                                                 * offset (int, optional): Starting position for pagination
-                                                                                 *
-                                                                                 * Returns:
-                                                                                 * A JSON response containing:
-                                                                                 * ```
-                                                                                 * {
-                                                                                     * "results": [
-                                                                                         * {
-                                                                                             * "id": 123,
-                                                                                             * "username": "john.doe",
-                                                                                             * "email": "john.doe@example.com",
-                                                                                             * "first_name": "John",
-                                                                                             * "last_name": "Doe",
-                                                                                             * "full_name": "John Doe",
-                                                                                             * "profile_image": "https://example.com/profiles/john-doe.jpg",
-                                                                                             * "role": "Student",
-                                                                                             * "departments": ["Computer Science", "Data Science"],
-                                                                                             * "status": "active",
-                                                                                             * "joined_date": "2023-01-15T12:00:00Z",
-                                                                                             * "last_login": "2023-06-20T15:30:00Z",
-                                                                                             * "metadata": {
-                                                                                                 * "location": "New York",
-                                                                                                 * "title": "Software Engineer",
-                                                                                                 * "bio": "Experienced software engineer with a passion for education"
-                                                                                                 * }
-                                                                                                 * },
-                                                                                                 * // Additional user objects...
-                                                                                                 * ],
-                                                                                                 * "count": 50,
-                                                                                                 * "next": "https://api.example.com/api/search/users/example-org/admin/?limit=10&offset=10",
-                                                                                                 * "previous": null,
-                                                                                                 * "current_page": 1,
-                                                                                                 * "total_pages": 5,
-                                                                                                 * "facets": {
-                                                                                                     * "role": [
-                                                                                                         * {"key": "Student", "doc_count": 30},
-                                                                                                         * {"key": "Instructor", "doc_count": 15},
-                                                                                                         * {"key": "Admin", "doc_count": 5}
-                                                                                                         * ],
-                                                                                                         * "department": [
-                                                                                                             * {"key": "Computer Science", "doc_count": 20},
-                                                                                                             * {"key": "Data Science", "doc_count": 15},
-                                                                                                             * {"key": "Business", "doc_count": 10},
-                                                                                                             * {"key": "Engineering", "doc_count": 5}
-                                                                                                             * ],
-                                                                                                             * "status": [
-                                                                                                                 * {"key": "active", "doc_count": 45},
-                                                                                                                 * {"key": "inactive", "doc_count": 5}
-                                                                                                                 * ]
-                                                                                                                 * }
-                                                                                                                 * }
-                                                                                                                 * ```
-                                                                                                                 * Error Responses:
-                                                                                                                 * 400 Bad Request: If the request parameters are invalid
-                                                                                                                 * 403 Forbidden: If the user doesn't have department admin privileges (when using department_mode)
-                                                                                                                 * 404 Not Found: If the user or organization doesn't exist
-                                                                                                                 * 500 Internal Server Error: If an unexpected error occurs
-                                                                                                                 *
-                                                                                                                 * Access Control:
-                                                                                                                 * - The requesting user must have an active account in the specified organization
-                                                                                                                 * - When department_mode is enabled, the user must be an admin of at least one department
-                                                                                                                 * - Department filtering restricts results to users in departments where the requesting user is an admin
-                                                                                                                 * @param org
-                                                                                                                 * @param username
-                                                                                                                 * @returns any No response body
-                                                                                                                 * @throws ApiError
-                                                                                                                 */
-                                                                                                                public static searchUsersOrgsUsersRetrieve(
-                                                                                                                    org: string,
-                                                                                                                    username: string,
-                                                                                                                ): CancelablePromise<any> {
-                                                                                                                    return __request(OpenAPI, {
-                                                                                                                        method: 'GET',
-                                                                                                                        url: '/api/search/users/orgs/{org}/users/{username}/',
-                                                                                                                        path: {
-                                                                                                                            'org': org,
-                                                                                                                            'username': username,
-                                                                                                                        },
-                                                                                                                    });
-                                                                                                                }
-                                                                                                            }
+                                }