@iblai/iblai-api 3.34.5-ai-plus → 3.35.0-core

package/src/services/SearchService.ts

@@ -6,55 +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 compatibility with older mentor search implementations.
-     *
-     * This endpoint provides the same functionality as MentorSearchView but supports
-     * older pagination parameters and only returns publicly available mentors
-     * (VIEWABLE_BY_ANYONE).
-     *
-     * Query Parameters:
-     * # Identification parameters (for detail view)
-     * id (int, optional): Retrieve a specific mentor by ID
-     * unique_id (uuid, optional): Retrieve a specific mentor by UUID
-     *
-     * # Legacy pagination parameters
-     * page (int, optional): Page number (1-based, used with page_size)
-     * page_size (int, optional): Number of results per page
-     *
-     * # Standard pagination parameters (also supported)
-     * limit (int, optional): Number of results per page
-     * offset (int, optional): Starting position for pagination
-     *
-     * # Other parameters
-     * Same as MentorSearchView
-     *
-     * # Special parameters
-     * filter_facet (any, optional): If present, return only facets without results
-     * created_by (str, optional): Filter mentors created by specific user
-     *
-     * Returns:
-     * Same format as MentorSearchView, but only includes publicly available mentors.
-     *
-     * Error Responses:
-     * 400 Bad Request: If the request parameters are invalid
-     * 403 Forbidden: If the requested mentor exists but is not publicly available
-     * 404 Not Found: If the requested mentor doesn't exist
-     * 500 Internal Server Error: If an unexpected error occurs
-     *
-     * Notes:
-     * - This endpoint is maintained for backward compatibility
-     * - Only returns mentors with visibility set to VIEWABLE_BY_ANYONE
-     * - Supports both old-style (page/page_size) and new-style (limit/offset) pagination
-     * @returns any No response body
-     * @throws ApiError
-     */
-    public static searchAiSearchRetrieve(): CancelablePromise<any> {
-        return __request(OpenAPI, {
-            method: 'GET',
-            url: '/api/search/ai-search/',
-        });
-    }
     /**
      * Search and filter content across the learning catalog.
      *
@@ -230,575 +181,129 @@ export class SearchService {
                                                             });
                                                         }
                                                         /**
-                                                         * Search and filter AI mentors across the platform.
+                                                         * Determine whether to serve a detail view or a list view.
+                                                         * If any detail-identifying parameters are present (course_id, program_id, etc.)
+                                                         * the detail view is returned; otherwise the aggregated list view is returned.
+                                                         * @param username
+                                                         * @returns any No response body
+                                                         * @throws ApiError
+                                                         */
+                                                        public static searchPersonalizedCatalogRetrieve(
+                                                            username: string,
+                                                        ): CancelablePromise<any> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/search/personalized-catalog/{username}/',
+                                                                path: {
+                                                                    'username': username,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Search and filter users within a specific organization/tenant.
                                                          *
-                                                         * This endpoint provides a powerful search interface for discovering AI mentors
-                                                         * with support for filtering, pagination, and detailed mentor information.
+                                                         * 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:
-                                                         * # Identification parameters (for detail view)
-                                                         * id (int, optional): Retrieve a specific mentor by ID
-                                                         * unique_id (uuid, optional): Retrieve a specific mentor by UUID
+                                                         * # 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
                                                          *
-                                                         * # Search and filtering parameters
-                                                         * query (str, optional): Search term to filter mentors by name or description
-                                                         * tenant (str, optional): Filter by tenant/organization
-                                                         * llm (list, optional): Filter by language model type
-                                                         * audience (list, optional): Filter by target audience
-                                                         * category (list, optional): Filter by mentor category
-                                                         * tags (list, optional): Filter by tags
-                                                         * created_by (str, optional): Filter mentors created by specific user
+                                                         * # 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
                                                          *
-                                                         * # Sorting and pagination
-                                                         * order_by (str, optional): Field to sort results by ('created_at', 'recently_accessed_at')
-                                                         * order_direction (str, optional): Sort direction ('asc' or 'desc', default: 'desc')
-                                                         * limit (int, optional): Number of results per page (default: 12, max: 100)
+                                                         * # Pagination
+                                                         * limit (int, optional): Number of results per page (default: 10)
                                                          * offset (int, optional): Starting position for pagination
                                                          *
                                                          * Returns:
-                                                         * For detail view (when id or unique_id is provided):
-                                                         * A JSON response containing a single mentor's details:
+                                                         * A JSON response containing:
+                                                         * ```
                                                          * {
-                                                             * "id": 123,
-                                                             * "unique_id": "550e8400-e29b-41d4-a716-446655440000",
-                                                             * "name": "Professor Smith",
-                                                             * "description": "AI mentor specializing in computer science",
-                                                             * "image_url": "https://example.com/images/prof-smith.jpg",
-                                                             * "llm": {
-                                                                 * "id": 1,
-                                                                 * "name": "GPT-4",
-                                                                 * "description": "Advanced language model"
-                                                                 * },
-                                                                 * "audience": {
-                                                                     * "id": 2,
-                                                                     * "name": "College Students",
-                                                                     * "description": "For university-level learners"
-                                                                     * },
-                                                                     * "category": "Computer Science",
-                                                                     * "tags": ["programming", "algorithms", "data structures"],
-                                                                     * "created_at": "2023-01-15T12:00:00Z",
-                                                                     * "recently_accessed_at": "2023-06-20T15:30:00Z",
-                                                                     * "platform": {
-                                                                         * "id": 1,
-                                                                         * "name": "Example University",
-                                                                         * "key": "example-university"
+                                                             * "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"
+                                                                         * }
                                                                          * },
-                                                                         * "visibility": "public",
-                                                                         * "settings": {
-                                                                             * "temperature": 0.7,
-                                                                             * "max_tokens": 1024,
-                                                                             * "system_prompt": "You are Professor Smith, an expert in computer science..."
-                                                                             * }
-                                                                             * }
-                                                                             *
-                                                                             * For list view:
-                                                                             * A JSON response containing:
-                                                                             * {
-                                                                                 * "results": [
-                                                                                     * {
-                                                                                         * "id": 123,
-                                                                                         * "unique_id": "550e8400-e29b-41d4-a716-446655440000",
-                                                                                         * "name": "Professor Smith",
-                                                                                         * "description": "AI mentor specializing in computer science",
-                                                                                         * "image_url": "https://example.com/images/prof-smith.jpg",
-                                                                                         * "llm": {"id": 1, "name": "GPT-4"},
-                                                                                         * "audience": {"id": 2, "name": "College Students"},
-                                                                                         * "category": "Computer Science",
-                                                                                         * "tags": ["programming", "algorithms"],
-                                                                                         * "created_at": "2023-01-15T12:00:00Z",
-                                                                                         * "recently_accessed_at": "2023-06-20T15:30:00Z"
-                                                                                         * },
-                                                                                         * // Additional mentor objects...
-                                                                                         * ],
-                                                                                         * "count": 50,
-                                                                                         * "next": "https://api.example.com/api/search/mentors/?limit=12&offset=12",
-                                                                                         * "previous": null,
-                                                                                         * "current_page": 1,
-                                                                                         * "num_pages": 5,
-                                                                                         * "facets": {
-                                                                                             * "llm": [
-                                                                                                 * {"key": "GPT-4", "doc_count": 30},
-                                                                                                 * {"key": "Claude", "doc_count": 20}
-                                                                                                 * ],
-                                                                                                 * "audience": [
-                                                                                                     * {"key": "College Students", "doc_count": 35},
-                                                                                                     * {"key": "Professionals", "doc_count": 15}
-                                                                                                     * ],
-                                                                                                     * "category": [
-                                                                                                         * {"key": "Computer Science", "doc_count": 25},
-                                                                                                         * {"key": "Mathematics", "doc_count": 15},
-                                                                                                         * {"key": "Business", "doc_count": 10}
-                                                                                                         * ]
-                                                                                                         * }
-                                                                                                         * }
-                                                                                                         *
-                                                                                                         * Error Responses:
-                                                                                                         * 400 Bad Request: If the request parameters are invalid
-                                                                                                         * 404 Not Found: If the requested mentor doesn't exist
-                                                                                                         * 500 Internal Server Error: If an unexpected error occurs
-                                                                                                         *
-                                                                                                         * Notes:
-                                                                                                         * - Results are cached for performance
-                                                                                                         * - Public mentors are visible to all users
-                                                                                                         * - Private mentors are only visible to authorized users
-                                                                                                         * @returns any No response body
-                                                                                                         * @throws ApiError
-                                                                                                         */
-                                                                                                        public static searchMentorsRetrieve(): CancelablePromise<any> {
-                                                                                                            return __request(OpenAPI, {
-                                                                                                                method: 'GET',
-                                                                                                                url: '/api/search/mentors/',
-                                                                                                            });
-                                                                                                        }
-                                                                                                        /**
-                                                                                                         * Search and filter documents associated with a specific mentor.
-                                                                                                         *
-                                                                                                         * This endpoint allows searching and filtering documents that are linked to a
-                                                                                                         * particular mentor, with support for pagination, sorting, and faceted filtering.
-                                                                                                         *
-                                                                                                         * Path Parameters:
-                                                                                                         * mentor_unique_id (uuid): The unique identifier of the mentor
-                                                                                                         *
-                                                                                                         * 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)
-                                                                                                         * 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",
-                                                                                                                     * "metadata": {
-                                                                                                                         * "page_count": 45,
-                                                                                                                         * "author": "John Smith",
-                                                                                                                         * "keywords": ["algorithms", "computer science", "data structures"],
-                                                                                                                         * "description": "Comprehensive introduction to fundamental algorithms"
-                                                                                                                         * }
-                                                                                                                         * },
-                                                                                                                         * // Additional document objects...
-                                                                                                                         * ],
-                                                                                                                         * "count": 25,
-                                                                                                                         * "next": "https://api.example.com/api/search/mentors/550e8400-e29b-41d4-a716-446655440000/documents/?limit=12&offset=12",
-                                                                                                                         * "previous": null,
-                                                                                                                         * "current_page": 1,
-                                                                                                                         * "total_pages": 3,
-                                                                                                                         * "facets": {
-                                                                                                                             * "document_type": [
-                                                                                                                                 * {"key": "pdf", "doc_count": 15},
-                                                                                                                                 * {"key": "text", "doc_count": 5},
-                                                                                                                                 * {"key": "docx", "doc_count": 5}
-                                                                                                                                 * ],
-                                                                                                                                 * "access": [
-                                                                                                                                     * {"key": "public", "doc_count": 20},
-                                                                                                                                     * {"key": "private", "doc_count": 5}
-                                                                                                                                     * ],
-                                                                                                                                     * "training_status": [
-                                                                                                                                         * {"key": "trained", "doc_count": 18},
-                                                                                                                                         * {"key": "pending", "doc_count": 5},
-                                                                                                                                         * {"key": "failed", "doc_count": 2}
-                                                                                                                                         * ]
-                                                                                                                                         * }
-                                                                                                                                         * }
-                                                                                                                                         *
-                                                                                                                                         * 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,
-                                                                                                                                                },
-                                                                                                                                            });
-                                                                                                                                        }
-                                                                                                                                        /**
-                                                                                                                                         * Search and filter AI mentors for a specific user within a tenant.
-                                                                                                                                         *
-                                                                                                                                         * This endpoint extends the base mentor search functionality but filters results
-                                                                                                                                         * to only show mentors 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 mentors for
-                                                                                                                                         *
-                                                                                                                                         * Query Parameters:
-                                                                                                                                         * Same as MentorSearchView, plus:
-                                                                                                                                         *
-                                                                                                                                         * # Identification parameters (for detail view)
-                                                                                                                                         * id (int, optional): Retrieve a specific mentor by ID
-                                                                                                                                         * unique_id (uuid, optional): Retrieve a specific mentor by UUID
-                                                                                                                                         * created_by (str, optional): Filter mentors created by specific user
-                                                                                                                                         *
-                                                                                                                                         * Returns:
-                                                                                                                                         * Same format as MentorSearchView, but filtered to only include mentors
-                                                                                                                                         * that the specified user has access to within the specified organization.
-                                                                                                                                         *
-                                                                                                                                         * Error Responses:
-                                                                                                                                         * 400 Bad Request: If the request parameters are invalid
-                                                                                                                                         * 404 Not Found: If the requested mentor doesn't exist or user doesn't have access
-                                                                                                                                         * 500 Internal Server Error: If an unexpected error occurs
-                                                                                                                                         *
-                                                                                                                                         * Access Control:
-                                                                                                                                         * - Requires platform membership (though currently not enforced)
-                                                                                                                                         * - Results are filtered based on user's permissions within the organization
-                                                                                                                                         * @param org
-                                                                                                                                         * @param username
-                                                                                                                                         * @returns any No response body
-                                                                                                                                         * @throws ApiError
-                                                                                                                                         */
-                                                                                                                                        public static searchOrgsUsersMentorsRetrieve(
-                                                                                                                                            org: string,
-                                                                                                                                            username: string,
-                                                                                                                                        ): CancelablePromise<any> {
-                                                                                                                                            return __request(OpenAPI, {
-                                                                                                                                                method: 'GET',
-                                                                                                                                                url: '/api/search/orgs/{org}/users/{username}/mentors/',
-                                                                                                                                                path: {
-                                                                                                                                                    'org': org,
-                                                                                                                                                    'username': username,
-                                                                                                                                                },
-                                                                                                                                            });
-                                                                                                                                        }
-                                                                                                                                        /**
-                                                                                                                                         * 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
-                                                                                                                                         * 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.
-                                                                                                                                         * @param org
-                                                                                                                                         * @param username
-                                                                                                                                         * @returns any No response body
-                                                                                                                                         * @throws ApiError
-                                                                                                                                         */
-                                                                                                                                        public static searchOrgsUsersRecommendedRetrieve(
-                                                                                                                                            org: string,
-                                                                                                                                            username: string,
-                                                                                                                                        ): CancelablePromise<any> {
-                                                                                                                                            return __request(OpenAPI, {
-                                                                                                                                                method: 'GET',
-                                                                                                                                                url: '/api/search/orgs/{org}/users/{username}/recommended/',
-                                                                                                                                                path: {
-                                                                                                                                                    'org': org,
-                                                                                                                                                    'username': username,
-                                                                                                                                                },
-                                                                                                                                            });
-                                                                                                                                        }
-                                                                                                                                        /**
-                                                                                                                                         * Determine whether to serve a detail view or a list view.
-                                                                                                                                         * If any detail-identifying parameters are present (course_id, program_id, etc.)
-                                                                                                                                         * the detail view is returned; otherwise the aggregated list view is returned.
-                                                                                                                                         * @param username
-                                                                                                                                         * @returns any No response body
-                                                                                                                                         * @throws ApiError
-                                                                                                                                         */
-                                                                                                                                        public static searchPersonalizedCatalogRetrieve(
-                                                                                                                                            username: string,
-                                                                                                                                        ): CancelablePromise<any> {
-                                                                                                                                            return __request(OpenAPI, {
-                                                                                                                                                method: 'GET',
-                                                                                                                                                url: '/api/search/personalized-catalog/{username}/',
-                                                                                                                                                path: {
-                                                                                                                                                    'username': username,
-                                                                                                                                                },
-                                                                                                                                            });
-                                                                                                                                        }
-                                                                                                                                        /**
-                                                                                                                                         * 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,
-                                                                                                                                                                                                                            },
-                                                                                                                                                                                                                        });
-                                                                                                                                                                                                                    }
-                                                                                                                                                                                                                }
+                                                                         * // 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,
+                                                                                                },
+                                                                                            });
+                                                                                        }
+                                                                                    }