@iblai/iblai-api 3.35.0-core → 3.35.1-ai

package/dist/types/services/SearchService.d.ts

@@ -1,183 +1,378 @@
 import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class SearchService {
     /**
-     * Search and filter content across the learning catalog.
-     *
-     * This endpoint provides a powerful search interface for discovering content across
-     * multiple content types (courses, programs, pathways, skills, roles, resources).
-     * It supports full-text search, faceted filtering, and pagination.
+     * Legacy endpoint for backward compatible mentor search
+     * @param audience Filter by target audience
+     * @param category Filter by mentor category
+     * @param createdBy Filter mentors created by specific user
+     * @param filterFacet If present, return only facets without results
+     * @param id Retrieve a specific mentor by ID
+     * @param limit Number of results per page
+     * @param llm Filter by language model type
+     * @param offset Starting position for pagination
+     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
+     * @param orderDirection Sort direction ('asc' or 'desc')
+     * @param page Page number (1-based, used with page_size)
+     * @param pageSize Number of results per page
+     * @param query Search term to filter mentors by name or description
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param uniqueId Retrieve a specific mentor by UUID
+     * @returns any
+     * @throws ApiError
+     */
+    static searchAiSearchRetrieve(audience?: Array<string>, category?: Array<string>, createdBy?: string, filterFacet?: boolean, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, page?: number, pageSize?: number, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<Record<string, any>>;
+    /**
+     * Search and filter content across the learning catalog
+     * @param allowSkillSearch Enable skill-based search
+     * @param alphabetical Sort alphabetically by name
+     * @param certificate Filter by certificate type
+     * @param content Content types to include in results
+     * @param courseId Filter by specific course ID
+     * @param duration Filter by course duration range
+     * @param language Filter by content language
+     * @param level Filter by difficulty level
+     * @param limit Number of results per page
+     * @param offset Starting position for pagination
+     * @param orderAscending Sort direction
+     * @param orderBy Field to sort results by
+     * @param pathwayId Filter by specific pathway ID
+     * @param price Filter by price/audit status
+     * @param programId Filter by specific program ID
+     * @param programType Filter by program type
+     * @param promotion Filter by promotion status
+     * @param query Search term to filter content by name or description
+     * @param resourceType Filter by resource type
+     * @param returnFacet Include facet data in response
+     * @param returnItems Include items in programs/pathways
+     * @param selfPaced Filter by course format
+     * @param skillId Filter by specific skill ID
+     * @param skills Filter by skills
+     * @param subject Filter by subject areas
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param topics Filter by topic areas
+     * @param updateFacet Force facet update
+     * @returns any
+     * @throws ApiError
+     */
+    static searchCatalogRetrieve(allowSkillSearch?: boolean, alphabetical?: boolean, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, orderAscending?: boolean, orderBy?: string, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, promotion?: Array<string>, query?: string, resourceType?: Array<string>, returnFacet?: boolean, returnItems?: boolean, selfPaced?: Array<string>, skillId?: string, skills?: Array<string>, subject?: Array<string>, tags?: Array<string>, tenant?: Array<string>, topics?: Array<string>, updateFacet?: string): CancelablePromise<Record<string, any>>;
+    /**
+     * Get AI mentors based on search criteria
+     * @param audience Filter by target audience
+     * @param category Filter by mentor category
+     * @param createdBy Filter mentors created by specific user
+     * @param id Retrieve a specific mentor by ID
+     * @param limit Number of results per page
+     * @param llm Filter by language model type
+     * @param offset Starting position for pagination
+     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
+     * @param orderDirection Sort direction ('asc' or 'desc')
+     * @param query Search term to filter mentors by name or description
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param uniqueId Retrieve a specific mentor by UUID
+     * @returns any
+     * @throws ApiError
+     */
+    static searchMentorsRetrieve(audience?: Array<string>, category?: Array<string>, createdBy?: string, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<Record<string, any>>;
+    /**
+     * Search and filter documents associated with a specific mentor.
      *
-     * Query Parameters:
-     * query (str, optional): Search term to filter content by name or description
-     * content (list, optional): Content types to include in results
-     * (courses, programs, pathways, skills, roles, resources)
-     * Default: ["programs", "courses", "pathways", "skills"]
+     * This endpoint allows searching and filtering documents that are linked to a
+     * particular mentor, with support for pagination, sorting, and faceted filtering.
      *
-     * # Filtering parameters
-     * course_id (str, optional): Filter by specific course ID
-     * program_id (str, optional): Filter by specific program ID
-     * pathway_id (str, optional): Filter by specific pathway ID
-     * skill_id (str, optional): Filter by specific skill ID
-     * subject (list, optional): Filter by subject areas
-     * tenant (list, optional): Filter by tenant/organization
-     * topics (list, optional): Filter by topic areas
-     * tags (list, optional): Filter by tags
-     * level (list, optional): Filter by difficulty level
-     * self_paced (list, optional): Filter by course format (self-paced, instructor-led)
-     * promotion (list, optional): Filter by promotion status
-     * language (list, optional): Filter by content language
-     * certificate (list, optional): Filter by certificate type
-     * program_type (list, optional): Filter by program type
-     * duration (list, optional): Filter by course duration range
-     * price (str, optional): Filter by price/audit status
-     * resource_type (list, optional): Filter by resource type
-     * skills (list, optional): Filter by skills
+     * Path Parameters:
+     * mentor_unique_id (uuid): The unique identifier of the mentor
      *
-     * # Sorting and pagination
-     * order_by (str, optional): Field to sort results by
-     * order_ascending (bool, optional): Sort direction (default: false)
-     * alphabetical (bool, optional): Sort alphabetically by name (default: false)
+     * 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
      *
-     * # Response options
-     * return_facet (bool, optional): Include facet data in response (default: true)
-     * return_items (bool, optional): Include items in programs/pathways (default: false)
-     * allow_skill_search (bool, optional): Enable skill-based search (default: false)
-     * update_facet (str, optional): Force facet update
-     *
      * Returns:
      * A JSON response containing:
-     * - results: List of content items with metadata
-     * - count: Total number of matching items
-     * - next: URL for the next page of results (if available)
-     * - previous: URL for the previous page of results (if available)
-     * - current_page: Current page number
-     * - total_pages: Total number of pages
-     * - facets: Aggregated counts for each filter category (if requested)
-     *
-     * Each content item contains type-specific fields:
-     * - Courses:
      * {
-         * "id": 123,
-         * "type": "course",
-         * "course_id": "CS101",
-         * "name": "Introduction to Computer Science",
-         * "description": "Learn the fundamentals of computer science",
-         * "short_description": "CS fundamentals",
-         * "image_url": "https://example.com/images/cs101.jpg",
-         * "level": "Beginner",
-         * "subject": "Computer Science",
-         * "topics": ["Programming", "Algorithms"],
-         * "tags": ["python", "coding"],
-         * "language": "English",
-         * "tenant": "example-university",
-         * "self_paced": true,
-         * "duration": "6 weeks",
-         * "certificate": "Professional Certificate",
-         * "price": "Free",
-         * "skills": [
-             * {"id": 1, "name": "Python Programming"},
-             * {"id": 2, "name": "Algorithms"}
-             * ],
-             * "url": "https://example.com/courses/cs101"
-             * }
-             *
-             * - Programs:
+         * "results": [
              * {
-                 * "id": 456,
-                 * "type": "program",
-                 * "program_id": "PROG123",
-                 * "name": "Data Science Program",
-                 * "description": "Comprehensive data science curriculum",
-                 * "short_description": "Learn data science",
-                 * "image_url": "https://example.com/images/datascience.jpg",
-                 * "level": "Intermediate",
-                 * "subject": "Data Science",
-                 * "topics": ["Machine Learning", "Statistics"],
-                 * "program_type": "Professional Certificate",
-                 * "courses": [
-                     * {"id": 123, "name": "Introduction to Python"},
-                     * {"id": 124, "name": "Statistics for Data Science"}
-                     * ],
-                     * "url": "https://example.com/programs/prog123"
+                 * "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"
                      * }
-                     *
-                     * - Pathways:
-                     * {
-                         * "id": 789,
-                         * "type": "pathway",
-                         * "pathway_id": "PATH456",
-                         * "name": "Software Engineering Career Path",
-                         * "description": "Complete pathway to become a software engineer",
-                         * "image_url": "https://example.com/images/swe-path.jpg",
-                         * "programs": [
-                             * {"id": 456, "name": "Programming Fundamentals"},
-                             * {"id": 457, "name": "Web Development"}
+                     * },
+                     * // 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}
                              * ],
-                             * "url": "https://example.com/pathways/path456"
-                             * }
-                             *
-                             * - Skills:
-                             * {
-                                 * "id": 321,
-                                 * "type": "skill",
-                                 * "name": "Machine Learning",
-                                 * "description": "Building systems that learn from data",
-                                 * "courses": [
-                                     * {"id": 125, "name": "Machine Learning Fundamentals"}
-                                     * ],
-                                     * "related_skills": [
-                                         * {"id": 322, "name": "Deep Learning"}
-                                         * ]
-                                         * }
-                                         *
-                                         * - Roles:
-                                         * {
-                                             * "id": 654,
-                                             * "type": "role",
-                                             * "name": "Data Scientist",
-                                             * "description": "Professional who analyzes and interprets complex data",
-                                             * "skills": [
-                                                 * {"id": 321, "name": "Machine Learning"},
-                                                 * {"id": 323, "name": "Data Analysis"}
-                                                 * ],
-                                                 * "recommended_courses": [
-                                                     * {"id": 125, "name": "Machine Learning Fundamentals"}
-                                                     * ]
-                                                     * }
-                                                     *
-                                                     * - Resources:
-                                                     * {
-                                                         * "id": 987,
-                                                         * "type": "resource",
-                                                         * "name": "Python Cheat Sheet",
-                                                         * "description": "Quick reference guide for Python",
-                                                         * "resource_type": "PDF",
-                                                         * "url": "https://example.com/resources/python-cheatsheet.pdf",
-                                                         * "topics": ["Programming", "Python"]
-                                                         * }
-                                                         *
-                                                         * Error Responses:
-                                                         * 500 Internal Server Error: If an unexpected error occurs during processing
-                                                         *
-                                                         * Notes:
-                                                         * - Results are cached for performance
-                                                         * - The 'resources' content type is only included by default if IBL_ENABLE_RESOURCES_IN_FACET is true
-                                                         * - For debugging, add ?debug=true to see detailed information about skill matching
-                                                         * @returns any No response body
-                                                         * @throws ApiError
-                                                         */
-    static searchCatalogRetrieve(): CancelablePromise<any>;
+                             * "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
+                                     */
+    static searchMentorsDocumentsRetrieve(mentorUniqueId: string): CancelablePromise<any>;
+    /**
+     * Get AI mentors for a specific tenant and user
+     * @param org
+     * @param username
+     * @param audience Filter by target audience
+     * @param category Filter by mentor category
+     * @param createdBy Filter mentors created by specific user
+     * @param id Retrieve a specific mentor by ID
+     * @param limit Number of results per page
+     * @param llm Filter by language model type
+     * @param offset Starting position for pagination
+     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
+     * @param orderDirection Sort direction ('asc' or 'desc')
+     * @param query Search term to filter mentors by name or description
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param uniqueId Retrieve a specific mentor by UUID
+     * @returns any
+     * @throws ApiError
+     */
+    static searchOrgsUsersMentorsRetrieve(org: string, username: string, audience?: Array<string>, category?: Array<string>, createdBy?: string, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<Record<string, any>>;
+    /**
+     * 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
+     */
+    static searchOrgsUsersPromptsRetrieve(org: string, username: string): CancelablePromise<any>;
     /**
      * 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 org
      * @param username
      * @returns any No response body
      * @throws ApiError
      */
-    static searchPersonalizedCatalogRetrieve(username: string): CancelablePromise<any>;
+    static searchOrgsUsersRecommendedRetrieve(org: string, username: string): CancelablePromise<any>;
+    /**
+     * Get personalized content for a specific user
+     * @param username
+     * @param allowSkillSearch Enable skill-based search
+     * @param alphabetical Sort alphabetically by name
+     * @param certificate Filter by certificate type
+     * @param content Content types to include in results
+     * @param courseId Retrieve a specific course by ID
+     * @param duration Filter by course duration range
+     * @param language Filter by content language
+     * @param level Filter by difficulty level
+     * @param limit Number of results per page
+     * @param offset Starting position for pagination
+     * @param orderAscending Sort direction
+     * @param orderBy Field to sort results by
+     * @param pathwayId Retrieve a specific pathway by ID
+     * @param price Filter by price/audit status
+     * @param programId Retrieve a specific program by ID
+     * @param programType Filter by program type
+     * @param promotion Filter by promotion status
+     * @param query Search term to filter content by name or description
+     * @param recommended Show only recommended content
+     * @param resourceId Retrieve a specific resource by ID
+     * @param resourceType Filter by resource type
+     * @param returnFacet Include facet data in response
+     * @param returnItems Include items in programs/pathways
+     * @param roleId Retrieve a specific role by ID
+     * @param selfPaced Filter by course format
+     * @param skillId Retrieve a specific skill by ID
+     * @param skills Filter by skills
+     * @param subject Filter by subject areas
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param topics Filter by topic areas
+     * @param updateFacet Force facet update
+     * @returns any
+     * @throws ApiError
+     */
+    static searchPersonalizedCatalogRetrieve(username: string, allowSkillSearch?: boolean, alphabetical?: boolean, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, orderAscending?: boolean, orderBy?: string, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, promotion?: Array<string>, query?: string, recommended?: boolean, resourceId?: string, resourceType?: Array<string>, returnFacet?: boolean, returnItems?: boolean, roleId?: string, selfPaced?: Array<string>, skillId?: string, skills?: Array<string>, subject?: Array<string>, tags?: Array<string>, tenant?: Array<string>, topics?: Array<string>, updateFacet?: string): CancelablePromise<Record<string, any>>;
+    /**
+     * 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
+                                                 */
+    static searchPromptsRetrieve(): CancelablePromise<any>;
     /**
      * Search and filter users within a specific organization/tenant.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iblai/iblai-api",
-  "version": "3.35.0-core",
+  "version": "3.35.1-ai",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
   "type": "module",

package/src/core/OpenAPI.ts

@@ -21,7 +21,7 @@ export type OpenAPIConfig = {
 
 export const OpenAPI: OpenAPIConfig = {
     BASE: 'https://base.manager.iblai.app',
-    VERSION: '3.35.0-core',
+    VERSION: '3.35.1-ai',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
     TOKEN: undefined,