@iblai/iblai-api 3.38.8-core → 3.38.9-ai-plus

package/src/services/CatalogService.ts

@@ -2,8 +2,44 @@
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
+import type { CatalogAutoIncrementResponse } from '../models/CatalogAutoIncrementResponse';
+import type { CatalogAutoIncrementUpdateRequest } from '../models/CatalogAutoIncrementUpdateRequest';
+import type { Course } from '../models/Course';
+import type { CourseCreateUpdate } from '../models/CourseCreateUpdate';
+import type { CourseDeleteResponse } from '../models/CourseDeleteResponse';
+import type { CourseEligibilityCheckResponse } from '../models/CourseEligibilityCheckResponse';
+import type { CourseEnrollmentSearchResponse } from '../models/CourseEnrollmentSearchResponse';
+import type { CourseMetadataSearchRequest } from '../models/CourseMetadataSearchRequest';
+import type { CourseMetadataUpdateRequest } from '../models/CourseMetadataUpdateRequest';
+import type { CourseReviewInfoResponse } from '../models/CourseReviewInfoResponse';
+import type { DesiredRole } from '../models/DesiredRole';
+import type { DesiredRoleCreateUpdateRequest } from '../models/DesiredRoleCreateUpdateRequest';
+import type { DesiredSkill } from '../models/DesiredSkill';
+import type { DesiredSkillCreateUpdateRequest } from '../models/DesiredSkillCreateUpdateRequest';
+import type { Pathway } from '../models/Pathway';
+import type { PathwayCreateUpdateRequest } from '../models/PathwayCreateUpdateRequest';
+import type { PathwayDeleteResponse } from '../models/PathwayDeleteResponse';
+import type { PathwayEnrollment } from '../models/PathwayEnrollment';
+import type { PathwayEnrollmentPlus } from '../models/PathwayEnrollmentPlus';
+import type { PathwayEnrollmentRequest } from '../models/PathwayEnrollmentRequest';
+import type { PathwaySelfEnrollmentRequest } from '../models/PathwaySelfEnrollmentRequest';
+import type { Program } from '../models/Program';
+import type { ProgramCreateUpdateRequest } from '../models/ProgramCreateUpdateRequest';
+import type { ProgramDeleteResponse } from '../models/ProgramDeleteResponse';
+import type { ProgramEnrollment } from '../models/ProgramEnrollment';
+import type { ProgramEnrollmentPlus } from '../models/ProgramEnrollmentPlus';
+import type { ProgramReviewInfoResponse } from '../models/ProgramReviewInfoResponse';
+import type { ProgramSearch } from '../models/ProgramSearch';
+import type { ReportedRole } from '../models/ReportedRole';
+import type { ReportedRoleCreateUpdateRequest } from '../models/ReportedRoleCreateUpdateRequest';
+import type { ReportedSkill } from '../models/ReportedSkill';
 import type { Resource } from '../models/Resource';
 import type { ResourceCreateUpdate } from '../models/ResourceCreateUpdate';
+import type { ResourceDeleteResponse } from '../models/ResourceDeleteResponse';
+import type { Role } from '../models/Role';
+import type { RoleCreateUpdateRequest } from '../models/RoleCreateUpdateRequest';
+import type { Skill } from '../models/Skill';
+import type { SkillCreateUpdateRequest } from '../models/SkillCreateUpdateRequest';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
 import { request as __request } from '../core/request';
@@ -331,124 +367,147 @@ export class CatalogService {
                                                         });
                                                     }
                                                     /**
-                                                     * Retrieve courses matching query parameters.
-                                                     *
-                                                     * Query Parameters:
-                                                     * course_id (str, optional): Filter courses by their unique identifier
-                                                     * slug (str, optional): Filter courses by their slug (case-insensitive)
-                                                     * org (str, optional): Filter courses by their associated organization
-                                                     *
-                                                     * Returns:
-                                                     * A list of courses matching the provided filters. If no filters are provided,
-                                                     * all courses are returned.
-                                                     * @returns any No response body
+                                                     * Retrieve courses matching specified filters.
+                                                     * @param courseId Filter courses by their unique identifier
+                                                     * @param org Filter courses by their associated organization
+                                                     * @param slug Filter courses by their slug (case-insensitive)
+                                                     * @returns Course
                                                      * @throws ApiError
                                                      */
-                                                    public static catalogCoursesRetrieve(): CancelablePromise<any> {
+                                                    public static catalogCoursesList(
+                                                        courseId?: string,
+                                                        org?: string,
+                                                        slug?: string,
+                                                    ): CancelablePromise<Array<Course>> {
                                                         return __request(OpenAPI, {
                                                             method: 'GET',
                                                             url: '/api/catalog/courses/',
+                                                            query: {
+                                                                'course_id': courseId,
+                                                                'org': org,
+                                                                'slug': slug,
+                                                            },
+                                                            errors: {
+                                                                400: `No response body`,
+                                                            },
                                                         });
                                                     }
                                                     /**
                                                      * Add or update a course in the database.
-                                                     *
-                                                     * Request Body:
-                                                     * course_id (str, required): The unique identifier for the course
-                                                     * org (str, required): The organization associated with the course
-                                                     * name (str, optional): The name of the course
-                                                     *
-                                                     * Returns:
-                                                     * A JSON representation of the course that was added or updated.
-                                                     * Status code 201 if the course was newly created.
-                                                     * Status code 200 if the course already existed and was updated.
-                                                     *
-                                                     * Error Responses:
-                                                     * 400 Bad Request: If the course could not be created or updated due to invalid data
-                                                     * @returns any No response body
+                                                     * @param requestBody
+                                                     * @param courseId Filter courses by their unique identifier
+                                                     * @param org Filter courses by their associated organization
+                                                     * @param slug Filter courses by their slug (case-insensitive)
+                                                     * @returns Course
                                                      * @throws ApiError
                                                      */
-                                                    public static catalogCoursesCreate(): CancelablePromise<any> {
+                                                    public static catalogCoursesCreate(
+                                                        requestBody: CourseCreateUpdate,
+                                                        courseId?: string,
+                                                        org?: string,
+                                                        slug?: string,
+                                                    ): CancelablePromise<Course> {
                                                         return __request(OpenAPI, {
                                                             method: 'POST',
                                                             url: '/api/catalog/courses/',
+                                                            query: {
+                                                                'course_id': courseId,
+                                                                'org': org,
+                                                                'slug': slug,
+                                                            },
+                                                            body: requestBody,
+                                                            mediaType: 'application/json',
+                                                            errors: {
+                                                                400: `No response body`,
+                                                            },
                                                         });
                                                     }
                                                     /**
                                                      * Remove a course from the database.
-                                                     *
-                                                     * Query Parameters:
-                                                     * course_id (str, required): The unique identifier for the course to be deleted
-                                                     *
-                                                     * Returns:
-                                                     * A JSON object containing the count of deleted items and their type.
-                                                     * Status code 200 upon successful deletion.
-                                                     *
-                                                     * Error Responses:
-                                                     * 400 Bad Request: If the required parameters are not provided or if no course
-                                                     * matches the given filters
-                                                     * @returns void
+                                                     * @param courseId Filter courses by their unique identifier
+                                                     * @param org Filter courses by their associated organization
+                                                     * @param slug Filter courses by their slug (case-insensitive)
+                                                     * @returns CourseDeleteResponse
                                                      * @throws ApiError
                                                      */
-                                                    public static catalogCoursesDestroy(): CancelablePromise<void> {
+                                                    public static catalogCoursesDestroy(
+                                                        courseId?: string,
+                                                        org?: string,
+                                                        slug?: string,
+                                                    ): CancelablePromise<CourseDeleteResponse> {
                                                         return __request(OpenAPI, {
                                                             method: 'DELETE',
                                                             url: '/api/catalog/courses/',
+                                                            query: {
+                                                                'course_id': courseId,
+                                                                'org': org,
+                                                                'slug': slug,
+                                                            },
+                                                            errors: {
+                                                                400: `No response body`,
+                                                            },
                                                         });
                                                     }
                                                     /**
-                                                     * GET
-                                                     * List 'eligible' courses for user.
-                                                     *
-                                                     * This method retrieves a list of courses that the specified user is eligible for.
-                                                     * It requires either a user_id or a username to identify the user, and optionally an organization (org)
-                                                     * and a search query to filter the courses.
-                                                     *
-                                                     * Params:
-                                                     * - user_id/username: Identifies the user whose eligible courses are to be listed.
-                                                     * - org: (Optional) Filters courses by organization.
-                                                     * - query: (Optional) A search term to filter the courses.
-                                                     *
-                                                     * Returns:
-                                                     * - A 200 status code with a list of serialized course data if courses are found.
-                                                     * - A 200 status code with an empty list if no eligible courses are found.
-                                                     * - A 400 status code if the user_id or username is not provided or invalid.
-                                                     *
-                                                     * Side Effects:
-                                                     * - If a username is provided instead of a user_id, the method attempts to retrieve the user_id from the username.
-                                                     * @returns any No response body
+                                                     * List courses that a user is eligible for.
+                                                     * @param org Filter eligible courses by organization
+                                                     * @param query Search term to filter eligible courses
+                                                     * @param userId User ID to check eligibility for
+                                                     * @param username Username to check eligibility for
+                                                     * @returns Course
                                                      * @throws ApiError
                                                      */
-                                                    public static catalogEligibilityCoursesRetrieve(): CancelablePromise<any> {
+                                                    public static catalogEligibilityCoursesList(
+                                                        org?: string,
+                                                        query?: string,
+                                                        userId?: string,
+                                                        username?: string,
+                                                    ): CancelablePromise<Array<Course>> {
                                                         return __request(OpenAPI, {
                                                             method: 'GET',
                                                             url: '/api/catalog/eligibility/courses/',
+                                                            query: {
+                                                                'org': org,
+                                                                'query': query,
+                                                                'user_id': userId,
+                                                                'username': username,
+                                                            },
+                                                            errors: {
+                                                                400: `No response body`,
+                                                            },
                                                         });
                                                     }
                                                     /**
-                                                     * GET
-                                                     * Check whether user is eligible to enroll in a course
-                                                     *
-                                                     * Params:
-                                                     * user_id/username: The unique identifier or username of the user whose eligibility is being checked.
-                                                     * course_id: The unique identifier of the course for which eligibility is being checked.
-                                                     * org: The organization associated with the course.
-                                                     * local_only: A flag indicating whether to check eligibility only within the local organization.
-                                                     *
-                                                     * Returns:
-                                                     * - 200: If eligibility information is successfully retrieved.
-                                                     * - 400: If required parameters are missing.
-                                                     * - 500: If there is an error retrieving eligibility information.
-                                                     *
-                                                     * Side Effects:
-                                                     * - If 'username' is provided instead of 'user_id', the method attempts to resolve the user_id from the username.
-                                                     * @returns any No response body
+                                                     * Check whether a user is eligible to enroll in a specific course.
+                                                     * @param courseId Course ID to check eligibility for
+                                                     * @param localOnly Whether to check eligibility only within the local organization
+                                                     * @param org Organization of the course
+                                                     * @param userId User ID to check eligibility for
+                                                     * @param username Username to check eligibility for
+                                                     * @returns CourseEligibilityCheckResponse
                                                      * @throws ApiError
                                                      */
-                                                    public static catalogEligibilityCoursesCheckRetrieve(): CancelablePromise<any> {
+                                                    public static catalogEligibilityCoursesCheckRetrieve(
+                                                        courseId: string,
+                                                        localOnly?: boolean,
+                                                        org?: string,
+                                                        userId?: string,
+                                                        username?: string,
+                                                    ): CancelablePromise<CourseEligibilityCheckResponse> {
                                                         return __request(OpenAPI, {
                                                             method: 'GET',
                                                             url: '/api/catalog/eligibility/courses/check/',
+                                                            query: {
+                                                                'course_id': courseId,
+                                                                'local_only': localOnly,
+                                                                'org': org,
+                                                                'user_id': userId,
+                                                                'username': username,
+                                                            },
+                                                            errors: {
+                                                                400: `No response body`,
+                                                                500: `No response body`,
+                                                            },
                                                         });
                                                     }
                                                     /**
@@ -511,54 +570,205 @@ export class CatalogService {
                                                                  * - Users can view their own enrollments
                                                                  * - Platform admins can view enrollments for users in their platform
                                                                  * - DM admins can view all enrollments
-                                                                 * @returns any No response body
+                                                                 * @param courseId Filter enrollments by course ID
+                                                                 * @param courseName Filter enrollments by course name (partial match)
+                                                                 * @param email Filter enrollments by user email
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param org Filter enrollments by organization
+                                                                 * @param page Page number for pagination
+                                                                 * @param pageSize Number of items per page
+                                                                 * @param platformKey Filter enrollments by platform key
+                                                                 * @param slug Filter enrollments by course slug
+                                                                 * @param sort Field to sort results by
+                                                                 * @param userId Filter enrollments by user ID
+                                                                 * @param username Filter enrollments by username
+                                                                 * @returns CourseEnrollmentSearchResponse
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentCoursesSearchRetrieve(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentCoursesSearchRetrieve(
+                                                                    courseId?: string,
+                                                                    courseName?: string,
+                                                                    email?: string,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    org?: string,
+                                                                    page?: number,
+                                                                    pageSize?: number,
+                                                                    platformKey?: string,
+                                                                    slug?: string,
+                                                                    sort: string = '-id',
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<CourseEnrollmentSearchResponse> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/catalog/enrollment/courses/search/',
+                                                                        query: {
+                                                                            'course_id': courseId,
+                                                                            'course_name': courseName,
+                                                                            'email': email,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'org': org,
+                                                                            'page': page,
+                                                                            'page_size': pageSize,
+                                                                            'platform_key': platformKey,
+                                                                            'slug': slug,
+                                                                            'sort': sort,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Search pathway enrollments. Requires user_id or username and pathway_id or slug.
-                                                                 * @returns any No response body
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param includeMetadata Include metadata in the response
+                                                                 * @param org Organization for the pathway
+                                                                 * @param pathwayId Pathway ID for enrollment
+                                                                 * @param pathwayKey Pathway key for enrollment
+                                                                 * @param pathwayUuid Pathway UUID for enrollment
+                                                                 * @param platformKey Platform key for the pathway
+                                                                 * @param slug Pathway slug for enrollment
+                                                                 * @param userId User ID for enrollment
+                                                                 * @param username Username for enrollment
+                                                                 * @returns PathwayEnrollmentPlus
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentPathwaysRetrieve(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentPathwaysRetrieve(
+                                                                    active: boolean = true,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    includeMetadata: boolean = true,
+                                                                    org?: string,
+                                                                    pathwayId?: string,
+                                                                    pathwayKey?: string,
+                                                                    pathwayUuid?: string,
+                                                                    platformKey?: string,
+                                                                    slug?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<PathwayEnrollmentPlus> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/catalog/enrollment/pathways/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'include_metadata': includeMetadata,
+                                                                            'org': org,
+                                                                            'pathway_id': pathwayId,
+                                                                            'pathway_key': pathwayKey,
+                                                                            'pathway_uuid': pathwayUuid,
+                                                                            'platform_key': platformKey,
+                                                                            'slug': slug,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Log user enrollment with a pathway.
-                                                                 * @returns any No response body
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param includeMetadata Include metadata in the response
+                                                                 * @param org Organization for the pathway
+                                                                 * @param pathwayId Pathway ID for enrollment
+                                                                 * @param pathwayKey Pathway key for enrollment
+                                                                 * @param pathwayUuid Pathway UUID for enrollment
+                                                                 * @param platformKey Platform key for the pathway
+                                                                 * @param slug Pathway slug for enrollment
+                                                                 * @param userId User ID for enrollment
+                                                                 * @param username Username for enrollment
+                                                                 * @param requestBody
+                                                                 * @returns PathwayEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentPathwaysCreate(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentPathwaysCreate(
+                                                                    active: boolean = true,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    includeMetadata: boolean = true,
+                                                                    org?: string,
+                                                                    pathwayId?: string,
+                                                                    pathwayKey?: string,
+                                                                    pathwayUuid?: string,
+                                                                    platformKey?: string,
+                                                                    slug?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                    requestBody?: PathwayEnrollmentRequest,
+                                                                ): CancelablePromise<PathwayEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'POST',
                                                                         url: '/api/catalog/enrollment/pathways/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'include_metadata': includeMetadata,
+                                                                            'org': org,
+                                                                            'pathway_id': pathwayId,
+                                                                            'pathway_key': pathwayKey,
+                                                                            'pathway_uuid': pathwayUuid,
+                                                                            'platform_key': platformKey,
+                                                                            'slug': slug,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
+                                                                        body: requestBody,
+                                                                        mediaType: 'application/json',
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Unenroll from a pathway. Deactivates enrollment.
-                                                                 * @returns void
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param includeMetadata Include metadata in the response
+                                                                 * @param org Organization for the pathway
+                                                                 * @param pathwayId Pathway ID for enrollment
+                                                                 * @param pathwayKey Pathway key for enrollment
+                                                                 * @param pathwayUuid Pathway UUID for enrollment
+                                                                 * @param platformKey Platform key for the pathway
+                                                                 * @param slug Pathway slug for enrollment
+                                                                 * @param userId User ID for enrollment
+                                                                 * @param username Username for enrollment
+                                                                 * @returns PathwayEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentPathwaysDestroy(): CancelablePromise<void> {
+                                                                public static catalogEnrollmentPathwaysDestroy(
+                                                                    active: boolean = true,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    includeMetadata: boolean = true,
+                                                                    org?: string,
+                                                                    pathwayId?: string,
+                                                                    pathwayKey?: string,
+                                                                    pathwayUuid?: string,
+                                                                    platformKey?: string,
+                                                                    slug?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<PathwayEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'DELETE',
                                                                         url: '/api/catalog/enrollment/pathways/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'include_metadata': includeMetadata,
+                                                                            'org': org,
+                                                                            'pathway_id': pathwayId,
+                                                                            'pathway_key': pathwayKey,
+                                                                            'pathway_uuid': pathwayUuid,
+                                                                            'platform_key': platformKey,
+                                                                            'slug': slug,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Search pathway enrollments based on user or pathway identifiers. Returns paginated enrollment results.
-                                                                 * @returns any No response body
+                                                                 * @returns PathwayEnrollmentPlus
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentPathwaysSearchRetrieve(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentPathwaysSearchRetrieve(): CancelablePromise<PathwayEnrollmentPlus> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/catalog/enrollment/pathways/search/',
@@ -566,112 +776,433 @@ export class CatalogService {
                                                                 }
                                                                 /**
                                                                  * Log user enrollment with a pathway.
-                                                                 * @returns any No response body
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param org Organization for the pathway
+                                                                 * @param pathwayId Pathway ID for self-enrollment
+                                                                 * @param pathwayKey Pathway key for self-enrollment
+                                                                 * @param platformKey Platform key for the pathway
+                                                                 * @param slug Pathway slug for self-enrollment
+                                                                 * @param userId User ID for self-enrollment
+                                                                 * @param username Username for self-enrollment
+                                                                 * @param requestBody
+                                                                 * @returns PathwayEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentPathwaysSelfCreate(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentPathwaysSelfCreate(
+                                                                    active: boolean = true,
+                                                                    org?: string,
+                                                                    pathwayId?: string,
+                                                                    pathwayKey?: string,
+                                                                    platformKey?: string,
+                                                                    slug?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                    requestBody?: PathwaySelfEnrollmentRequest,
+                                                                ): CancelablePromise<PathwayEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'POST',
                                                                         url: '/api/catalog/enrollment/pathways/self/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'org': org,
+                                                                            'pathway_id': pathwayId,
+                                                                            'pathway_key': pathwayKey,
+                                                                            'platform_key': platformKey,
+                                                                            'slug': slug,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
+                                                                        body: requestBody,
+                                                                        mediaType: 'application/json',
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Unenroll from a pathway. Deactivates enrollment.
-                                                                 * @returns void
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param org Organization for the pathway
+                                                                 * @param pathwayId Pathway ID for self-enrollment
+                                                                 * @param pathwayKey Pathway key for self-enrollment
+                                                                 * @param platformKey Platform key for the pathway
+                                                                 * @param slug Pathway slug for self-enrollment
+                                                                 * @param userId User ID for self-enrollment
+                                                                 * @param username Username for self-enrollment
+                                                                 * @returns PathwayEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentPathwaysSelfDestroy(): CancelablePromise<void> {
+                                                                public static catalogEnrollmentPathwaysSelfDestroy(
+                                                                    active: boolean = true,
+                                                                    org?: string,
+                                                                    pathwayId?: string,
+                                                                    pathwayKey?: string,
+                                                                    platformKey?: string,
+                                                                    slug?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<PathwayEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'DELETE',
                                                                         url: '/api/catalog/enrollment/pathways/self/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'org': org,
+                                                                            'pathway_id': pathwayId,
+                                                                            'pathway_key': pathwayKey,
+                                                                            'platform_key': platformKey,
+                                                                            'slug': slug,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Search program enrollments. Requires user_id or username and program_id or slug.
-                                                                 * @returns any No response body
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param expired Date when enrollment expires
+                                                                 * @param ignoreExpiration Whether to ignore expiration during unenrollment
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param includeMetadata Include metadata in the response
+                                                                 * @param org Organization for the program
+                                                                 * @param platformKey Platform key for the program
+                                                                 * @param programId Program ID for enrollment
+                                                                 * @param programKey Program key for enrollment
+                                                                 * @param programType Program type (standard, platform, custom)
+                                                                 * @param slug Program slug for enrollment
+                                                                 * @param started Date when enrollment started
+                                                                 * @param userId User ID for enrollment
+                                                                 * @param username Username for enrollment
+                                                                 * @returns ProgramEnrollmentPlus
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentProgramsRetrieve(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentProgramsRetrieve(
+                                                                    active: boolean = true,
+                                                                    expired?: string,
+                                                                    ignoreExpiration: boolean = false,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    includeMetadata: boolean = true,
+                                                                    org?: string,
+                                                                    platformKey?: string,
+                                                                    programId?: string,
+                                                                    programKey?: string,
+                                                                    programType?: string,
+                                                                    slug?: string,
+                                                                    started?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<ProgramEnrollmentPlus> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/catalog/enrollment/programs/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'expired': expired,
+                                                                            'ignore_expiration': ignoreExpiration,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'include_metadata': includeMetadata,
+                                                                            'org': org,
+                                                                            'platform_key': platformKey,
+                                                                            'program_id': programId,
+                                                                            'program_key': programKey,
+                                                                            'program_type': programType,
+                                                                            'slug': slug,
+                                                                            'started': started,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Log user enrollment with a program.
-                                                                 * @returns any No response body
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param expired Date when enrollment expires
+                                                                 * @param ignoreExpiration Whether to ignore expiration during unenrollment
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param includeMetadata Include metadata in the response
+                                                                 * @param org Organization for the program
+                                                                 * @param platformKey Platform key for the program
+                                                                 * @param programId Program ID for enrollment
+                                                                 * @param programKey Program key for enrollment
+                                                                 * @param programType Program type (standard, platform, custom)
+                                                                 * @param slug Program slug for enrollment
+                                                                 * @param started Date when enrollment started
+                                                                 * @param userId User ID for enrollment
+                                                                 * @param username Username for enrollment
+                                                                 * @param requestBody
+                                                                 * @returns ProgramEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentProgramsCreate(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentProgramsCreate(
+                                                                    active: boolean = true,
+                                                                    expired?: string,
+                                                                    ignoreExpiration: boolean = false,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    includeMetadata: boolean = true,
+                                                                    org?: string,
+                                                                    platformKey?: string,
+                                                                    programId?: string,
+                                                                    programKey?: string,
+                                                                    programType?: string,
+                                                                    slug?: string,
+                                                                    started?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                    requestBody?: ProgramEnrollmentPlus,
+                                                                ): CancelablePromise<ProgramEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'POST',
                                                                         url: '/api/catalog/enrollment/programs/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'expired': expired,
+                                                                            'ignore_expiration': ignoreExpiration,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'include_metadata': includeMetadata,
+                                                                            'org': org,
+                                                                            'platform_key': platformKey,
+                                                                            'program_id': programId,
+                                                                            'program_key': programKey,
+                                                                            'program_type': programType,
+                                                                            'slug': slug,
+                                                                            'started': started,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
+                                                                        body: requestBody,
+                                                                        mediaType: 'application/json',
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Unenroll from a program. Deactivates enrollment.
-                                                                 * @returns void
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param expired Date when enrollment expires
+                                                                 * @param ignoreExpiration Whether to ignore expiration during unenrollment
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param includeMetadata Include metadata in the response
+                                                                 * @param org Organization for the program
+                                                                 * @param platformKey Platform key for the program
+                                                                 * @param programId Program ID for enrollment
+                                                                 * @param programKey Program key for enrollment
+                                                                 * @param programType Program type (standard, platform, custom)
+                                                                 * @param slug Program slug for enrollment
+                                                                 * @param started Date when enrollment started
+                                                                 * @param userId User ID for enrollment
+                                                                 * @param username Username for enrollment
+                                                                 * @returns ProgramEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentProgramsDestroy(): CancelablePromise<void> {
+                                                                public static catalogEnrollmentProgramsDestroy(
+                                                                    active: boolean = true,
+                                                                    expired?: string,
+                                                                    ignoreExpiration: boolean = false,
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    includeMetadata: boolean = true,
+                                                                    org?: string,
+                                                                    platformKey?: string,
+                                                                    programId?: string,
+                                                                    programKey?: string,
+                                                                    programType?: string,
+                                                                    slug?: string,
+                                                                    started?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<ProgramEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'DELETE',
                                                                         url: '/api/catalog/enrollment/programs/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'expired': expired,
+                                                                            'ignore_expiration': ignoreExpiration,
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'include_metadata': includeMetadata,
+                                                                            'org': org,
+                                                                            'platform_key': platformKey,
+                                                                            'program_id': programId,
+                                                                            'program_key': programKey,
+                                                                            'program_type': programType,
+                                                                            'slug': slug,
+                                                                            'started': started,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Search program enrollments based on user or program identifiers. Returns paginated enrollment results.
-                                                                 * @returns any No response body
+                                                                 * @param includeDefaultPlatform Include enrollments from default platform
+                                                                 * @param org Filter enrollments by organization
+                                                                 * @param page Page number for pagination
+                                                                 * @param pageSize Number of items per page
+                                                                 * @param platformKey Filter enrollments by platform key
+                                                                 * @param programId Filter enrollments by program ID
+                                                                 * @param programType Filter by program type (standard, platform, custom)
+                                                                 * @param slug Filter enrollments by program slug
+                                                                 * @param sort Field to sort results by
+                                                                 * @param userId Filter enrollments by user ID
+                                                                 * @param username Filter enrollments by username
+                                                                 * @returns ProgramEnrollmentPlus
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentProgramsSearchRetrieve(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentProgramsSearchRetrieve(
+                                                                    includeDefaultPlatform?: boolean,
+                                                                    org?: string,
+                                                                    page?: number,
+                                                                    pageSize?: number,
+                                                                    platformKey?: string,
+                                                                    programId?: string,
+                                                                    programType?: string,
+                                                                    slug?: string,
+                                                                    sort: string = '-id',
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<ProgramEnrollmentPlus> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/catalog/enrollment/programs/search/',
+                                                                        query: {
+                                                                            'include_default_platform': includeDefaultPlatform,
+                                                                            'org': org,
+                                                                            'page': page,
+                                                                            'page_size': pageSize,
+                                                                            'platform_key': platformKey,
+                                                                            'program_id': programId,
+                                                                            'program_type': programType,
+                                                                            'slug': slug,
+                                                                            'sort': sort,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Log user enrollment with a program.
-                                                                 * @returns any No response body
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param expired Date when enrollment expires
+                                                                 * @param ignoreExpiration Whether to ignore expiration during unenrollment
+                                                                 * @param org Organization for the program
+                                                                 * @param platformKey Platform key for the program
+                                                                 * @param programId Program ID for self-enrollment
+                                                                 * @param programKey Program key for self-enrollment
+                                                                 * @param slug Program slug for self-enrollment
+                                                                 * @param started Date when enrollment started
+                                                                 * @param userId User ID for self-enrollment
+                                                                 * @param username Username for self-enrollment
+                                                                 * @param requestBody
+                                                                 * @returns ProgramEnrollment
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentProgramsSelfCreate(): CancelablePromise<any> {
+                                                                public static catalogEnrollmentProgramsSelfCreate(
+                                                                    active: boolean = true,
+                                                                    expired?: string,
+                                                                    ignoreExpiration: boolean = false,
+                                                                    org?: string,
+                                                                    platformKey?: string,
+                                                                    programId?: string,
+                                                                    programKey?: string,
+                                                                    slug?: string,
+                                                                    started?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                    requestBody?: ProgramEnrollment,
+                                                                ): CancelablePromise<ProgramEnrollment> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'POST',
                                                                         url: '/api/catalog/enrollment/programs/self/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'expired': expired,
+                                                                            'ignore_expiration': ignoreExpiration,
+                                                                            'org': org,
+                                                                            'platform_key': platformKey,
+                                                                            'program_id': programId,
+                                                                            'program_key': programKey,
+                                                                            'slug': slug,
+                                                                            'started': started,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
+                                                                        body: requestBody,
+                                                                        mediaType: 'application/json',
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Unenroll from a program. Deactivates enrollment.
+                                                                 * @param active Whether the enrollment should be active
+                                                                 * @param expired Date when enrollment expires
+                                                                 * @param ignoreExpiration Whether to ignore expiration during unenrollment
+                                                                 * @param org Organization for the program
+                                                                 * @param platformKey Platform key for the program
+                                                                 * @param programId Program ID for self-enrollment
+                                                                 * @param programKey Program key for self-enrollment
+                                                                 * @param slug Program slug for self-enrollment
+                                                                 * @param started Date when enrollment started
+                                                                 * @param userId User ID for self-enrollment
+                                                                 * @param username Username for self-enrollment
                                                                  * @returns void
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogEnrollmentProgramsSelfDestroy(): CancelablePromise<void> {
+                                                                public static catalogEnrollmentProgramsSelfDestroy(
+                                                                    active: boolean = true,
+                                                                    expired?: string,
+                                                                    ignoreExpiration: boolean = false,
+                                                                    org?: string,
+                                                                    platformKey?: string,
+                                                                    programId?: string,
+                                                                    programKey?: string,
+                                                                    slug?: string,
+                                                                    started?: string,
+                                                                    userId?: string,
+                                                                    username?: string,
+                                                                ): CancelablePromise<void> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'DELETE',
                                                                         url: '/api/catalog/enrollment/programs/self/',
+                                                                        query: {
+                                                                            'active': active,
+                                                                            'expired': expired,
+                                                                            'ignore_expiration': ignoreExpiration,
+                                                                            'org': org,
+                                                                            'platform_key': platformKey,
+                                                                            'program_id': programId,
+                                                                            'program_key': programKey,
+                                                                            'slug': slug,
+                                                                            'started': started,
+                                                                            'user_id': userId,
+                                                                            'username': username,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Retrieve auto increment information for a specific platform.
-                                                                 * @returns any No response body
+                                                                 * @returns CatalogAutoIncrementResponse
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogIncrementRetrieve(): CancelablePromise<any> {
+                                                                public static catalogIncrementRetrieve(): CancelablePromise<CatalogAutoIncrementResponse> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/catalog/increment/',
+                                                                        errors: {
+                                                                            404: `No response body`,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
                                                                  * Update auto increment information and retrieve a new ID for a specific platform.
-                                                                 * @returns any No response body
+                                                                 * @param requestBody
+                                                                 * @returns any
                                                                  * @throws ApiError
                                                                  */
-                                                                public static catalogIncrementCreate(): CancelablePromise<any> {
+                                                                public static catalogIncrementCreate(
+                                                                    requestBody: CatalogAutoIncrementUpdateRequest,
+                                                                ): CancelablePromise<Record<string, any>> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'POST',
                                                                         url: '/api/catalog/increment/',
+                                                                        body: requestBody,
+                                                                        mediaType: 'application/json',
+                                                                        errors: {
+                                                                            400: `No response body`,
+                                                                            500: `No response body`,
+                                                                        },
                                                                     });
                                                                 }
                                                                 /**
@@ -4165,111 +4696,103 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * Query metadata choices based on field_key, scope, and org parameters.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param fieldKey The key of the field for which choices are being queried
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param org The organization context for the metadata choices
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param scope The scope within which to query the metadata choices (course, program, pathway, resource)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataChoicesRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataChoicesRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fieldKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                org?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                scope?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     url: '/api/catalog/metadata/choices/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'field_key': fieldKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'org': org,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'scope': scope,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * GET
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Query course metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method retrieves metadata for a specified course. The course_id must be provided
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * as a query parameter. If the course is not found, a 400 status code is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * If the metadata retrieval fails, a 404 status code is returned. On successful retrieval,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * the metadata is returned with a 200 status code.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id: The ID of the course for which metadata is being queried.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Retrieve metadata for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get metadata for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCourseRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCourseRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     url: '/api/catalog/metadata/course/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * POST
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Update course metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method updates the metadata for a specified course. The course_id and metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * must be provided in the request data. An optional 'update' parameter can be provided
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * to specify whether to overwrite existing metadata. If the course is not found, a 400
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * status code is returned. If the field parameter is provided, a 404 status code is returned
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * as field updates are not supported. On successful update, the updated metadata is returned
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * with a 200 status code. If the update fails, a 400 status code is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id: The ID of the course for which metadata is being updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * metadata: The new metadata to update the course with.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * update (optional): A boolean indicating whether to overwrite existing metadata.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Update metadata for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get metadata for
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param requestBody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCourseCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCourseCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestBody: CourseMetadataUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     url: '/api/catalog/metadata/course/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * GET
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Query public course metadata.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method retrieves and returns the public metadata for a specified course.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * It requires a 'course_id' parameter to identify the course for which metadata is requested.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * CAUTION: Does not factor in course visibility.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id: The unique identifier for the course whose metadata is being queried.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - 200: Successfully retrieved the course metadata.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - 400: The course ID provided does not correspond to any existing course.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - 404: Metadata retrieval failed for the specified course.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - Logs debug information if the course is not found or if metadata retrieval fails.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Retrieve public metadata for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get metadata for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCoursePublicRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCoursePublicRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     url: '/api/catalog/metadata/course-public/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * GET
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Query public course metadata.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method retrieves and returns the public metadata for a specified course.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * It requires a 'course_id' parameter to identify the course for which metadata is requested.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * CAUTION: Does not factor in course visibility.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id: The unique identifier for the course whose metadata is being queried.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - 200: Successfully retrieved the course metadata.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - 400: The course ID provided does not correspond to any existing course.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - 404: Metadata retrieval failed for the specified course.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - Logs debug information if the course is not found or if metadata retrieval fails.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Retrieve public metadata for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get metadata for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @param field
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             public static catalogMetadataCoursePublicRetrieve2(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 field: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
@@ -4278,55 +4801,44 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     path: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         'field': field,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * POST
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Query course metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Return course info for courses matching course query
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * <filters>
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method accepts a set of filters in the request body to query the course metadata.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * It returns a list of courses that match the provided filters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - Returns a 400 status code if the search filters are empty or invalid.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - Returns a 500 status code if an unexpected error occurs during the query process.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - Logs an error if the search filters are empty.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - Logs an exception if the filters are invalid or if an unexpected error occurs.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Special Return Codes:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * - A 200 status code indicates successful retrieval of course metadata.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Search for courses matching specified metadata filters.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @returns any
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCourseSearchCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogMetadataCourseSearchCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestBody?: CourseMetadataSearchRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): CancelablePromise<Record<string, any>> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     url: '/api/catalog/metadata/course-search/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        500: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * GET
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Query course metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method retrieves metadata for a specified course. The course_id must be provided
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * as a query parameter. If the course is not found, a 400 status code is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * If the metadata retrieval fails, a 404 status code is returned. On successful retrieval,
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * the metadata is returned with a 200 status code.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id: The ID of the course for which metadata is being queried.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Retrieve metadata for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get metadata for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @param field
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             public static catalogMetadataCourseRetrieve2(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 field: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
@@ -4335,29 +4847,27 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     path: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         'field': field,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * POST
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Update course metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * This method updates the metadata for a specified course. The course_id and metadata
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * must be provided in the request data. An optional 'update' parameter can be provided
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * to specify whether to overwrite existing metadata. If the course is not found, a 400
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * status code is returned. If the field parameter is provided, a 404 status code is returned
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * as field updates are not supported. On successful update, the updated metadata is returned
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * with a 200 status code. If the update fails, a 400 status code is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id: The ID of the course for which metadata is being updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * metadata: The new metadata to update the course with.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * update (optional): A boolean indicating whether to overwrite existing metadata.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Update metadata for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get metadata for
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @param field
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param requestBody
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @returns any No response body
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             public static catalogMetadataCourseCreate2(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 field: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                requestBody: CourseMetadataUpdateRequest,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             ): CancelablePromise<any> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'POST',
@@ -4365,6 +4875,15 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     path: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         'field': field,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
@@ -4981,10 +5500,10 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Retrieve pathways matching query. Limited parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns Pathway
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogPathwaysRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogPathwaysList(): CancelablePromise<Array<Pathway>> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/pathways/',
@@ -4992,32 +5511,43 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Add or update a pathway.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns Pathway
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogPathwaysCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogPathwaysCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requestBody: PathwayCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): CancelablePromise<Pathway> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/pathways/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Remove a pathway from the database.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns void
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns PathwayDeleteResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogPathwaysDestroy(): CancelablePromise<void> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogPathwaysDestroy(): CancelablePromise<PathwayDeleteResponse> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'DELETE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/pathways/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Retrieve programs matching query parameters. Limited parameters include program_id, name, slug, enabled, and org.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns Program
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogProgramsRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogProgramsList(): CancelablePromise<Array<Program>> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/programs/',
@@ -5025,24 +5555,35 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Add or update a program. Accepts a list of courses and updates or creates a program.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns Program
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogProgramsCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogProgramsCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    requestBody: ProgramCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): CancelablePromise<Program> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/programs/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Remove a program from the database. Requires program_id and org as parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns void
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns ProgramDeleteResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogProgramsDestroy(): CancelablePromise<void> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogProgramsDestroy(): CancelablePromise<ProgramDeleteResponse> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'DELETE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/programs/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
@@ -5065,91 +5606,162 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Side Effects:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * - None
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param courseId Current course ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param org Organization to filter recommendations
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param userId User ID for personalized recommendations
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns Course
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogRecommendationCoursesRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogRecommendationCoursesRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    courseId: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    org?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userId?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): CancelablePromise<Course> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/recommendation/courses/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'org': org,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * GET
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Retrieve resources matching query. Limited parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Optional:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * resource_type
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * item_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * name
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * platform_key/key
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * platform_org/org
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * This method retrieves resources based on the provided query parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * It filters the resources using the allowed parameters and returns a serialized list of resources.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * - If no resources match the query, an empty list is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * - None
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param id Resource ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param itemId Item ID associated with the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param key Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param name Resource name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param org Platform organization
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param platformKey Platform key (alternative to key)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param platformOrg Platform organization (alternative to org)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param resourceType Type of resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param userId User ID who owns the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param username Username who owns the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns Resource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogResourcesRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogResourcesList(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    itemId?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    org?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platformOrg?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resourceType?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): CancelablePromise<Array<Resource>> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/resources/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'item_id': itemId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'key': key,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'org': org,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'platform_org': platformOrg,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'resource_type': resourceType,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Create or update a resource with optional image upload
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Create or update a resource. For updates, include the resource ID.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @param formData
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param id Resource ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param itemId Item ID associated with the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param key Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param name Resource name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param org Platform organization
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param platformKey Platform key (alternative to key)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param platformOrg Platform organization (alternative to org)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param resourceType Type of resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param userId User ID who owns the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param username Username who owns the resource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @returns Resource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 public static catalogResourcesCreate(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     formData: ResourceCreateUpdate,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    itemId?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    org?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platformOrg?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resourceType?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    username?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 ): CancelablePromise<Resource> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/resources/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'item_id': itemId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'key': key,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'org': org,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'platform_org': platformOrg,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'resource_type': resourceType,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         formData: formData,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         mediaType: 'multipart/form-data',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * DELETE
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * Remove a resource from the database.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Params (all required):
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * user_id or platform_key
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Return:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * count
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * type
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * This method deletes a resource from the database based on the provided parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * It returns the count of deleted resources and their type.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * - If required parameters are missing, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * - If no resources match the query, the count will be zero.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * - The specified resource is removed from the database.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns void
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param id Resource ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param itemId Item ID associated with the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param key Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param name Resource name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param org Platform organization
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param platformKey Platform key (alternative to key)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param platformOrg Platform organization (alternative to org)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param resourceType Type of resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param userId User ID who owns the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param username Username who owns the resource
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns ResourceDeleteResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogResourcesDestroy(): CancelablePromise<void> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogResourcesDestroy(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    itemId?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    key?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    org?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    platformOrg?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    resourceType?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): CancelablePromise<ResourceDeleteResponse> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'DELETE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/resources/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'item_id': itemId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'key': key,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'org': org,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'platform_org': platformOrg,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'resource_type': resourceType,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
@@ -5213,17 +5825,24 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Query course review info
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * course_id
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * Retrieve aggregate review information for a course.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @param courseId The course ID to get review information for
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             * @returns CourseReviewInfoResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogReviewsCourseInfoRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            public static catalogReviewsCourseInfoRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                courseId: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ): CancelablePromise<CourseReviewInfoResponse> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     url: '/api/catalog/reviews/course/info/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'course_id': courseId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             /**
@@ -5401,17 +6020,24 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Query program review info
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * program_key
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * Retrieve aggregate review information for a program.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @param programKey The program key to get review information for
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 * @returns ProgramReviewInfoResponse
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogReviewsProgramInfoRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                public static catalogReviewsProgramInfoRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    programKey: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): CancelablePromise<ProgramReviewInfoResponse> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         url: '/api/catalog/reviews/program/info/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            'program_key': programKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 /**
@@ -5530,158 +6156,201 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Retrieve roles matching query parameters. Supports filtering by name, id, and slug.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param id Role ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param name Role name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param nameIexact Exact match for role name (case insensitive)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param page Page number for pagination
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param pageSize Number of items per page
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param platformKey Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param slug Role slug
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param sort Field to sort results by
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns Role
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nameIexact?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            page?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageSize?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            slug?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sort: string = 'id',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<Role> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name__iexact': nameIexact,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page': page,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page_size': pageSize,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'slug': slug,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'sort': sort,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Add a new role or update an existing role based on provided data.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param id Role ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param name Role name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param nameIexact Exact match for role name (case insensitive)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param page Page number for pagination
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param pageSize Number of items per page
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param platformKey Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param slug Role slug
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param sort Field to sort results by
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns Role
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: RoleCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nameIexact?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            page?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageSize?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            slug?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sort: string = 'id',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<Role> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name__iexact': nameIexact,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page': page,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page_size': pageSize,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'slug': slug,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'sort': sort,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Retrieve desired roles for a user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * This method retrieves the desired roles for a user based on the provided query parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * If the user is found and has desired roles, it returns the serialized role data with a status of 200.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * If no roles are found, it returns a status of 400 indicating a bad request.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the user cannot be identified from the provided parameters, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If no desired roles exist for the user, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - None
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns DesiredRole
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesDesiredRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesDesiredRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<DesiredRole> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/desired/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * POST
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update a role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - user_id/username: The identifier for the user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - skills: The skills associated with the desired role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - data: Additional data related to the desired role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * This method allows adding or updating a user's desired roles. It accepts user identification
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * and role data in the request body. If the role is successfully created, it returns the serialized
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * role data with a status of 201. If the role is updated, it returns the serialized role data with
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * a status of 200. If the operation fails, it returns a status of 400.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the user cannot be identified from the provided parameters, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the role cannot be created or updated, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - Creates or updates the desired roles for the specified user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update desired roles for a user.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns DesiredRole
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesDesiredCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesDesiredCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: DesiredRoleCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<DesiredRole> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/desired/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update a role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * This method handles the creation or updating of a role based on the provided data.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * It checks if public role creation is allowed, and if not, returns a 404 status.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * If the request is made by a user token, the user is logged.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - id: Identifier for the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - name: Name of the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - slug: A short label for the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - data: Additional data for the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 201 status code if a new role is created.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 200 status code if an existing role is updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 400 status code if the role creation or update fails.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 404 status code if public role creation is not allowed.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - Logs the user if the request is made by a user token.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update a role through the public API (when enabled).
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns Role
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesPublicCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesPublicCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: RoleCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<Role> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/public/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    404: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * GET
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Retrieve desired roles for user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - name: The name of the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - id: The ID of the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - slug: The slug of the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 200: If the role is found, returns the serialized role data.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 400: If no role is found for the user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the user cannot be found using the provided user_id or username, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Retrieve reported roles for a user.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns ReportedRole
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesReportedRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesReportedRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<ReportedRole> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/reported/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * POST
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update a role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - user_id/username: The identifier for the user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - skills: The skills associated with the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - data: Additional data related to the role.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 201: If a new role is created, returns the serialized role data.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 200: If an existing role is updated, returns the serialized role data.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 400: If the role cannot be saved or updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the user cannot be found using the provided user_id or username, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the role cannot be saved or updated, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - Creates a new role or updates an existing role for the user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update reported roles for a user.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns ReportedRole
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesReportedCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogRolesReportedCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: ReportedRoleCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<ReportedRole> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/roles/reported/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                errors: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    400: `No response body`,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
@@ -5704,123 +6373,166 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Special Return Codes:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * - A 200 status code indicates successful retrieval of programs matching the query.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param org The organization to which the programs belong
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param query The search term used to filter programs
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns ProgramSearch
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSearchProgramsCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSearchProgramsCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: ProgramSearch,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            org?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            query: string = '',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<ProgramSearch> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/search/programs/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'org': org,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'query': query,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Retrieve skills matching query. Limited parameters.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param id Skill ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param name Skill name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param nameIexact Exact match for skill name (case insensitive)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param page Page number for pagination
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param pageSize Number of items per page
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param platformKey Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param slug Skill slug
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param sort Field to sort results by
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns Skill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nameIexact?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            page?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageSize?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            slug?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sort: string = 'id',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<Skill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name__iexact': nameIexact,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page': page,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page_size': pageSize,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'slug': slug,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'sort': sort,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Add or update a skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param id Skill ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param name Skill name
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param nameIexact Exact match for skill name (case insensitive)
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param page Page number for pagination
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param pageSize Number of items per page
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param platformKey Platform key
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param slug Skill slug
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param sort Field to sort results by
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns Skill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nameIexact?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            page?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pageSize?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            platformKey?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            slug?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sort: string = 'id',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody?: Skill,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<Skill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'id': id,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name': name,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'name__iexact': nameIexact,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page': page,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'page_size': pageSize,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'platform_key': platformKey,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'slug': slug,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'sort': sort,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * GET
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Retrieve desired skills for a user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * This method fetches the desired skills associated with a user based on the provided
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * query parameters. It requires either a user_id or username to identify the user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - name: The name of the skill to retrieve.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - id: The unique identifier of the skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - slug: A slug representation of the skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 200: A successful response containing the serialized desired skill data.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 400: If the user is not found or no desired skills exist for the user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the user cannot be identified from the provided parameters, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If no desired skills are found for the identified user, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns DesiredSkill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsDesiredRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsDesiredRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<DesiredSkill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/desired/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * POST
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update a skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * This method allows adding new skills or updating existing skills for a user.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * It requires user identification through user_id or username and a list of skills
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * to be added or updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Params:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - user_id/username: Identifies the user for whom the skills are to be added or updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - skills: A list of skills to be added or updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - data: Additional data related to the skills.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 201: If a new skill is successfully created.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 200: If an existing skill is successfully updated.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 400: If the user cannot be identified or the skill cannot be saved.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Error Conditions:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the user cannot be identified from the provided parameters, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - If the skill cannot be saved due to any reason, a 400 status is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Side Effects:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - This method may create a new skill entry or update an existing one in the database.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Add or update desired skills for a user.
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns DesiredSkill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsDesiredCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsDesiredCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: DesiredSkillCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<DesiredSkill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/desired/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * POST
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Add or update a skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * This method processes POST requests to add or update a role. It expects the following parameters in the request data:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - id: The unique identifier for the skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - name: The name of the skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - slug: A URL-friendly version of the skill name.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - data: Additional data related to the skill.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * If the `ALLOW_PUBLIC_SKILL_CREATE` setting is disabled, the method will return a 404 status code, indicating that the creation of new skills is not allowed.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * If the request is made by a user with a valid token, the user will be logged.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         *
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * Returns:
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 201 status code if a new skill is created successfully.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 200 status code if an existing skill is updated successfully.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * - 400 status code if the skill creation or update fails.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns Skill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsPublicCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsPublicCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: SkillCreateUpdateRequest,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<Skill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/public/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
@@ -5840,13 +6552,22 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Error Conditions:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * - If the user cannot be identified, a 400 status code is returned.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * - If no reported skills exist for the user, a 400 status code is returned.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns ReportedSkill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsReportedRetrieve(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsReportedRetrieve(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<ReportedSkill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'GET',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/reported/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**
@@ -5872,13 +6593,26 @@ export class CatalogService {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * Side Effects:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * - If a new skill is created, it will be persisted in the database.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * - If an existing skill is updated, the changes will be saved in the database.
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns any No response body
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param requestBody
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param userId User ID
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @param username Username
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         * @returns ReportedSkill
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          * @throws ApiError
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          */
-                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsReportedCreate(): CancelablePromise<any> {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        public static catalogSkillsReportedCreate(
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            requestBody: ReportedSkill,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            userId?: number,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            username?: string,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ): CancelablePromise<ReportedSkill> {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 method: 'POST',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 url: '/api/catalog/skills/reported/',
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                query: {
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    'username': username,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                },
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body: requestBody,
+                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                mediaType: 'application/json',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             });
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         /**