@iblai/iblai-api 3.48.3-core → 3.48.4-core

package/src/services/SearchService.ts

@@ -173,69 +173,157 @@ export class SearchService {
                                                          * - 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,
+                                                        public static searchCatalogRetrieve({
+                                                            allowSkillSearch = false,
+                                                            alphabetical = false,
+                                                            certificate,
+                                                            content,
+                                                            courseId,
+                                                            duration,
+                                                            language,
+                                                            level,
+                                                            limit = 12,
+                                                            offset,
+                                                            orderAscending = false,
+                                                            orderBy,
+                                                            pathwayId,
+                                                            price,
+                                                            programId,
+                                                            programType,
+                                                            promotion,
+                                                            query,
+                                                            resourceType,
+                                                            returnFacet = true,
+                                                            returnItems = false,
+                                                            selfPaced,
+                                                            skillId,
+                                                            skills,
+                                                            subject,
+                                                            tags,
+                                                            tenant,
+                                                            topics,
+                                                            updateFacet,
+                                                        }: {
+                                                            /**
+                                                             * Enable skill-based search
+                                                             */
+                                                            allowSkillSearch?: boolean,
+                                                            /**
+                                                             * Sort alphabetically by name
+                                                             */
+                                                            alphabetical?: boolean,
+                                                            /**
+                                                             * Filter by certificate type
+                                                             */
                                                             certificate?: Array<string>,
+                                                            /**
+                                                             * Content types to include in results
+                                                             */
                                                             content?: Array<string>,
+                                                            /**
+                                                             * Filter by specific course ID
+                                                             */
                                                             courseId?: string,
+                                                            /**
+                                                             * Filter by course duration range
+                                                             */
                                                             duration?: Array<string>,
+                                                            /**
+                                                             * Filter by content language
+                                                             */
                                                             language?: Array<string>,
+                                                            /**
+                                                             * Filter by difficulty level
+                                                             */
                                                             level?: Array<string>,
-                                                            limit: number = 12,
+                                                            /**
+                                                             * Number of results per page
+                                                             */
+                                                            limit?: number,
+                                                            /**
+                                                             * Starting position for pagination
+                                                             */
                                                             offset?: number,
-                                                            orderAscending: boolean = false,
+                                                            /**
+                                                             * Sort direction
+                                                             */
+                                                            orderAscending?: boolean,
+                                                            /**
+                                                             * Field to sort results by
+                                                             */
                                                             orderBy?: string,
+                                                            /**
+                                                             * Filter by specific pathway ID
+                                                             */
                                                             pathwayId?: string,
+                                                            /**
+                                                             * Filter by price/audit status
+                                                             */
                                                             price?: string,
+                                                            /**
+                                                             * Filter by specific program ID
+                                                             */
                                                             programId?: string,
+                                                            /**
+                                                             * Filter by program type
+                                                             */
                                                             programType?: Array<string>,
+                                                            /**
+                                                             * Filter by promotion status
+                                                             */
                                                             promotion?: Array<string>,
+                                                            /**
+                                                             * Search term to filter content by name or description
+                                                             */
                                                             query?: string,
+                                                            /**
+                                                             * Filter by resource type
+                                                             */
                                                             resourceType?: Array<string>,
-                                                            returnFacet: boolean = true,
-                                                            returnItems: boolean = false,
+                                                            /**
+                                                             * Include facet data in response
+                                                             */
+                                                            returnFacet?: boolean,
+                                                            /**
+                                                             * Include items in programs/pathways
+                                                             */
+                                                            returnItems?: boolean,
+                                                            /**
+                                                             * Filter by course format
+                                                             */
                                                             selfPaced?: Array<string>,
+                                                            /**
+                                                             * Filter by specific skill ID
+                                                             */
                                                             skillId?: string,
+                                                            /**
+                                                             * Filter by skills
+                                                             */
                                                             skills?: Array<string>,
+                                                            /**
+                                                             * Filter by subject areas
+                                                             */
                                                             subject?: Array<string>,
+                                                            /**
+                                                             * Filter by tags
+                                                             */
                                                             tags?: Array<string>,
+                                                            /**
+                                                             * Filter by tenant/organization
+                                                             */
                                                             tenant?: Array<string>,
+                                                            /**
+                                                             * Filter by topic areas
+                                                             */
                                                             topics?: Array<string>,
+                                                            /**
+                                                             * Force facet update
+                                                             */
                                                             updateFacet?: string,
-                                                        ): CancelablePromise<GlobalCatalogSearchResponse> {
+                                                        }): CancelablePromise<GlobalCatalogSearchResponse> {
                                                             return __request(OpenAPI, {
                                                                 method: 'GET',
                                                                 url: '/api/search/catalog/',
@@ -280,77 +368,174 @@ export class SearchService {
                                                          * 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(
+                                                        public static searchPersonalizedCatalogRetrieve({
+                                                            username,
+                                                            allowSkillSearch = false,
+                                                            alphabetical = false,
+                                                            certificate,
+                                                            content,
+                                                            courseId,
+                                                            duration,
+                                                            language,
+                                                            level,
+                                                            limit = 12,
+                                                            offset,
+                                                            orderAscending = false,
+                                                            orderBy,
+                                                            pathwayId,
+                                                            price,
+                                                            programId,
+                                                            programType,
+                                                            promotion,
+                                                            query,
+                                                            recommended = false,
+                                                            resourceId,
+                                                            resourceType,
+                                                            returnFacet = true,
+                                                            returnItems = false,
+                                                            roleId,
+                                                            selfPaced,
+                                                            skillId,
+                                                            skills,
+                                                            subject,
+                                                            tags,
+                                                            tenant,
+                                                            topics,
+                                                            updateFacet,
+                                                        }: {
                                                             username: string,
-                                                            allowSkillSearch: boolean = false,
-                                                            alphabetical: boolean = false,
+                                                            /**
+                                                             * Enable skill-based search
+                                                             */
+                                                            allowSkillSearch?: boolean,
+                                                            /**
+                                                             * Sort alphabetically by name
+                                                             */
+                                                            alphabetical?: boolean,
+                                                            /**
+                                                             * Filter by certificate type
+                                                             */
                                                             certificate?: Array<string>,
+                                                            /**
+                                                             * Content types to include in results
+                                                             */
                                                             content?: Array<string>,
+                                                            /**
+                                                             * Retrieve a specific course by ID
+                                                             */
                                                             courseId?: string,
+                                                            /**
+                                                             * Filter by course duration range
+                                                             */
                                                             duration?: Array<string>,
+                                                            /**
+                                                             * Filter by content language
+                                                             */
                                                             language?: Array<string>,
+                                                            /**
+                                                             * Filter by difficulty level
+                                                             */
                                                             level?: Array<string>,
-                                                            limit: number = 12,
+                                                            /**
+                                                             * Number of results per page
+                                                             */
+                                                            limit?: number,
+                                                            /**
+                                                             * Starting position for pagination
+                                                             */
                                                             offset?: number,
-                                                            orderAscending: boolean = false,
+                                                            /**
+                                                             * Sort direction
+                                                             */
+                                                            orderAscending?: boolean,
+                                                            /**
+                                                             * Field to sort results by
+                                                             */
                                                             orderBy?: string,
+                                                            /**
+                                                             * Retrieve a specific pathway by ID
+                                                             */
                                                             pathwayId?: string,
+                                                            /**
+                                                             * Filter by price/audit status
+                                                             */
                                                             price?: string,
+                                                            /**
+                                                             * Retrieve a specific program by ID
+                                                             */
                                                             programId?: string,
+                                                            /**
+                                                             * Filter by program type
+                                                             */
                                                             programType?: Array<string>,
+                                                            /**
+                                                             * Filter by promotion status
+                                                             */
                                                             promotion?: Array<string>,
+                                                            /**
+                                                             * Search term to filter content by name or description
+                                                             */
                                                             query?: string,
-                                                            recommended: boolean = false,
+                                                            /**
+                                                             * Show only recommended content
+                                                             */
+                                                            recommended?: boolean,
+                                                            /**
+                                                             * Retrieve a specific resource by ID
+                                                             */
                                                             resourceId?: string,
+                                                            /**
+                                                             * Filter by resource type
+                                                             */
                                                             resourceType?: Array<string>,
-                                                            returnFacet: boolean = true,
-                                                            returnItems: boolean = false,
+                                                            /**
+                                                             * Include facet data in response
+                                                             */
+                                                            returnFacet?: boolean,
+                                                            /**
+                                                             * Include items in programs/pathways
+                                                             */
+                                                            returnItems?: boolean,
+                                                            /**
+                                                             * Retrieve a specific role by ID
+                                                             */
                                                             roleId?: string,
+                                                            /**
+                                                             * Filter by course format
+                                                             */
                                                             selfPaced?: Array<string>,
+                                                            /**
+                                                             * Retrieve a specific skill by ID
+                                                             */
                                                             skillId?: string,
+                                                            /**
+                                                             * Filter by skills
+                                                             */
                                                             skills?: Array<string>,
+                                                            /**
+                                                             * Filter by subject areas
+                                                             */
                                                             subject?: Array<string>,
+                                                            /**
+                                                             * Filter by tags
+                                                             */
                                                             tags?: Array<string>,
+                                                            /**
+                                                             * Filter by tenant/organization
+                                                             */
                                                             tenant?: Array<string>,
+                                                            /**
+                                                             * Filter by topic areas
+                                                             */
                                                             topics?: Array<string>,
+                                                            /**
+                                                             * Force facet update
+                                                             */
                                                             updateFacet?: string,
-                                                        ): CancelablePromise<Record<string, any>> {
+                                                        }): CancelablePromise<Record<string, any>> {
                                                             return __request(OpenAPI, {
                                                                 method: 'GET',
                                                                 url: '/api/search/personalized-catalog/{username}/',
@@ -482,41 +667,81 @@ export class SearchService {
                                                                                          * - 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(
+                                                                                        public static searchUsersOrgsUsersRetrieve({
+                                                                                            org,
+                                                                                            username,
+                                                                                            department,
+                                                                                            educationDegree,
+                                                                                            educationFieldOfStudy,
+                                                                                            educationInstitution,
+                                                                                            includeMembershipData = false,
+                                                                                            limit = 10,
+                                                                                            offset,
+                                                                                            q,
+                                                                                            userResumeCompany,
+                                                                                            userResumeIndustry,
+                                                                                            userResumeJobTitle,
+                                                                                            userResumeLocation,
+                                                                                            userResumeSkills,
+                                                                                        }: {
                                                                                             org: string,
                                                                                             username: string,
+                                                                                            /**
+                                                                                             * Filter by department names
+                                                                                             */
                                                                                             department?: Array<string>,
+                                                                                            /**
+                                                                                             * Filter by degree
+                                                                                             */
                                                                                             educationDegree?: string,
+                                                                                            /**
+                                                                                             * Filter by field of study
+                                                                                             */
                                                                                             educationFieldOfStudy?: string,
+                                                                                            /**
+                                                                                             * Filter by institution
+                                                                                             */
                                                                                             educationInstitution?: string,
-                                                                                            includeMembershipData: boolean = false,
-                                                                                            limit: number = 10,
+                                                                                            /**
+                                                                                             * Include user group membership data in results
+                                                                                             */
+                                                                                            includeMembershipData?: boolean,
+                                                                                            /**
+                                                                                             * Number of results per page
+                                                                                             */
+                                                                                            limit?: number,
+                                                                                            /**
+                                                                                             * Starting position for pagination
+                                                                                             */
                                                                                             offset?: number,
+                                                                                            /**
+                                                                                             * Search term to filter users by name, email, or other attributes
+                                                                                             */
                                                                                             q?: string,
+                                                                                            /**
+                                                                                             * Filter by company
+                                                                                             */
                                                                                             userResumeCompany?: string,
+                                                                                            /**
+                                                                                             * Filter by industry
+                                                                                             */
                                                                                             userResumeIndustry?: string,
+                                                                                            /**
+                                                                                             * Filter by job title
+                                                                                             */
                                                                                             userResumeJobTitle?: string,
+                                                                                            /**
+                                                                                             * Filter by location
+                                                                                             */
                                                                                             userResumeLocation?: string,
+                                                                                            /**
+                                                                                             * Filter by skills
+                                                                                             */
                                                                                             userResumeSkills?: string,
-                                                                                        ): CancelablePromise<UserSearchResponse> {
+                                                                                        }): CancelablePromise<UserSearchResponse> {
                                                                                             return __request(OpenAPI, {
                                                                                                 method: 'GET',
                                                                                                 url: '/api/search/users/orgs/{org}/users/{username}/',