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

package/src/services/SearchService.ts

@@ -14,43 +14,92 @@ import { request as __request } from '../core/request';
 export 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
      */
-    public static searchAiSearchRetrieve(
+    public static searchAiSearchRetrieve({
+        audience,
+        category,
+        createdBy,
+        filterFacet = false,
+        id,
+        limit = 12,
+        llm,
+        offset,
+        orderBy,
+        orderDirection = 'desc',
+        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,
-        filterFacet: boolean = false,
+        /**
+         * If present, return only facets without results
+         */
+        filterFacet?: boolean,
+        /**
+         * Retrieve a specific mentor by ID
+         */
         id?: number,
-        limit: number = 12,
+        /**
+         * 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,
-        orderDirection: string = 'desc',
+        /**
+         * 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> {
+    }): CancelablePromise<MentorSearchResponse> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/search/ai-search/',
@@ -243,69 +292,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/',
@@ -458,39 +595,82 @@ export 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
                                                                                                          */
-                                                                                                        public static searchMentorsRetrieve(
+                                                                                                        public static searchMentorsRetrieve({
+                                                                                                            audience,
+                                                                                                            category,
+                                                                                                            createdBy,
+                                                                                                            featured,
+                                                                                                            id,
+                                                                                                            limit = 12,
+                                                                                                            llm,
+                                                                                                            offset,
+                                                                                                            orderBy,
+                                                                                                            orderDirection = 'desc',
+                                                                                                            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,
-                                                                                                            limit: number = 12,
+                                                                                                            /**
+                                                                                                             * 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,
-                                                                                                            orderDirection: string = 'desc',
+                                                                                                            /**
+                                                                                                             * 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> {
+                                                                                                        }): CancelablePromise<MentorSearchResponse> {
                                                                                                             return __request(OpenAPI, {
                                                                                                                 method: 'GET',
                                                                                                                 url: '/api/search/mentors/',
@@ -518,31 +698,59 @@ export class SearchService {
                                                                                                         }
                                                                                                         /**
                                                                                                          * 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
                                                                                                          */
-                                                                                                        public static searchMentorsDocumentsRetrieve(
+                                                                                                        public static searchMentorsDocumentsRetrieve({
+                                                                                                            mentorUniqueId,
+                                                                                                            access,
+                                                                                                            documentType,
+                                                                                                            limit = 12,
+                                                                                                            offset,
+                                                                                                            orderBy,
+                                                                                                            orderDirection = 'desc',
+                                                                                                            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,
-                                                                                                            limit: number = 12,
+                                                                                                            /**
+                                                                                                             * 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,
-                                                                                                            orderDirection: string = 'desc',
+                                                                                                            /**
+                                                                                                             * 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> {
+                                                                                                        }): CancelablePromise<DocumentSearchResponse> {
                                                                                                             return __request(OpenAPI, {
                                                                                                                 method: 'GET',
                                                                                                                 url: '/api/search/mentors/{mentor_unique_id}/documents/',
@@ -577,43 +785,86 @@ export 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
                                                                                                          */
-                                                                                                        public static searchOrgsUsersMentorsRetrieve(
+                                                                                                        public static searchOrgsUsersMentorsRetrieve({
+                                                                                                            org,
+                                                                                                            username,
+                                                                                                            audience,
+                                                                                                            category,
+                                                                                                            createdBy,
+                                                                                                            featured,
+                                                                                                            id,
+                                                                                                            limit = 12,
+                                                                                                            llm,
+                                                                                                            offset,
+                                                                                                            orderBy,
+                                                                                                            orderDirection = 'desc',
+                                                                                                            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,
-                                                                                                            limit: number = 12,
+                                                                                                            /**
+                                                                                                             * 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,
-                                                                                                            orderDirection: string = 'desc',
+                                                                                                            /**
+                                                                                                             * 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> {
+                                                                                                        }): CancelablePromise<MentorSearchResponse> {
                                                                                                             return __request(OpenAPI, {
                                                                                                                 method: 'GET',
                                                                                                                 url: '/api/search/orgs/{org}/users/{username}/mentors/',
@@ -673,41 +924,81 @@ export 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
                                                                                                          */
-                                                                                                        public static searchOrgsUsersPromptsRetrieve(
+                                                                                                        public static searchOrgsUsersPromptsRetrieve({
+                                                                                                            org,
+                                                                                                            username,
+                                                                                                            alphabetical = false,
+                                                                                                            category,
+                                                                                                            filterFacet,
+                                                                                                            language,
+                                                                                                            limit = 10,
+                                                                                                            mentor,
+                                                                                                            offset,
+                                                                                                            orderDirection = 'desc',
+                                                                                                            query,
+                                                                                                            sortBy,
+                                                                                                            style,
+                                                                                                            tenant,
+                                                                                                            tone,
+                                                                                                        }: {
                                                                                                             org: string,
                                                                                                             username: string,
-                                                                                                            alphabetical: boolean = false,
+                                                                                                            /**
+                                                                                                             * 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,
-                                                                                                            limit: number = 10,
+                                                                                                            /**
+                                                                                                             * Number of results per page
+                                                                                                             */
+                                                                                                            limit?: number,
+                                                                                                            /**
+                                                                                                             * Filter by mentor UUID
+                                                                                                             */
                                                                                                             mentor?: string,
+                                                                                                            /**
+                                                                                                             * Starting position for pagination
+                                                                                                             */
                                                                                                             offset?: number,
-                                                                                                            orderDirection: string = 'desc',
+                                                                                                            /**
+                                                                                                             * 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> {
+                                                                                                        }): CancelablePromise<PromptSearchResponse> {
                                                                                                             return __request(OpenAPI, {
                                                                                                                 method: 'GET',
                                                                                                                 url: '/api/search/orgs/{org}/users/{username}/prompts/',
@@ -740,59 +1031,126 @@ export class SearchService {
                                                                                                         }
                                                                                                         /**
                                                                                                          * 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
                                                                                                          */
-                                                                                                        public static searchOrgsUsersRecommendedRetrieve(
+                                                                                                        public static searchOrgsUsersRecommendedRetrieve({
+                                                                                                            org,
+                                                                                                            username,
+                                                                                                            certificate,
+                                                                                                            content,
+                                                                                                            courseId,
+                                                                                                            duration,
+                                                                                                            language,
+                                                                                                            level,
+                                                                                                            limit = 12,
+                                                                                                            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>,
-                                                                                                            limit: number = 12,
+                                                                                                            /**
+                                                                                                             * 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> {
+                                                                                                        }): CancelablePromise<RecommendedCoursesResponse> {
                                                                                                             return __request(OpenAPI, {
                                                                                                                 method: 'GET',
                                                                                                                 url: '/api/search/orgs/{org}/users/{username}/recommended/',
@@ -835,77 +1193,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}/',
@@ -1058,37 +1513,77 @@ export 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
                                                                                                                                                      */
-                                                                                                                                                    public static searchPromptsRetrieve(
-                                                                                                                                                        alphabetical: boolean = false,
+                                                                                                                                                    public static searchPromptsRetrieve({
+                                                                                                                                                        alphabetical = false,
+                                                                                                                                                        category,
+                                                                                                                                                        filterFacet,
+                                                                                                                                                        language,
+                                                                                                                                                        limit = 10,
+                                                                                                                                                        mentor,
+                                                                                                                                                        offset,
+                                                                                                                                                        orderDirection = 'desc',
+                                                                                                                                                        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,
-                                                                                                                                                        limit: number = 10,
+                                                                                                                                                        /**
+                                                                                                                                                         * Number of results per page
+                                                                                                                                                         */
+                                                                                                                                                        limit?: number,
+                                                                                                                                                        /**
+                                                                                                                                                         * Filter by mentor UUID
+                                                                                                                                                         */
                                                                                                                                                         mentor?: string,
+                                                                                                                                                        /**
+                                                                                                                                                         * Starting position for pagination
+                                                                                                                                                         */
                                                                                                                                                         offset?: number,
-                                                                                                                                                        orderDirection: string = 'desc',
+                                                                                                                                                        /**
+                                                                                                                                                         * 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> {
+                                                                                                                                                    }): CancelablePromise<PromptSearchResponse> {
                                                                                                                                                         return __request(OpenAPI, {
                                                                                                                                                             method: 'GET',
                                                                                                                                                             url: '/api/search/prompts/',
@@ -1202,41 +1697,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}/',