@iblai/iblai-api 3.48.3-ai-plus → 3.48.4-ai

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

@@ -8,26 +8,75 @@ import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class SearchService {
     /**
      * Legacy endpoint for backward compatible mentor search
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param filterFacet If present, return only facets without results
-     * @param id Retrieve a specific mentor by ID
-     * @param limit Number of results per page
-     * @param llm Filter by language model type
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param page Page number (1-based, used with page_size)
-     * @param pageSize Number of results per page
-     * @param query Search term to filter mentors by name or description
-     * @param tags Filter by tags
-     * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
      * @returns MentorSearchResponse
      * @throws ApiError
      */
-    static searchAiSearchRetrieve(audience?: Array<string>, category?: Array<string>, createdBy?: string, filterFacet?: boolean, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, page?: number, pageSize?: number, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<MentorSearchResponse>;
+    static searchAiSearchRetrieve({ audience, category, createdBy, filterFacet, id, limit, llm, offset, orderBy, orderDirection, page, pageSize, query, tags, tenant, uniqueId, }: {
+        /**
+         * Filter by target audience
+         */
+        audience?: Array<string>;
+        /**
+         * Filter by mentor category
+         */
+        category?: Array<string>;
+        /**
+         * Filter mentors created by specific user
+         */
+        createdBy?: string;
+        /**
+         * If present, return only facets without results
+         */
+        filterFacet?: boolean;
+        /**
+         * Retrieve a specific mentor by ID
+         */
+        id?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by language model type
+         */
+        llm?: Array<string>;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * Field to sort results by ('created_at', 'recently_accessed_at')
+         */
+        orderBy?: string;
+        /**
+         * Sort direction ('asc' or 'desc')
+         */
+        orderDirection?: string;
+        /**
+         * Page number (1-based, used with page_size)
+         */
+        page?: number;
+        /**
+         * Number of results per page
+         */
+        pageSize?: number;
+        /**
+         * Search term to filter mentors by name or description
+         */
+        query?: string;
+        /**
+         * Filter by tags
+         */
+        tags?: Array<string>;
+        /**
+         * Filter by tenant/organization
+         */
+        tenant?: string;
+        /**
+         * Retrieve a specific mentor by UUID
+         */
+        uniqueId?: string;
+    }): CancelablePromise<MentorSearchResponse>;
     /**
      * Search and filter content across the learning catalog.
      *
@@ -193,39 +242,127 @@ export declare 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
                                                          */
-    static searchCatalogRetrieve(allowSkillSearch?: boolean, alphabetical?: boolean, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, orderAscending?: boolean, orderBy?: string, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, promotion?: Array<string>, query?: string, resourceType?: Array<string>, returnFacet?: boolean, returnItems?: boolean, selfPaced?: Array<string>, skillId?: string, skills?: Array<string>, subject?: Array<string>, tags?: Array<string>, tenant?: Array<string>, topics?: Array<string>, updateFacet?: string): CancelablePromise<GlobalCatalogSearchResponse>;
+    static searchCatalogRetrieve({ allowSkillSearch, alphabetical, certificate, content, courseId, duration, language, level, limit, offset, orderAscending, orderBy, pathwayId, price, programId, programType, promotion, query, resourceType, returnFacet, returnItems, 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>;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * 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>;
+        /**
+         * 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>;
     /**
      * Search and filter AI mentors across the platform.
      *
@@ -338,40 +475,111 @@ export declare class SearchService {
                                                      * - Results are cached for performance
                                                      * - Public mentors are visible to all users
                                                      * - Private mentors are only visible to authorized users
-                                                     * @param audience Filter by target audience
-                                                     * @param category Filter by mentor category
-                                                     * @param createdBy Filter mentors created by specific user
-                                                     * @param featured Filter by featured status
-                                                     * @param id Retrieve a specific mentor by ID
-                                                     * @param limit Number of results per page
-                                                     * @param llm Filter by language model type
-                                                     * @param offset Starting position for pagination
-                                                     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-                                                     * @param orderDirection Sort direction ('asc' or 'desc')
-                                                     * @param query Search term to filter mentors by name or description
-                                                     * @param tags Filter by tags
-                                                     * @param tenant Filter by tenant/organization
-                                                     * @param uniqueId Retrieve a specific mentor by UUID
                                                      * @returns MentorSearchResponse
                                                      * @throws ApiError
                                                      */
-    static searchMentorsRetrieve(audience?: Array<string>, category?: Array<string>, createdBy?: string, featured?: boolean, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<MentorSearchResponse>;
+    static searchMentorsRetrieve({ audience, category, createdBy, featured, id, limit, llm, offset, orderBy, orderDirection, query, tags, tenant, uniqueId, }: {
+        /**
+         * Filter by target audience
+         */
+        audience?: Array<string>;
+        /**
+         * Filter by mentor category
+         */
+        category?: Array<string>;
+        /**
+         * Filter mentors created by specific user
+         */
+        createdBy?: string;
+        /**
+         * Filter by featured status
+         */
+        featured?: boolean;
+        /**
+         * Retrieve a specific mentor by ID
+         */
+        id?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by language model type
+         */
+        llm?: Array<string>;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * Field to sort results by ('created_at', 'recently_accessed_at')
+         */
+        orderBy?: string;
+        /**
+         * Sort direction ('asc' or 'desc')
+         */
+        orderDirection?: string;
+        /**
+         * Search term to filter mentors by name or description
+         */
+        query?: string;
+        /**
+         * Filter by tags
+         */
+        tags?: Array<string>;
+        /**
+         * Filter by tenant/organization
+         */
+        tenant?: string;
+        /**
+         * Retrieve a specific mentor by UUID
+         */
+        uniqueId?: string;
+    }): CancelablePromise<MentorSearchResponse>;
     /**
      * Search and filter documents associated with a specific mentor
-     * @param mentorUniqueId
-     * @param access Filter by access level (e.g., 'public', 'private')
-     * @param documentType Filter by document type (e.g., 'pdf', 'text')
-     * @param limit Number of results per page
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('date_created', 'last_modified', 'document_name')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param platformKey Filter by platform key
-     * @param query Search term to filter documents by name or content
-     * @param trainingStatus Filter by training status (e.g., 'trained', 'pending')
      * @returns DocumentSearchResponse
      * @throws ApiError
      */
-    static searchMentorsDocumentsRetrieve(mentorUniqueId: string, access?: string, documentType?: string, limit?: number, offset?: number, orderBy?: string, orderDirection?: string, platformKey?: string, query?: string, trainingStatus?: string): CancelablePromise<DocumentSearchResponse>;
+    static searchMentorsDocumentsRetrieve({ mentorUniqueId, access, documentType, limit, offset, orderBy, orderDirection, platformKey, query, trainingStatus, }: {
+        mentorUniqueId: string;
+        /**
+         * Filter by access level (e.g., 'public', 'private')
+         */
+        access?: string;
+        /**
+         * Filter by document type (e.g., 'pdf', 'text')
+         */
+        documentType?: string;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * Field to sort results by ('date_created', 'last_modified', 'document_name')
+         */
+        orderBy?: string;
+        /**
+         * Sort direction ('asc' or 'desc')
+         */
+        orderDirection?: string;
+        /**
+         * Filter by platform key
+         */
+        platformKey?: string;
+        /**
+         * Search term to filter documents by name or content
+         */
+        query?: string;
+        /**
+         * Filter by training status (e.g., 'trained', 'pending')
+         */
+        trainingStatus?: string;
+    }): CancelablePromise<DocumentSearchResponse>;
     /**
      * Handle GET requests for tenant-specific mentor search.
      *
@@ -382,26 +590,69 @@ export declare class SearchService {
      *
      * Returns:
      * Response: DRF Response object with search results
-     * @param org
-     * @param username
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param featured Filter by featured status
-     * @param id Retrieve a specific mentor by ID
-     * @param limit Number of results per page
-     * @param llm Filter by language model type
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param query Search term to filter mentors by name or description
-     * @param tags Filter by tags
-     * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
      * @returns MentorSearchResponse
      * @throws ApiError
      */
-    static searchOrgsUsersMentorsRetrieve(org: string, username: string, audience?: Array<string>, category?: Array<string>, createdBy?: string, featured?: boolean, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<MentorSearchResponse>;
+    static searchOrgsUsersMentorsRetrieve({ org, username, audience, category, createdBy, featured, id, limit, llm, offset, orderBy, orderDirection, query, tags, tenant, uniqueId, }: {
+        org: string;
+        username: string;
+        /**
+         * Filter by target audience
+         */
+        audience?: Array<string>;
+        /**
+         * Filter by mentor category
+         */
+        category?: Array<string>;
+        /**
+         * Filter mentors created by specific user
+         */
+        createdBy?: string;
+        /**
+         * Filter by featured status
+         */
+        featured?: boolean;
+        /**
+         * Retrieve a specific mentor by ID
+         */
+        id?: number;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by language model type
+         */
+        llm?: Array<string>;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * Field to sort results by ('created_at', 'recently_accessed_at')
+         */
+        orderBy?: string;
+        /**
+         * Sort direction ('asc' or 'desc')
+         */
+        orderDirection?: string;
+        /**
+         * Search term to filter mentors by name or description
+         */
+        query?: string;
+        /**
+         * Filter by tags
+         */
+        tags?: Array<string>;
+        /**
+         * Filter by tenant/organization
+         */
+        tenant?: string;
+        /**
+         * Retrieve a specific mentor by UUID
+         */
+        uniqueId?: string;
+    }): CancelablePromise<MentorSearchResponse>;
     /**
      * Search and filter AI prompts for a specific user within a tenant.
      *
@@ -432,96 +683,300 @@ export declare class SearchService {
      * Access Control:
      * - Results are filtered based on user's permissions within the organization
      * - Private prompts are only visible to authorized users
-     * @param org
-     * @param username
-     * @param alphabetical Sort alphabetically
-     * @param category Filter by prompt category
-     * @param filterFacet If true, return only facets without results
-     * @param language Filter by prompt language
-     * @param limit Number of results per page
-     * @param mentor Filter by mentor UUID
-     * @param offset Starting position for pagination
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param query Search term to filter prompts by name or content
-     * @param sortBy Field to sort results by
-     * @param style Filter by prompt style
-     * @param tenant Filter by tenant/organization
-     * @param tone Filter by prompt tone
      * @returns PromptSearchResponse
      * @throws ApiError
      */
-    static searchOrgsUsersPromptsRetrieve(org: string, username: string, alphabetical?: boolean, category?: string, filterFacet?: boolean, language?: string, limit?: number, mentor?: string, offset?: number, orderDirection?: string, query?: string, sortBy?: string, style?: string, tenant?: string, tone?: string): CancelablePromise<PromptSearchResponse>;
+    static searchOrgsUsersPromptsRetrieve({ org, username, alphabetical, category, filterFacet, language, limit, mentor, offset, orderDirection, query, sortBy, style, tenant, tone, }: {
+        org: string;
+        username: string;
+        /**
+         * Sort alphabetically
+         */
+        alphabetical?: boolean;
+        /**
+         * Filter by prompt category
+         */
+        category?: string;
+        /**
+         * If true, return only facets without results
+         */
+        filterFacet?: boolean;
+        /**
+         * Filter by prompt language
+         */
+        language?: string;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by mentor UUID
+         */
+        mentor?: string;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * Sort direction ('asc' or 'desc')
+         */
+        orderDirection?: string;
+        /**
+         * Search term to filter prompts by name or content
+         */
+        query?: string;
+        /**
+         * Field to sort results by
+         */
+        sortBy?: string;
+        /**
+         * Filter by prompt style
+         */
+        style?: string;
+        /**
+         * Filter by tenant/organization
+         */
+        tenant?: string;
+        /**
+         * Filter by prompt tone
+         */
+        tone?: string;
+    }): CancelablePromise<PromptSearchResponse>;
     /**
      * Determine whether to serve a detail view or a list view.
-     * @param org
-     * @param username
-     * @param certificate Filter by certificate type
-     * @param content Content types to include in recommendations (courses, programs, pathways, skills, roles, resources)
-     * @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 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 query Search term to filter content by name or description
-     * @param resourceId Retrieve a specific resource by ID
-     * @param resourceType Filter by resource type
-     * @param roleId Retrieve a specific role by ID
-     * @param selfPaced Filter by course format (self-paced, instructor-led)
-     * @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 topics Filter by topic areas
      * @returns RecommendedCoursesResponse
      * @throws ApiError
      */
-    static searchOrgsUsersRecommendedRetrieve(org: string, username: string, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, query?: string, resourceId?: string, resourceType?: Array<string>, roleId?: string, selfPaced?: Array<string>, skillId?: string, skills?: Array<string>, subject?: Array<string>, tags?: Array<string>, topics?: Array<string>): CancelablePromise<RecommendedCoursesResponse>;
+    static searchOrgsUsersRecommendedRetrieve({ org, username, certificate, content, courseId, duration, language, level, limit, offset, pathwayId, price, programId, programType, query, resourceId, resourceType, roleId, selfPaced, skillId, skills, subject, tags, topics, }: {
+        org: string;
+        username: string;
+        /**
+         * Filter by certificate type
+         */
+        certificate?: Array<string>;
+        /**
+         * Content types to include in recommendations (courses, programs, pathways, skills, roles, resources)
+         */
+        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>;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * 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>;
+        /**
+         * Search term to filter content by name or description
+         */
+        query?: string;
+        /**
+         * Retrieve a specific resource by ID
+         */
+        resourceId?: string;
+        /**
+         * Filter by resource type
+         */
+        resourceType?: Array<string>;
+        /**
+         * Retrieve a specific role by ID
+         */
+        roleId?: string;
+        /**
+         * Filter by course format (self-paced, instructor-led)
+         */
+        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 topic areas
+         */
+        topics?: Array<string>;
+    }): CancelablePromise<RecommendedCoursesResponse>;
     /**
      * 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
      */
-    static searchPersonalizedCatalogRetrieve(username: string, allowSkillSearch?: boolean, alphabetical?: boolean, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, orderAscending?: boolean, orderBy?: string, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, promotion?: Array<string>, query?: string, recommended?: boolean, resourceId?: string, resourceType?: Array<string>, returnFacet?: boolean, returnItems?: boolean, roleId?: string, selfPaced?: Array<string>, skillId?: string, skills?: Array<string>, subject?: Array<string>, tags?: Array<string>, tenant?: Array<string>, topics?: Array<string>, updateFacet?: string): CancelablePromise<Record<string, any>>;
+    static searchPersonalizedCatalogRetrieve({ username, allowSkillSearch, alphabetical, certificate, content, courseId, duration, language, level, limit, offset, orderAscending, orderBy, pathwayId, price, programId, programType, promotion, query, recommended, resourceId, resourceType, returnFacet, returnItems, roleId, selfPaced, skillId, skills, subject, tags, tenant, topics, updateFacet, }: {
+        username: string;
+        /**
+         * 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>;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * 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;
+        /**
+         * Show only recommended content
+         */
+        recommended?: boolean;
+        /**
+         * Retrieve a specific resource by ID
+         */
+        resourceId?: string;
+        /**
+         * Filter by resource type
+         */
+        resourceType?: Array<string>;
+        /**
+         * 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>>;
     /**
      * Search and filter AI prompts across the platform.
      *
@@ -632,23 +1087,63 @@ export declare class SearchService {
                                                  * Notes:
                                                  * - Only publicly available prompts are returned by default
                                                  * - When filtering by mentor, the mentor ID must be a valid UUID
-                                                 * @param alphabetical Sort alphabetically
-                                                 * @param category Filter by prompt category
-                                                 * @param filterFacet If true, return only facets without results
-                                                 * @param language Filter by prompt language
-                                                 * @param limit Number of results per page
-                                                 * @param mentor Filter by mentor UUID
-                                                 * @param offset Starting position for pagination
-                                                 * @param orderDirection Sort direction ('asc' or 'desc')
-                                                 * @param query Search term to filter prompts by name or content
-                                                 * @param sortBy Field to sort results by
-                                                 * @param style Filter by prompt style
-                                                 * @param tenant Filter by tenant/organization
-                                                 * @param tone Filter by prompt tone
                                                  * @returns PromptSearchResponse
                                                  * @throws ApiError
                                                  */
-    static searchPromptsRetrieve(alphabetical?: boolean, category?: string, filterFacet?: boolean, language?: string, limit?: number, mentor?: string, offset?: number, orderDirection?: string, query?: string, sortBy?: string, style?: string, tenant?: string, tone?: string): CancelablePromise<PromptSearchResponse>;
+    static searchPromptsRetrieve({ alphabetical, category, filterFacet, language, limit, mentor, offset, orderDirection, query, sortBy, style, tenant, tone, }: {
+        /**
+         * Sort alphabetically
+         */
+        alphabetical?: boolean;
+        /**
+         * Filter by prompt category
+         */
+        category?: string;
+        /**
+         * If true, return only facets without results
+         */
+        filterFacet?: boolean;
+        /**
+         * Filter by prompt language
+         */
+        language?: string;
+        /**
+         * Number of results per page
+         */
+        limit?: number;
+        /**
+         * Filter by mentor UUID
+         */
+        mentor?: string;
+        /**
+         * Starting position for pagination
+         */
+        offset?: number;
+        /**
+         * Sort direction ('asc' or 'desc')
+         */
+        orderDirection?: string;
+        /**
+         * Search term to filter prompts by name or content
+         */
+        query?: string;
+        /**
+         * Field to sort results by
+         */
+        sortBy?: string;
+        /**
+         * Filter by prompt style
+         */
+        style?: string;
+        /**
+         * Filter by tenant/organization
+         */
+        tenant?: string;
+        /**
+         * Filter by prompt tone
+         */
+        tone?: string;
+    }): CancelablePromise<PromptSearchResponse>;
     /**
      * Search and filter users within a specific organization/tenant.
      *
@@ -738,23 +1233,63 @@ export declare 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
                                      */
-    static searchUsersOrgsUsersRetrieve(org: string, username: string, department?: Array<string>, educationDegree?: string, educationFieldOfStudy?: string, educationInstitution?: string, includeMembershipData?: boolean, limit?: number, offset?: number, q?: string, userResumeCompany?: string, userResumeIndustry?: string, userResumeJobTitle?: string, userResumeLocation?: string, userResumeSkills?: string): CancelablePromise<UserSearchResponse>;
+    static searchUsersOrgsUsersRetrieve({ org, username, department, educationDegree, educationFieldOfStudy, educationInstitution, includeMembershipData, limit, 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;
+        /**
+         * 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>;
 }