@iblai/iblai-api 0.0.1-core

package/src/services/SearchService.ts

@@ -0,0 +1,550 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { GlobalCatalogSearchResponse } from '../models/GlobalCatalogSearchResponse';
+import type { UserSearchResponse } from '../models/UserSearchResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export 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.
+     *
+     * 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"]
+     *
+     * # 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
+     *
+     * # 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)
+     * 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:
+             * {
+                 * "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"
+                     * }
+                     *
+                     * - 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"}
+                             * ],
+                             * "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
+                                                         * @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 GlobalCatalogSearchResponse
+                                                         * @throws ApiError
+                                                         */
+                                                        public static searchCatalogRetrieve(
+                                                            allowSkillSearch: boolean = false,
+                                                            alphabetical: boolean = false,
+                                                            certificate?: Array<string>,
+                                                            content?: Array<string>,
+                                                            courseId?: string,
+                                                            duration?: Array<string>,
+                                                            language?: Array<string>,
+                                                            level?: Array<string>,
+                                                            limit: number = 12,
+                                                            offset?: number,
+                                                            orderAscending: boolean = false,
+                                                            orderBy?: string,
+                                                            pathwayId?: string,
+                                                            price?: string,
+                                                            programId?: string,
+                                                            programType?: Array<string>,
+                                                            promotion?: Array<string>,
+                                                            query?: string,
+                                                            resourceType?: Array<string>,
+                                                            returnFacet: boolean = true,
+                                                            returnItems: boolean = false,
+                                                            selfPaced?: Array<string>,
+                                                            skillId?: string,
+                                                            skills?: Array<string>,
+                                                            subject?: Array<string>,
+                                                            tags?: Array<string>,
+                                                            tenant?: Array<string>,
+                                                            topics?: Array<string>,
+                                                            updateFacet?: string,
+                                                        ): CancelablePromise<GlobalCatalogSearchResponse> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/search/catalog/',
+                                                                query: {
+                                                                    'allow_skill_search': allowSkillSearch,
+                                                                    'alphabetical': alphabetical,
+                                                                    'certificate': certificate,
+                                                                    'content': content,
+                                                                    'course_id': courseId,
+                                                                    'duration': duration,
+                                                                    'language': language,
+                                                                    'level': level,
+                                                                    'limit': limit,
+                                                                    'offset': offset,
+                                                                    'order_ascending': orderAscending,
+                                                                    'order_by': orderBy,
+                                                                    'pathway_id': pathwayId,
+                                                                    'price': price,
+                                                                    'program_id': programId,
+                                                                    'program_type': programType,
+                                                                    'promotion': promotion,
+                                                                    'query': query,
+                                                                    'resource_type': resourceType,
+                                                                    'return_facet': returnFacet,
+                                                                    'return_items': returnItems,
+                                                                    'self_paced': selfPaced,
+                                                                    'skill_id': skillId,
+                                                                    'skills': skills,
+                                                                    'subject': subject,
+                                                                    'tags': tags,
+                                                                    'tenant': tenant,
+                                                                    'topics': topics,
+                                                                    'update_facet': updateFacet,
+                                                                },
+                                                                errors: {
+                                                                    400: `Bad request`,
+                                                                    500: `Server error`,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * 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
+                                                         * @param allowSkillSearch Enable skill-based search
+                                                         * @param alphabetical Sort alphabetically by name
+                                                         * @param certificate Filter by certificate type
+                                                         * @param content Content types to include in results
+                                                         * @param courseId Retrieve a specific course by ID
+                                                         * @param duration Filter by course duration range
+                                                         * @param language Filter by content language
+                                                         * @param level Filter by difficulty level
+                                                         * @param limit Number of results per page
+                                                         * @param offset Starting position for pagination
+                                                         * @param orderAscending Sort direction
+                                                         * @param orderBy Field to sort results by
+                                                         * @param pathwayId Retrieve a specific pathway by ID
+                                                         * @param price Filter by price/audit status
+                                                         * @param programId Retrieve a specific program by ID
+                                                         * @param programType Filter by program type
+                                                         * @param promotion Filter by promotion status
+                                                         * @param query Search term to filter content by name or description
+                                                         * @param recommended Show only recommended content
+                                                         * @param resourceId Retrieve a specific resource by ID
+                                                         * @param resourceType Filter by resource type
+                                                         * @param returnFacet Include facet data in response
+                                                         * @param returnItems Include items in programs/pathways
+                                                         * @param roleId Retrieve a specific role by ID
+                                                         * @param selfPaced Filter by course format
+                                                         * @param skillId Retrieve a specific skill by ID
+                                                         * @param skills Filter by skills
+                                                         * @param subject Filter by subject areas
+                                                         * @param tags Filter by tags
+                                                         * @param tenant Filter by tenant/organization
+                                                         * @param topics Filter by topic areas
+                                                         * @param updateFacet Force facet update
+                                                         * @returns any
+                                                         * @throws ApiError
+                                                         */
+                                                        public static searchPersonalizedCatalogRetrieve(
+                                                            username: string,
+                                                            allowSkillSearch: boolean = false,
+                                                            alphabetical: boolean = false,
+                                                            certificate?: Array<string>,
+                                                            content?: Array<string>,
+                                                            courseId?: string,
+                                                            duration?: Array<string>,
+                                                            language?: Array<string>,
+                                                            level?: Array<string>,
+                                                            limit: number = 12,
+                                                            offset?: number,
+                                                            orderAscending: boolean = false,
+                                                            orderBy?: string,
+                                                            pathwayId?: string,
+                                                            price?: string,
+                                                            programId?: string,
+                                                            programType?: Array<string>,
+                                                            promotion?: Array<string>,
+                                                            query?: string,
+                                                            recommended: boolean = false,
+                                                            resourceId?: string,
+                                                            resourceType?: Array<string>,
+                                                            returnFacet: boolean = true,
+                                                            returnItems: boolean = false,
+                                                            roleId?: string,
+                                                            selfPaced?: Array<string>,
+                                                            skillId?: string,
+                                                            skills?: Array<string>,
+                                                            subject?: Array<string>,
+                                                            tags?: Array<string>,
+                                                            tenant?: Array<string>,
+                                                            topics?: Array<string>,
+                                                            updateFacet?: string,
+                                                        ): CancelablePromise<Record<string, any>> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/search/personalized-catalog/{username}/',
+                                                                path: {
+                                                                    'username': username,
+                                                                },
+                                                                query: {
+                                                                    'allow_skill_search': allowSkillSearch,
+                                                                    'alphabetical': alphabetical,
+                                                                    'certificate': certificate,
+                                                                    'content': content,
+                                                                    'course_id': courseId,
+                                                                    'duration': duration,
+                                                                    'language': language,
+                                                                    'level': level,
+                                                                    'limit': limit,
+                                                                    'offset': offset,
+                                                                    'order_ascending': orderAscending,
+                                                                    'order_by': orderBy,
+                                                                    'pathway_id': pathwayId,
+                                                                    'price': price,
+                                                                    'program_id': programId,
+                                                                    'program_type': programType,
+                                                                    'promotion': promotion,
+                                                                    'query': query,
+                                                                    'recommended': recommended,
+                                                                    'resource_id': resourceId,
+                                                                    'resource_type': resourceType,
+                                                                    'return_facet': returnFacet,
+                                                                    'return_items': returnItems,
+                                                                    'role_id': roleId,
+                                                                    'self_paced': selfPaced,
+                                                                    'skill_id': skillId,
+                                                                    'skills': skills,
+                                                                    'subject': subject,
+                                                                    'tags': tags,
+                                                                    'tenant': tenant,
+                                                                    'topics': topics,
+                                                                    'update_facet': updateFacet,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Search and filter 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
+                                                                                         * @param department Filter by department names
+                                                                                         * @param educationDegree Filter by degree
+                                                                                         * @param educationFieldOfStudy Filter by field of study
+                                                                                         * @param educationInstitution Filter by institution
+                                                                                         * @param includeMembershipData Include user group membership data in results
+                                                                                         * @param limit Number of results per page
+                                                                                         * @param offset Starting position for pagination
+                                                                                         * @param q Search term to filter users by name, email, or other attributes
+                                                                                         * @param userResumeCompany Filter by company
+                                                                                         * @param userResumeIndustry Filter by industry
+                                                                                         * @param userResumeJobTitle Filter by job title
+                                                                                         * @param userResumeLocation Filter by location
+                                                                                         * @param userResumeSkills Filter by skills
+                                                                                         * @returns UserSearchResponse
+                                                                                         * @throws ApiError
+                                                                                         */
+                                                                                        public static searchUsersOrgsUsersRetrieve(
+                                                                                            org: string,
+                                                                                            username: string,
+                                                                                            department?: Array<string>,
+                                                                                            educationDegree?: string,
+                                                                                            educationFieldOfStudy?: string,
+                                                                                            educationInstitution?: string,
+                                                                                            includeMembershipData: boolean = false,
+                                                                                            limit: number = 10,
+                                                                                            offset?: number,
+                                                                                            q?: string,
+                                                                                            userResumeCompany?: string,
+                                                                                            userResumeIndustry?: string,
+                                                                                            userResumeJobTitle?: string,
+                                                                                            userResumeLocation?: string,
+                                                                                            userResumeSkills?: string,
+                                                                                        ): CancelablePromise<UserSearchResponse> {
+                                                                                            return __request(OpenAPI, {
+                                                                                                method: 'GET',
+                                                                                                url: '/api/search/users/orgs/{org}/users/{username}/',
+                                                                                                path: {
+                                                                                                    'org': org,
+                                                                                                    'username': username,
+                                                                                                },
+                                                                                                query: {
+                                                                                                    'department': department,
+                                                                                                    'education__degree': educationDegree,
+                                                                                                    'education__field_of_study': educationFieldOfStudy,
+                                                                                                    'education__institution': educationInstitution,
+                                                                                                    'include_membership_data': includeMembershipData,
+                                                                                                    'limit': limit,
+                                                                                                    'offset': offset,
+                                                                                                    'q': q,
+                                                                                                    'user_resume__company': userResumeCompany,
+                                                                                                    'user_resume__industry': userResumeIndustry,
+                                                                                                    'user_resume__job_title': userResumeJobTitle,
+                                                                                                    'user_resume__location': userResumeLocation,
+                                                                                                    'user_resume__skills': userResumeSkills,
+                                                                                                },
+                                                                                                errors: {
+                                                                                                    400: `Bad request`,
+                                                                                                    403: `Forbidden`,
+                                                                                                    404: `Not found`,
+                                                                                                    500: `Server error`,
+                                                                                                },
+                                                                                            });
+                                                                                        }
+                                                                                    }