@iblai/iblai-api 4.118.3-core → 4.118.4-core

package/dist/index.umd.js

@@ -114,7 +114,7 @@
 
     const OpenAPI = {
       BASE: 'https://base.manager.iblai.app',
-      VERSION: '4.118.3-core',
+      VERSION: '4.118.4-core',
       WITH_CREDENTIALS: false,
       CREDENTIALS: 'include',
       TOKEN: undefined,
@@ -15396,14 +15396,14 @@
        */
       static credentialsOrgsUsersRetrieve({
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -15489,15 +15489,15 @@
                        */
       static credentialsOrgsUsersCreate({
         platformKey,
-        username,
+        userId,
         requestBody
       }) {
         return request(OpenAPI, {
           method: 'POST',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           body: requestBody,
           mediaType: 'application/json'
@@ -15546,33 +15546,36 @@
                * "result": {credential object}
                * }
                *
-               * DELETE: No content (204)
-               *
-               * Error Responses:
-               * 400 Bad Request: If the request data is invalid
-               * 401 Unauthorized: If the user is not authenticated
-               * 403 Forbidden: If the user does not have permission to access this resource
-               * 404 Not Found: If the credential doesn't exist
-               * 500 Internal Server Error: If an unexpected error occurs
-               *
-               * Access Control:
-               * - Requires CredentialAssignmentPermission
-               * - Users can only manage credentials they have permission to access
-               * @returns Credential
-               * @throws ApiError
-               */
+               * DELETE: A JSON response indicating success:
+               * {
+                   * "status": {"success": true, "description": "Deleted"}
+                   * }
+                   *
+                   * Error Responses:
+                   * 400 Bad Request: If the request data is invalid
+                   * 401 Unauthorized: If the user is not authenticated
+                   * 403 Forbidden: If the user does not have permission to access this resource
+                   * 404 Not Found: If the credential doesn't exist
+                   * 500 Internal Server Error: If an unexpected error occurs
+                   *
+                   * Access Control:
+                   * - Requires CredentialAssignmentPermission
+                   * - Users can only manage credentials they have permission to access
+                   * @returns Credential
+                   * @throws ApiError
+                   */
       static credentialsOrgsUsersRetrieve2({
         entityId,
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -15619,34 +15622,37 @@
                * "result": {credential object}
                * }
                *
-               * DELETE: No content (204)
-               *
-               * Error Responses:
-               * 400 Bad Request: If the request data is invalid
-               * 401 Unauthorized: If the user is not authenticated
-               * 403 Forbidden: If the user does not have permission to access this resource
-               * 404 Not Found: If the credential doesn't exist
-               * 500 Internal Server Error: If an unexpected error occurs
-               *
-               * Access Control:
-               * - Requires CredentialAssignmentPermission
-               * - Users can only manage credentials they have permission to access
-               * @returns Credential
-               * @throws ApiError
-               */
+               * DELETE: A JSON response indicating success:
+               * {
+                   * "status": {"success": true, "description": "Deleted"}
+                   * }
+                   *
+                   * Error Responses:
+                   * 400 Bad Request: If the request data is invalid
+                   * 401 Unauthorized: If the user is not authenticated
+                   * 403 Forbidden: If the user does not have permission to access this resource
+                   * 404 Not Found: If the credential doesn't exist
+                   * 500 Internal Server Error: If an unexpected error occurs
+                   *
+                   * Access Control:
+                   * - Requires CredentialAssignmentPermission
+                   * - Users can only manage credentials they have permission to access
+                   * @returns Credential
+                   * @throws ApiError
+                   */
       static credentialsOrgsUsersUpdate({
         entityId,
         platformKey,
-        username,
+        userId,
         requestBody
       }) {
         return request(OpenAPI, {
           method: 'PUT',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           body: requestBody,
           mediaType: 'application/json'
@@ -15695,212 +15701,110 @@
                * "result": {credential object}
                * }
                *
-               * DELETE: No content (204)
-               *
-               * Error Responses:
-               * 400 Bad Request: If the request data is invalid
-               * 401 Unauthorized: If the user is not authenticated
-               * 403 Forbidden: If the user does not have permission to access this resource
-               * 404 Not Found: If the credential doesn't exist
-               * 500 Internal Server Error: If an unexpected error occurs
-               *
-               * Access Control:
-               * - Requires CredentialAssignmentPermission
-               * - Users can only manage credentials they have permission to access
-               * @returns void
-               * @throws ApiError
-               */
+               * DELETE: A JSON response indicating success:
+               * {
+                   * "status": {"success": true, "description": "Deleted"}
+                   * }
+                   *
+                   * Error Responses:
+                   * 400 Bad Request: If the request data is invalid
+                   * 401 Unauthorized: If the user is not authenticated
+                   * 403 Forbidden: If the user does not have permission to access this resource
+                   * 404 Not Found: If the credential doesn't exist
+                   * 500 Internal Server Error: If an unexpected error occurs
+                   *
+                   * Access Control:
+                   * - Requires CredentialAssignmentPermission
+                   * - Users can only manage credentials they have permission to access
+                   * @returns void
+                   * @throws ApiError
+                   */
       static credentialsOrgsUsersDestroy({
         entityId,
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'DELETE',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
       /**
-       * Endpoint to issue and retrieve credential assertions for a specific credential.
-       *
-       * This endpoint allows issuing new credential assertions and retrieving existing
-       * assertions for a specific credential.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The credential entity ID
-       *
-       * Methods:
-       * POST: Issue a new credential assertion
-       * GET: Retrieve assertions for a specific credential
-       *
-       * POST Request Body:
-       * A JSON object containing recipient information and any additional metadata
-       * required for issuing the credential.
-       *
-       * Returns:
-       * POST: A JSON response containing the created assertion using the AssertionSerializer format
-       * GET: A paginated list of assertions using the AssertionSerializer format
-       *
-       * Error Responses:
-       * 400 Bad Request: If the request data is invalid
-       * 401 Unauthorized: If the user is not authenticated
-       * 403 Forbidden: If the user does not have permission to access this resource
-       * 404 Not Found: If the credential doesn't exist
-       * 500 Internal Server Error: If an unexpected error occurs
        * @returns PaginatedAssertionsResponse
        * @throws ApiError
        */
       static credentialsOrgsUsersAssertionsRetrieve3({
         entityId,
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}/assertions/',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
       /**
-       * Endpoint to issue and retrieve credential assertions for a specific credential.
-       *
-       * This endpoint allows issuing new credential assertions and retrieving existing
-       * assertions for a specific credential.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The credential entity ID
-       *
-       * Methods:
-       * POST: Issue a new credential assertion
-       * GET: Retrieve assertions for a specific credential
-       *
-       * POST Request Body:
-       * A JSON object containing recipient information and any additional metadata
-       * required for issuing the credential.
-       *
-       * Returns:
-       * POST: A JSON response containing the created assertion using the AssertionSerializer format
-       * GET: A paginated list of assertions using the AssertionSerializer format
-       *
-       * Error Responses:
-       * 400 Bad Request: If the request data is invalid
-       * 401 Unauthorized: If the user is not authenticated
-       * 403 Forbidden: If the user does not have permission to access this resource
-       * 404 Not Found: If the credential doesn't exist
-       * 500 Internal Server Error: If an unexpected error occurs
        * @returns Assertion
        * @throws ApiError
        */
       static credentialsOrgsUsersAssertionsCreate({
         entityId,
         platformKey,
-        username,
+        userId,
         requestBody
       }) {
         return request(OpenAPI, {
           method: 'POST',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}/assertions/',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           body: requestBody,
           mediaType: 'application/json'
         });
       }
       /**
-       * Endpoint to issue credential assertions in bulk for a specific credential.
-       *
-       * This endpoint allows issuing credential assertions to multiple users at once.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The credential entity ID
-       *
-       * POST Request Body:
-       * A JSON object containing:
-       * - users (list): List of usernames to issue the credential to
-       * - Additional metadata required for issuing the credential
-       *
-       * Returns:
-       * A JSON response containing:
-       * {
-           * "skipped": ["username1", "username3"],  // Users that were skipped (e.g., already have the credential)
-           * "issued": ["username2", "username4"]    // Users that were successfully issued the credential
-           * }
-           *
-           * Error Responses:
-           * 400 Bad Request: If the request data is invalid or missing required fields
-           * 401 Unauthorized: If the user is not authenticated
-           * 403 Forbidden: If the user does not have permission to access this resource
-           * 404 Not Found: If the credential doesn't exist
-           * 500 Internal Server Error: If an unexpected error occurs
-           * @returns BulkCreateAssertion
-           * @throws ApiError
-           */
+       * @returns BulkCreateAssertion
+       * @throws ApiError
+       */
       static credentialsOrgsUsersAssertionsBulkCreate({
         entityId,
         platformKey,
-        username,
+        userId,
         requestBody
       }) {
         return request(OpenAPI, {
           method: 'POST',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/bulk/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}/assertions/bulk/',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           body: requestBody,
           mediaType: 'application/json'
         });
       }
       /**
-       * Endpoint to retrieve all credential assertions for a user within an organization.
-       *
-       * This endpoint provides access to all credential assertions (issued credentials)
-       * for a specific user within an organization, with support for filtering.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID to retrieve assertions for
-       *
-       * Query Parameters:
-       * course (str, optional): Filter by course ID
-       * include_revoked (bool, optional): Include revoked assertions (default: false)
-       * include_expired (bool, optional): Include expired assertions (default: false)
-       * exclude_main_tenant_assertions (bool, optional): Exclude assertions from the main tenant (default: false)
-       *
-       * Returns:
-       * A paginated response using the AssertionSerializer format
-       *
-       * Error Responses:
-       * 401 Unauthorized: If the user is not authenticated
-       * 403 Forbidden: If the user does not have permission to access this resource
-       * 404 Not Found: If the user or organization doesn't exist
-       * 500 Internal Server Error: If an unexpected error occurs
+       * A GET View that validates QueryParams and returns results to a serializer
        * @returns PaginatedAssertionsResponse
        * @throws ApiError
        */
       static credentialsOrgsUsersAssertionsRetrieve({
         platformKey,
-        username,
+        userId,
         course,
         excludeMainTenantAssertions,
         includeExpired,
@@ -15910,10 +15814,10 @@
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           query: {
             'course': course,
@@ -15932,7 +15836,7 @@
        */
       static credentialsOrgsUsersAssertionsOverTimeRetrieve({
         platformKey,
-        username,
+        userId,
         departmentId,
         endDate,
         format = 'json',
@@ -15941,10 +15845,10 @@
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions-over-time/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions-over-time/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           query: {
             'department_id': departmentId,
@@ -15956,99 +15860,41 @@
         });
       }
       /**
-       * Endpoint to retrieve and update a specific credential assertion.
-       *
-       * This endpoint allows retrieving details of a specific credential assertion
-       * and updating its status (e.g., revoking it).
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The assertion entity ID
-       *
-       * Methods:
-       * GET: Retrieve assertion details
-       * PUT: Update assertion status (e.g., revoke)
-       *
-       * PUT Request Body:
-       * A JSON object containing:
-       * - revoked (bool): Set to true to revoke the assertion
-       * - revocationReason (str): Reason for revocation (required when revoking)
-       *
-       * Returns:
-       * GET: A JSON response containing the assertion details using the AssertionSerializer format
-       * PUT: A JSON response containing the updated assertion using the AssertionSerializer format
-       *
-       * Error Responses:
-       * 400 Bad Request: If the request data is invalid
-       * 401 Unauthorized: If the user is not authenticated
-       * 403 Forbidden: If the user does not have permission to access this resource
-       * 404 Not Found: If the assertion doesn't exist
-       * 500 Internal Server Error: If an unexpected error occurs
        * @returns Assertion
        * @throws ApiError
        */
       static credentialsOrgsUsersAssertionsRetrieve2({
         entityId,
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions/{entity_id}',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions/{entity_id}',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
       /**
-       * Endpoint to retrieve and update a specific credential assertion.
-       *
-       * This endpoint allows retrieving details of a specific credential assertion
-       * and updating its status (e.g., revoking it).
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The assertion entity ID
-       *
-       * Methods:
-       * GET: Retrieve assertion details
-       * PUT: Update assertion status (e.g., revoke)
-       *
-       * PUT Request Body:
-       * A JSON object containing:
-       * - revoked (bool): Set to true to revoke the assertion
-       * - revocationReason (str): Reason for revocation (required when revoking)
-       *
-       * Returns:
-       * GET: A JSON response containing the assertion details using the AssertionSerializer format
-       * PUT: A JSON response containing the updated assertion using the AssertionSerializer format
-       *
-       * Error Responses:
-       * 400 Bad Request: If the request data is invalid
-       * 401 Unauthorized: If the user is not authenticated
-       * 403 Forbidden: If the user does not have permission to access this resource
-       * 404 Not Found: If the assertion doesn't exist
-       * 500 Internal Server Error: If an unexpected error occurs
        * @returns Assertion
        * @throws ApiError
        */
       static credentialsOrgsUsersAssertionsUpdate({
         entityId,
         platformKey,
-        username,
+        userId,
         requestBody
       }) {
         return request(OpenAPI, {
           method: 'PUT',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions/{entity_id}',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions/{entity_id}',
           path: {
             'entity_id': entityId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           body: requestBody,
           mediaType: 'application/json'
@@ -16063,15 +15909,15 @@
       static credentialsOrgsUsersAssignmentsDestroy({
         assignmentId,
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'DELETE',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/{assignment_id}',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/{assignment_id}',
           path: {
             'assignment_id': assignmentId,
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -16082,14 +15928,14 @@
        */
       static credentialsOrgsUsersAssignmentsGroupsRetrieve({
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/groups/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/groups/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -16100,14 +15946,14 @@
        */
       static credentialsOrgsUsersAssignmentsGroupsCreate({
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'POST',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/groups/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/groups/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -16121,14 +15967,14 @@
        */
       static credentialsOrgsUsersAssignmentsUsersRetrieve({
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/users/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/users/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -16139,14 +15985,14 @@
        */
       static credentialsOrgsUsersAssignmentsUsersCreate({
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'POST',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/users/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/users/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -16157,7 +16003,7 @@
        */
       static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve({
         platformKey,
-        username,
+        userId,
         departmentId,
         endDate,
         format = 'json',
@@ -16166,10 +16012,10 @@
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/course-assertions-over-time/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/course-assertions-over-time/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           query: {
             'department_id': departmentId,
@@ -16181,42 +16027,21 @@
         });
       }
       /**
-       * Endpoint to retrieve the credentials of a given tenant grouped by course.
-       *
-       * This endpoint provides access to credential data grouped by course for a specific
-       * organization/tenant, with support for pagination and filtering.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       *
-       * Query Parameters:
-       * limit (int, optional): Number of results per page (default: 10)
-       * offset (int, optional): Starting position for pagination
-       * search (str, optional): Search term e.g course_id
-       *
-       * Returns:
-       * A paginated response using the CourseCredentialSerializer format.
-       *
-       * Error Responses:
-       * 401 Unauthorized: If the user is not authenticated
-       * 403 Forbidden: If the user does not have permission to access this data
-       * 404 Not Found: If the organization doesn't exist
-       * 500 Internal Server Error: If an unexpected error occurs
        * @returns any No response body
        * @throws ApiError
        */
       static credentialsOrgsUsersCourseCredentialsList({
         platformKey,
-        username,
+        userId,
         page,
         pageSize
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/course-credentials/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/course-credentials/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           query: {
             'page': page,
@@ -16231,7 +16056,7 @@
        */
       static credentialsOrgsUsersCredentialsOverTimeRetrieve({
         platformKey,
-        username,
+        userId,
         departmentId,
         endDate,
         format = 'json',
@@ -16240,10 +16065,10 @@
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/credentials-over-time/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/credentials-over-time/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           },
           query: {
             'department_id': departmentId,
@@ -16269,14 +16094,14 @@
        */
       static credentialsOrgsUsersExternalMappingRetrieve({
         platformKey,
-        username
+        userId
       }) {
         return request(OpenAPI, {
           method: 'GET',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/external-mapping/',
           path: {
             'platform_key': platformKey,
-            'username': username
+            'user_id': userId
           }
         });
       }
@@ -16302,12 +16127,1046 @@
            */
       static credentialsOrgsUsersExternalMappingCreate({
         platformKey,
-        username,
+        userId,
         requestBody
       }) {
         return request(OpenAPI, {
           method: 'POST',
-          url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/external-mapping/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * Delete an external credential mapping.
+       *
+       * Request Body:
+       * {
+           * "credential_id": "credential-entity-id",  // Required
+           * "provider_name": "accredible"             // Required
+           * }
+           *
+           * Returns:
+           * A JSON response confirming deletion
+           * @returns void
+           * @throws ApiError
+           */
+      static credentialsOrgsUsersExternalMappingDestroy({
+        platformKey,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'DELETE',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/external-mapping/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          }
+        });
+      }
+      /**
+       * @returns UploadedImage
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersImagesRetrieve({
+        platformKey,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/images/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          }
+        });
+      }
+      /**
+       * @returns UploadedImage
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersImagesCreate({
+        platformKey,
+        userId,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/images/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * A GET View that validates QueryParams and returns results to a serializer
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersRetrieve({
+        platformKey,
+        q,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/issuers/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          query: {
+            'q': q
+          }
+        });
+      }
+      /**
+       * A GET View that validates QueryParams and returns results to a serializer
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersCreate({
+        platformKey,
+        q,
+        userId,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/issuers/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          query: {
+            'q': q
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersRetrieve2({
+        entityId,
+        platformKey,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/issuers/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'user_id': userId
+          }
+        });
+      }
+      /**
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersUpdate({
+        entityId,
+        platformKey,
+        userId,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'PUT',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/issuers/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * @returns void
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersDestroy({
+        entityId,
+        platformKey,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'DELETE',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/issuers/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'user_id': userId
+          }
+        });
+      }
+      /**
+       * @returns IssuerAuthority
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersAuthorityCreate({
+        platformKey,
+        userId,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/issuers/authority/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * Retrieve provider configurations for the platform.
+       *
+       * Query Parameters:
+       * provider_name (str, optional): Filter to a specific provider
+       * page (int, optional): Page number
+       * page_size (int, optional): Items per page
+       *
+       * Returns all configurations for the platform if the user is an admin.
+       * @returns CredentialProviderConfig
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersProviderConfigRetrieve({
+        platformKey,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/provider-config/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          }
+        });
+      }
+      /**
+       * Create or update a provider configuration.
+       *
+       * If a configuration doesn't exist for the platform and provider, it will be created.
+       * If it exists, it will be updated.
+       *
+       * Request Body:
+       * {
+           * "provider_name": "accredible",  // Required
+           * "config": {...},                 // Optional
+           * "enabled": true                  // Optional
+           * }
+           *
+           * Returns:
+           * - 201 Created: When creating a new configuration
+           * - 200 OK: When updating an existing configuration
+           * @returns CredentialProviderConfig
+           * @throws ApiError
+           */
+      static credentialsOrgsUsersProviderConfigCreate({
+        platformKey,
+        userId,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/provider-config/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * Deactivate a provider configuration (sets enabled=False).
+       *
+       * Request Body:
+       * {
+           * "provider_name": "accredible"  // Required
+           * }
+           * @returns void
+           * @throws ApiError
+           */
+      static credentialsOrgsUsersProviderConfigDestroy({
+        platformKey,
+        userId
+      }) {
+        return request(OpenAPI, {
+          method: 'DELETE',
+          url: '/api/credentials/orgs/{platform_key}/users/{user_id}/provider-config/',
+          path: {
+            'platform_key': platformKey,
+            'user_id': userId
+          }
+        });
+      }
+      /**
+       * Get all credentials for a platform with search and pagination support.
+       *
+       * Query Parameters:
+       * - platform_org: Platform org ID (takes precedence over URL org)
+       * - page: Page number (default: 1)
+       * - page_size: Items per page (default: 10, max: 100)
+       * - search: Search term to filter credentials
+       * - course: Course ID to filter credentials
+       * - program: Program ID to filter credentials
+       * @returns Credential
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersRetrieve3({
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * API View for managing credentials across a platform.
+       *
+       * This endpoint allows creating and retrieving credentials for a specific organization/tenant,
+       * with support for filtering, searching, and pagination.
+       *
+       * Path Parameters:
+       * org (str): The organization/tenant identifier
+       * user_id (str): The user ID making the request
+       *
+       * Query Parameters:
+       * # Platform identification
+       * platform_org (str, optional): Alternative platform identifier (takes precedence over URL org)
+       *
+       * # Pagination
+       * page (int, optional): Page number (default: 1)
+       * page_size (int, optional): Items per page (default: 10, max: 100)
+       *
+       * # Filtering and search
+       * search (str, optional): Search term to filter credentials by name or description
+       * course (str, optional): Course ID to filter credentials associated with a specific course
+       * program (str, optional): Program ID to filter credentials associated with a specific program
+       *
+       * Methods:
+       * GET: Retrieve credentials with filtering and pagination
+       * POST: Create a new credential
+       *
+       * POST Request Body:
+       * A JSON object containing credential details:
+       * - name (str): Credential name
+       * - description (str, optional): Credential description
+       * - issuer (str): Issuer entity ID
+       * - credential_type (str, optional): Type of credential
+       * - html_template (str, optional): HTML template for credential rendering
+       * - css_template (str, optional): CSS template for credential styling
+       * - icon_image (str, optional): URL to credential icon
+       * - background_image (str, optional): URL to credential background
+       * - thumbnail_image (str, optional): URL to credential thumbnail
+       * - criteria_url (str, optional): URL to credential criteria
+       * - criteria_text (str, optional): Text description of credential criteria
+       * - issuing_signal (str, optional): Signal that triggers credential issuance
+       *
+       * Returns:
+       * GET: A JSON response containing:
+       * {
+           * "status": {"success": true, "description": "Ok"},
+           * "result": {
+               * "next": "URL to next page",
+               * "previous": "URL to previous page",
+               * "count": 42,
+               * "data": [
+                   * {credential object},
+                   * {credential object},
+                   * ...
+                   * ],
+                   * "num_pages": 5,
+                   * "page_number": 1,
+                   * "max_page_size": 100
+                   * }
+                   * }
+                   *
+                   * POST: A JSON response containing:
+                   * {
+                       * "status": {"success": true, "description": "Created"},
+                       * "result": {credential object}
+                       * }
+                       *
+                       * Error Responses:
+                       * 400 Bad Request: If the request data is invalid
+                       * 401 Unauthorized: If the user is not authenticated
+                       * 403 Forbidden: If the user does not have permission to access this resource
+                       * 404 Not Found: If the platform doesn't exist
+                       * 500 Internal Server Error: If an unexpected error occurs
+                       *
+                       * Access Control:
+                       * - Requires CredentialAssignmentPermission
+                       * - Only public credentials are returned by default
+                       * @returns Credential
+                       * @throws ApiError
+                       */
+      static credentialsOrgsUsersCreate2({
+        platformKey,
+        username,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * API View for managing individual credentials.
+       *
+       * This endpoint allows retrieving, updating, and deleting specific credentials
+       * identified by their entity_id.
+       *
+       * Path Parameters:
+       * org (str): The organization/tenant identifier
+       * user_id (str): The user ID making the request
+       * entity_id (str): The credential entity ID
+       *
+       * Methods:
+       * GET: Retrieve a specific credential
+       * PUT: Update a specific credential
+       * DELETE: Delete a specific credential
+       *
+       * PUT Request Body:
+       * A JSON object containing credential details to update:
+       * - name (str, optional): Credential name
+       * - description (str, optional): Credential description
+       * - credential_type (str, optional): Type of credential
+       * - html_template (str, optional): HTML template for credential rendering
+       * - css_template (str, optional): CSS template for credential styling
+       * - icon_image (str, optional): URL to credential icon
+       * - background_image (str, optional): URL to credential background
+       * - thumbnail_image (str, optional): URL to credential thumbnail
+       * - criteria_url (str, optional): URL to credential criteria
+       * - criteria_text (str, optional): Text description of credential criteria
+       * - issuing_signal (str, optional): Signal that triggers credential issuance
+       *
+       * Returns:
+       * GET: A JSON response containing:
+       * {
+           * "status": {"success": true, "description": "Ok"},
+           * "result": {credential object}
+           * }
+           *
+           * PUT: A JSON response containing:
+           * {
+               * "status": {"success": true, "description": "Updated"},
+               * "result": {credential object}
+               * }
+               *
+               * DELETE: A JSON response indicating success:
+               * {
+                   * "status": {"success": true, "description": "Deleted"}
+                   * }
+                   *
+                   * Error Responses:
+                   * 400 Bad Request: If the request data is invalid
+                   * 401 Unauthorized: If the user is not authenticated
+                   * 403 Forbidden: If the user does not have permission to access this resource
+                   * 404 Not Found: If the credential doesn't exist
+                   * 500 Internal Server Error: If an unexpected error occurs
+                   *
+                   * Access Control:
+                   * - Requires CredentialAssignmentPermission
+                   * - Users can only manage credentials they have permission to access
+                   * @returns Credential
+                   * @throws ApiError
+                   */
+      static credentialsOrgsUsersRetrieve4({
+        entityId,
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * API View for managing individual credentials.
+       *
+       * This endpoint allows retrieving, updating, and deleting specific credentials
+       * identified by their entity_id.
+       *
+       * Path Parameters:
+       * org (str): The organization/tenant identifier
+       * user_id (str): The user ID making the request
+       * entity_id (str): The credential entity ID
+       *
+       * Methods:
+       * GET: Retrieve a specific credential
+       * PUT: Update a specific credential
+       * DELETE: Delete a specific credential
+       *
+       * PUT Request Body:
+       * A JSON object containing credential details to update:
+       * - name (str, optional): Credential name
+       * - description (str, optional): Credential description
+       * - credential_type (str, optional): Type of credential
+       * - html_template (str, optional): HTML template for credential rendering
+       * - css_template (str, optional): CSS template for credential styling
+       * - icon_image (str, optional): URL to credential icon
+       * - background_image (str, optional): URL to credential background
+       * - thumbnail_image (str, optional): URL to credential thumbnail
+       * - criteria_url (str, optional): URL to credential criteria
+       * - criteria_text (str, optional): Text description of credential criteria
+       * - issuing_signal (str, optional): Signal that triggers credential issuance
+       *
+       * Returns:
+       * GET: A JSON response containing:
+       * {
+           * "status": {"success": true, "description": "Ok"},
+           * "result": {credential object}
+           * }
+           *
+           * PUT: A JSON response containing:
+           * {
+               * "status": {"success": true, "description": "Updated"},
+               * "result": {credential object}
+               * }
+               *
+               * DELETE: A JSON response indicating success:
+               * {
+                   * "status": {"success": true, "description": "Deleted"}
+                   * }
+                   *
+                   * Error Responses:
+                   * 400 Bad Request: If the request data is invalid
+                   * 401 Unauthorized: If the user is not authenticated
+                   * 403 Forbidden: If the user does not have permission to access this resource
+                   * 404 Not Found: If the credential doesn't exist
+                   * 500 Internal Server Error: If an unexpected error occurs
+                   *
+                   * Access Control:
+                   * - Requires CredentialAssignmentPermission
+                   * - Users can only manage credentials they have permission to access
+                   * @returns Credential
+                   * @throws ApiError
+                   */
+      static credentialsOrgsUsersUpdate2({
+        entityId,
+        platformKey,
+        username,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'PUT',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * API View for managing individual credentials.
+       *
+       * This endpoint allows retrieving, updating, and deleting specific credentials
+       * identified by their entity_id.
+       *
+       * Path Parameters:
+       * org (str): The organization/tenant identifier
+       * user_id (str): The user ID making the request
+       * entity_id (str): The credential entity ID
+       *
+       * Methods:
+       * GET: Retrieve a specific credential
+       * PUT: Update a specific credential
+       * DELETE: Delete a specific credential
+       *
+       * PUT Request Body:
+       * A JSON object containing credential details to update:
+       * - name (str, optional): Credential name
+       * - description (str, optional): Credential description
+       * - credential_type (str, optional): Type of credential
+       * - html_template (str, optional): HTML template for credential rendering
+       * - css_template (str, optional): CSS template for credential styling
+       * - icon_image (str, optional): URL to credential icon
+       * - background_image (str, optional): URL to credential background
+       * - thumbnail_image (str, optional): URL to credential thumbnail
+       * - criteria_url (str, optional): URL to credential criteria
+       * - criteria_text (str, optional): Text description of credential criteria
+       * - issuing_signal (str, optional): Signal that triggers credential issuance
+       *
+       * Returns:
+       * GET: A JSON response containing:
+       * {
+           * "status": {"success": true, "description": "Ok"},
+           * "result": {credential object}
+           * }
+           *
+           * PUT: A JSON response containing:
+           * {
+               * "status": {"success": true, "description": "Updated"},
+               * "result": {credential object}
+               * }
+               *
+               * DELETE: A JSON response indicating success:
+               * {
+                   * "status": {"success": true, "description": "Deleted"}
+                   * }
+                   *
+                   * Error Responses:
+                   * 400 Bad Request: If the request data is invalid
+                   * 401 Unauthorized: If the user is not authenticated
+                   * 403 Forbidden: If the user does not have permission to access this resource
+                   * 404 Not Found: If the credential doesn't exist
+                   * 500 Internal Server Error: If an unexpected error occurs
+                   *
+                   * Access Control:
+                   * - Requires CredentialAssignmentPermission
+                   * - Users can only manage credentials they have permission to access
+                   * @returns void
+                   * @throws ApiError
+                   */
+      static credentialsOrgsUsersDestroy2({
+        entityId,
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'DELETE',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * @returns PaginatedAssertionsResponse
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsRetrieve6({
+        entityId,
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * @returns Assertion
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsCreate2({
+        entityId,
+        platformKey,
+        username,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * @returns BulkCreateAssertion
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsBulkCreate2({
+        entityId,
+        platformKey,
+        username,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/bulk/',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * A GET View that validates QueryParams and returns results to a serializer
+       * @returns PaginatedAssertionsResponse
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsRetrieve4({
+        platformKey,
+        username,
+        course,
+        excludeMainTenantAssertions,
+        includeExpired,
+        includeRevoked,
+        page,
+        pageSize
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          },
+          query: {
+            'course': course,
+            'exclude_main_tenant_assertions': excludeMainTenantAssertions,
+            'include_expired': includeExpired,
+            'include_revoked': includeRevoked,
+            'page': page,
+            'page_size': pageSize
+          }
+        });
+      }
+      /**
+       * Get all credentials of a given tenant
+       * @returns OvertimeWithChangeInfo
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsOverTimeRetrieve2({
+        platformKey,
+        username,
+        departmentId,
+        endDate,
+        format = 'json',
+        includeMainPlatform = true,
+        startDate
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions-over-time/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          },
+          query: {
+            'department_id': departmentId,
+            'end_date': endDate,
+            'format': format,
+            'include_main_platform': includeMainPlatform,
+            'start_date': startDate
+          }
+        });
+      }
+      /**
+       * @returns Assertion
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsRetrieve5({
+        entityId,
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * @returns Assertion
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssertionsUpdate2({
+        entityId,
+        platformKey,
+        username,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'PUT',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assertions/{entity_id}',
+          path: {
+            'entity_id': entityId,
+            'platform_key': platformKey,
+            'username': username
+          },
+          body: requestBody,
+          mediaType: 'application/json'
+        });
+      }
+      /**
+       * Delete a credential assignment using its entity_id.
+       * Only platform admins and department admins can delete assignments.
+       * @returns void
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssignmentsDestroy2({
+        assignmentId,
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'DELETE',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/{assignment_id}',
+          path: {
+            'assignment_id': assignmentId,
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * Get group assignments with department-aware filtering
+       * @returns any No response body
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssignmentsGroupsRetrieve2({
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/groups/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * Create group assignment with department access validation
+       * @returns any No response body
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssignmentsGroupsCreate2({
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/groups/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * Get assignments and their corresponding assertions based on user role:
+       * - Regular users: get only their own assignments
+       * - Platform admins: get assignments for all users in their platform
+       * - Department admins: get assignments for users in their department groups
+       * @returns any No response body
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssignmentsUsersRetrieve2({
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/users/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * Create assignments with department access validation
+       * @returns any No response body
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersAssignmentsUsersCreate2({
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/assignments/users/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * Get all credentials of a given tenant
+       * @returns OverTime
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve2({
+        platformKey,
+        username,
+        departmentId,
+        endDate,
+        format = 'json',
+        includeMainPlatform = true,
+        startDate
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/course-assertions-over-time/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          },
+          query: {
+            'department_id': departmentId,
+            'end_date': endDate,
+            'format': format,
+            'include_main_platform': includeMainPlatform,
+            'start_date': startDate
+          }
+        });
+      }
+      /**
+       * @returns any No response body
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersCourseCredentialsList2({
+        platformKey,
+        username,
+        page,
+        pageSize
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/course-credentials/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          },
+          query: {
+            'page': page,
+            'page_size': pageSize
+          }
+        });
+      }
+      /**
+       * Get all credentials of a given tenant
+       * @returns OverTime
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersCredentialsOverTimeRetrieve2({
+        platformKey,
+        username,
+        departmentId,
+        endDate,
+        format = 'json',
+        includeMainPlatform = true,
+        startDate
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/credentials-over-time/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          },
+          query: {
+            'department_id': departmentId,
+            'end_date': endDate,
+            'format': format,
+            'include_main_platform': includeMainPlatform,
+            'start_date': startDate
+          }
+        });
+      }
+      /**
+       * Retrieve external credential mappings for the platform.
+       *
+       * Query Parameters:
+       * credential_id (str, optional): Filter by credential entity_id
+       * provider_name (str, optional): Filter by provider name
+       * page (int, optional): Page number
+       * page_size (int, optional): Items per page
+       *
+       * Returns all mappings for the platform if the user is an admin.
+       * @returns ExternalCredentialMapping
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersExternalMappingRetrieve2({
+        platformKey,
+        username
+      }) {
+        return request(OpenAPI, {
+          method: 'GET',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
+          path: {
+            'platform_key': platformKey,
+            'username': username
+          }
+        });
+      }
+      /**
+       * Create or update an external credential mapping.
+       *
+       * If a mapping doesn't exist for the credential + platform + provider combination,
+       * it will be created. If it exists, it will be updated.
+       *
+       * Request Body:
+       * {
+           * "credential_id": "credential-entity-id",  // Required
+           * "provider_name": "accredible",            // Required
+           * "external_template_id": "123456",         // Optional
+           * "metadata": {}                            // Optional
+           * }
+           *
+           * Returns:
+           * - 201 Created: When creating a new mapping
+           * - 200 OK: When updating an existing mapping
+           * @returns ExternalCredentialMapping
+           * @throws ApiError
+           */
+      static credentialsOrgsUsersExternalMappingCreate2({
+        platformKey,
+        username,
+        requestBody
+      }) {
+        return request(OpenAPI, {
+          method: 'POST',
+          url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
           path: {
             'platform_key': platformKey,
             'username': username
@@ -16330,7 +17189,7 @@
            * @returns void
            * @throws ApiError
            */
-      static credentialsOrgsUsersExternalMappingDestroy({
+      static credentialsOrgsUsersExternalMappingDestroy2({
         platformKey,
         username
       }) {
@@ -16344,63 +17203,10 @@
         });
       }
       /**
-       * API View for managing uploaded images for credentials.
-       *
-       * This endpoint allows uploading new images and retrieving existing images
-       * for use with credentials (icons, backgrounds, thumbnails, etc.).
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       *
-       * Query Parameters:
-       * query (str, required for GET): Search term to filter images by name
-       *
-       * Methods:
-       * GET: Retrieve images matching a search query
-       * POST: Upload a new image
-       *
-       * POST Request Body:
-       * Multipart form data containing:
-       * - image (file, required): The image file to upload
-       * - name (str, optional): A descriptive name for the image
-       *
-       * Returns:
-       * GET: A JSON array of image objects:
-       * [
-           * {
-               * "id": 123,
-               * "name": "Logo",
-               * "image": "https://example.com/media/uploaded_images/logo.png"
-               * },
-               * {
-                   * "id": 124,
-                   * "name": "Background",
-                   * "image": "https://example.com/media/uploaded_images/background.jpg"
-                   * },
-                   * ...
-                   * ]
-                   *
-                   * POST: A JSON object containing the uploaded image details:
-                   * {
-                       * "id": 125,
-                       * "name": "Certificate Icon",
-                       * "image": "https://example.com/media/uploaded_images/certificate-icon.png"
-                       * }
-                       *
-                       * Error Responses:
-                       * 400 Bad Request: If the request data is invalid or missing required parameters
-                       * 401 Unauthorized: If the user is not authenticated
-                       * 403 Forbidden: If the user does not have permission to access this resource
-                       * 500 Internal Server Error: If an unexpected error occurs
-                       *
-                       * Access Control:
-                       * - Requires IsAdminUserOrStudentDRFMixin
-                       * - Only authenticated users with appropriate permissions can upload and retrieve images
-                       * @returns UploadedImage
-                       * @throws ApiError
-                       */
-      static credentialsOrgsUsersImagesRetrieve({
+       * @returns UploadedImage
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersImagesRetrieve2({
         platformKey,
         username
       }) {
@@ -16414,63 +17220,10 @@
         });
       }
       /**
-       * API View for managing uploaded images for credentials.
-       *
-       * This endpoint allows uploading new images and retrieving existing images
-       * for use with credentials (icons, backgrounds, thumbnails, etc.).
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       *
-       * Query Parameters:
-       * query (str, required for GET): Search term to filter images by name
-       *
-       * Methods:
-       * GET: Retrieve images matching a search query
-       * POST: Upload a new image
-       *
-       * POST Request Body:
-       * Multipart form data containing:
-       * - image (file, required): The image file to upload
-       * - name (str, optional): A descriptive name for the image
-       *
-       * Returns:
-       * GET: A JSON array of image objects:
-       * [
-           * {
-               * "id": 123,
-               * "name": "Logo",
-               * "image": "https://example.com/media/uploaded_images/logo.png"
-               * },
-               * {
-                   * "id": 124,
-                   * "name": "Background",
-                   * "image": "https://example.com/media/uploaded_images/background.jpg"
-                   * },
-                   * ...
-                   * ]
-                   *
-                   * POST: A JSON object containing the uploaded image details:
-                   * {
-                       * "id": 125,
-                       * "name": "Certificate Icon",
-                       * "image": "https://example.com/media/uploaded_images/certificate-icon.png"
-                       * }
-                       *
-                       * Error Responses:
-                       * 400 Bad Request: If the request data is invalid or missing required parameters
-                       * 401 Unauthorized: If the user is not authenticated
-                       * 403 Forbidden: If the user does not have permission to access this resource
-                       * 500 Internal Server Error: If an unexpected error occurs
-                       *
-                       * Access Control:
-                       * - Requires IsAdminUserOrStudentDRFMixin
-                       * - Only authenticated users with appropriate permissions can upload and retrieve images
-                       * @returns UploadedImage
-                       * @throws ApiError
-                       */
-      static credentialsOrgsUsersImagesCreate({
+       * @returns UploadedImage
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersImagesCreate2({
         platformKey,
         username,
         requestBody
@@ -16487,71 +17240,11 @@
         });
       }
       /**
-       * API View for managing credential issuers.
-       *
-       * This endpoint allows creating and retrieving issuers for a specific organization/tenant,
-       * with support for filtering and pagination.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       *
-       * Query Parameters:
-       * q (str, optional): Search term to filter issuers by name
-       * limit (int, optional): Number of results per page (default: 50)
-       * offset (int, optional): Starting position for pagination
-       *
-       * Methods:
-       * GET: Retrieve issuers with filtering and pagination
-       * POST: Create a new issuer
-       *
-       * POST Request Body:
-       * A JSON object containing issuer details:
-       * - name (str): Issuer name
-       * - iconImage (str, optional): URL to issuer icon
-       * - email (str, optional): Contact email for the issuer
-       * - url (str, optional): Website URL for the issuer
-       * - allowed_template_tags (array, optional): List of allowed template tags
-       *
-       * Returns:
-       * GET: A JSON response containing:
-       * {
-           * "status": {"success": true, "description": "Ok"},
-           * "result": {
-               * "next": "URL to next page",
-               * "previous": "URL to previous page",
-               * "count": 10,
-               * "data": [
-                   * {issuer object},
-                   * {issuer object},
-                   * ...
-                   * ],
-                   * "num_pages": 1,
-                   * "page_number": 1,
-                   * "max_page_size": 1000
-                   * }
-                   * }
-                   *
-                   * POST: A JSON response containing:
-                   * {
-                       * "status": {"success": true, "description": "Created"},
-                       * "result": {issuer object}
-                       * }
-                       *
-                       * Error Responses:
-                       * 400 Bad Request: If the request data is invalid
-                       * 401 Unauthorized: If the user is not authenticated
-                       * 403 Forbidden: If the user does not have permission to access this resource
-                       * 404 Not Found: If the platform doesn't exist
-                       * 500 Internal Server Error: If an unexpected error occurs
-                       *
-                       * Access Control:
-                       * - Requires IsAdminUserOrStudentDRFMixin
-                       * - Only authenticated users with appropriate permissions can manage issuers
-                       * @returns Issuer
-                       * @throws ApiError
-                       */
-      static credentialsOrgsUsersIssuersRetrieve({
+       * A GET View that validates QueryParams and returns results to a serializer
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersRetrieve3({
         platformKey,
         q,
         username
@@ -16569,71 +17262,11 @@
         });
       }
       /**
-       * API View for managing credential issuers.
-       *
-       * This endpoint allows creating and retrieving issuers for a specific organization/tenant,
-       * with support for filtering and pagination.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       *
-       * Query Parameters:
-       * q (str, optional): Search term to filter issuers by name
-       * limit (int, optional): Number of results per page (default: 50)
-       * offset (int, optional): Starting position for pagination
-       *
-       * Methods:
-       * GET: Retrieve issuers with filtering and pagination
-       * POST: Create a new issuer
-       *
-       * POST Request Body:
-       * A JSON object containing issuer details:
-       * - name (str): Issuer name
-       * - iconImage (str, optional): URL to issuer icon
-       * - email (str, optional): Contact email for the issuer
-       * - url (str, optional): Website URL for the issuer
-       * - allowed_template_tags (array, optional): List of allowed template tags
-       *
-       * Returns:
-       * GET: A JSON response containing:
-       * {
-           * "status": {"success": true, "description": "Ok"},
-           * "result": {
-               * "next": "URL to next page",
-               * "previous": "URL to previous page",
-               * "count": 10,
-               * "data": [
-                   * {issuer object},
-                   * {issuer object},
-                   * ...
-                   * ],
-                   * "num_pages": 1,
-                   * "page_number": 1,
-                   * "max_page_size": 1000
-                   * }
-                   * }
-                   *
-                   * POST: A JSON response containing:
-                   * {
-                       * "status": {"success": true, "description": "Created"},
-                       * "result": {issuer object}
-                       * }
-                       *
-                       * Error Responses:
-                       * 400 Bad Request: If the request data is invalid
-                       * 401 Unauthorized: If the user is not authenticated
-                       * 403 Forbidden: If the user does not have permission to access this resource
-                       * 404 Not Found: If the platform doesn't exist
-                       * 500 Internal Server Error: If an unexpected error occurs
-                       *
-                       * Access Control:
-                       * - Requires IsAdminUserOrStudentDRFMixin
-                       * - Only authenticated users with appropriate permissions can manage issuers
-                       * @returns Issuer
-                       * @throws ApiError
-                       */
-      static credentialsOrgsUsersIssuersCreate({
+       * A GET View that validates QueryParams and returns results to a serializer
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersCreate2({
         platformKey,
         q,
         username,
@@ -16654,75 +17287,10 @@
         });
       }
       /**
-       * API View for managing individual issuers.
-       *
-       * This endpoint allows retrieving, updating, and deleting specific issuers
-       * identified by their entity_id or org identifier.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The issuer entity ID or org identifier
-       *
-       * Methods:
-       * GET: Retrieve a specific issuer
-       * PUT: Update a specific issuer
-       * DELETE: Delete a specific issuer
-       *
-       * PUT Request Body:
-       * A JSON object containing issuer details to update:
-       * - name (str, optional): Issuer name
-       * - iconImage (str, optional): URL to issuer icon
-       * - email (str, optional): Contact email for the issuer
-       * - url (str, optional): Website URL for the issuer
-       * - allowed_template_tags (array, optional): List of allowed template tags
-       *
-       * Returns:
-       * GET: A JSON response containing the issuer details:
-       * [
-           * {
-               * "name": "Example University",
-               * "org": "example-university",
-               * "entityId": "abc123",
-               * "signatories": [...],
-               * "url": "https://example.com",
-               * "iconImage": "https://example.com/logo.png",
-               * "allowed_template_tags": [...]
-               * }
-               * ]
-               *
-               * PUT: A JSON response containing the updated issuer details:
-               * [
-                   * {
-                       * "name": "Example University",
-                       * "org": "example-university",
-                       * "entityId": "abc123",
-                       * "signatories": [...],
-                       * "url": "https://example.com",
-                       * "iconImage": "https://example.com/new-logo.png",
-                       * "allowed_template_tags": [...]
-                       * }
-                       * ]
-                       *
-                       * DELETE: A JSON response indicating success:
-                       * {
-                           * "status": {"success": true, "description": "Deleted"}
-                           * }
-                           *
-                           * Error Responses:
-                           * 400 Bad Request: If the request data is invalid
-                           * 401 Unauthorized: If the user is not authenticated
-                           * 403 Forbidden: If the user does not have permission to access this resource
-                           * 404 Not Found: If the issuer doesn't exist
-                           * 500 Internal Server Error: If an unexpected error occurs
-                           *
-                           * Access Control:
-                           * - Requires IsAdminUserOrStudentDRFMixin
-                           * - Only authenticated users with appropriate permissions can manage issuers
-                           * @returns Issuer
-                           * @throws ApiError
-                           */
-      static credentialsOrgsUsersIssuersRetrieve2({
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersRetrieve4({
         entityId,
         platformKey,
         username
@@ -16738,75 +17306,10 @@
         });
       }
       /**
-       * API View for managing individual issuers.
-       *
-       * This endpoint allows retrieving, updating, and deleting specific issuers
-       * identified by their entity_id or org identifier.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The issuer entity ID or org identifier
-       *
-       * Methods:
-       * GET: Retrieve a specific issuer
-       * PUT: Update a specific issuer
-       * DELETE: Delete a specific issuer
-       *
-       * PUT Request Body:
-       * A JSON object containing issuer details to update:
-       * - name (str, optional): Issuer name
-       * - iconImage (str, optional): URL to issuer icon
-       * - email (str, optional): Contact email for the issuer
-       * - url (str, optional): Website URL for the issuer
-       * - allowed_template_tags (array, optional): List of allowed template tags
-       *
-       * Returns:
-       * GET: A JSON response containing the issuer details:
-       * [
-           * {
-               * "name": "Example University",
-               * "org": "example-university",
-               * "entityId": "abc123",
-               * "signatories": [...],
-               * "url": "https://example.com",
-               * "iconImage": "https://example.com/logo.png",
-               * "allowed_template_tags": [...]
-               * }
-               * ]
-               *
-               * PUT: A JSON response containing the updated issuer details:
-               * [
-                   * {
-                       * "name": "Example University",
-                       * "org": "example-university",
-                       * "entityId": "abc123",
-                       * "signatories": [...],
-                       * "url": "https://example.com",
-                       * "iconImage": "https://example.com/new-logo.png",
-                       * "allowed_template_tags": [...]
-                       * }
-                       * ]
-                       *
-                       * DELETE: A JSON response indicating success:
-                       * {
-                           * "status": {"success": true, "description": "Deleted"}
-                           * }
-                           *
-                           * Error Responses:
-                           * 400 Bad Request: If the request data is invalid
-                           * 401 Unauthorized: If the user is not authenticated
-                           * 403 Forbidden: If the user does not have permission to access this resource
-                           * 404 Not Found: If the issuer doesn't exist
-                           * 500 Internal Server Error: If an unexpected error occurs
-                           *
-                           * Access Control:
-                           * - Requires IsAdminUserOrStudentDRFMixin
-                           * - Only authenticated users with appropriate permissions can manage issuers
-                           * @returns Issuer
-                           * @throws ApiError
-                           */
-      static credentialsOrgsUsersIssuersUpdate({
+       * @returns Issuer
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersUpdate2({
         entityId,
         platformKey,
         username,
@@ -16825,75 +17328,10 @@
         });
       }
       /**
-       * API View for managing individual issuers.
-       *
-       * This endpoint allows retrieving, updating, and deleting specific issuers
-       * identified by their entity_id or org identifier.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       * entity_id (str): The issuer entity ID or org identifier
-       *
-       * Methods:
-       * GET: Retrieve a specific issuer
-       * PUT: Update a specific issuer
-       * DELETE: Delete a specific issuer
-       *
-       * PUT Request Body:
-       * A JSON object containing issuer details to update:
-       * - name (str, optional): Issuer name
-       * - iconImage (str, optional): URL to issuer icon
-       * - email (str, optional): Contact email for the issuer
-       * - url (str, optional): Website URL for the issuer
-       * - allowed_template_tags (array, optional): List of allowed template tags
-       *
-       * Returns:
-       * GET: A JSON response containing the issuer details:
-       * [
-           * {
-               * "name": "Example University",
-               * "org": "example-university",
-               * "entityId": "abc123",
-               * "signatories": [...],
-               * "url": "https://example.com",
-               * "iconImage": "https://example.com/logo.png",
-               * "allowed_template_tags": [...]
-               * }
-               * ]
-               *
-               * PUT: A JSON response containing the updated issuer details:
-               * [
-                   * {
-                       * "name": "Example University",
-                       * "org": "example-university",
-                       * "entityId": "abc123",
-                       * "signatories": [...],
-                       * "url": "https://example.com",
-                       * "iconImage": "https://example.com/new-logo.png",
-                       * "allowed_template_tags": [...]
-                       * }
-                       * ]
-                       *
-                       * DELETE: A JSON response indicating success:
-                       * {
-                           * "status": {"success": true, "description": "Deleted"}
-                           * }
-                           *
-                           * Error Responses:
-                           * 400 Bad Request: If the request data is invalid
-                           * 401 Unauthorized: If the user is not authenticated
-                           * 403 Forbidden: If the user does not have permission to access this resource
-                           * 404 Not Found: If the issuer doesn't exist
-                           * 500 Internal Server Error: If an unexpected error occurs
-                           *
-                           * Access Control:
-                           * - Requires IsAdminUserOrStudentDRFMixin
-                           * - Only authenticated users with appropriate permissions can manage issuers
-                           * @returns void
-                           * @throws ApiError
-                           */
-      static credentialsOrgsUsersIssuersDestroy({
+       * @returns void
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersDestroy2({
         entityId,
         platformKey,
         username
@@ -16909,51 +17347,10 @@
         });
       }
       /**
-       * API View for managing issuer authorities (signatories).
-       *
-       * This endpoint allows creating authorities/signatories that can be associated
-       * with issuers or specific credentials.
-       *
-       * Path Parameters:
-       * org (str): The organization/tenant identifier
-       * user_id (str): The user ID making the request
-       *
-       * Methods:
-       * POST: Create a new issuer authority
-       *
-       * POST Request Body:
-       * A JSON object containing authority details:
-       * - name (str, required): Name of the signatory
-       * - title (str, required): Title of the signatory
-       * - signature (str, required): URL to the signature image
-       * - org (str, optional): Organization identifier to associate with an issuer
-       * - entityId (str, optional): Issuer entity ID to associate with
-       * - credential (str, optional): Credential entity ID to associate with
-       *
-       * Returns:
-       * POST: A JSON response containing the created authority:
-       * {
-           * "data": {
-               * "name": "John Smith",
-               * "title": "President",
-               * "signature": "https://example.com/signatures/john-smith.png"
-               * }
-               * }
-               *
-               * Error Responses:
-               * 400 Bad Request: If the request data is invalid or missing required fields
-               * 401 Unauthorized: If the user is not authenticated
-               * 403 Forbidden: If the user does not have permission to access this resource
-               * 404 Not Found: If the issuer or credential doesn't exist
-               * 500 Internal Server Error: If an unexpected error occurs
-               *
-               * Access Control:
-               * - Requires IsAdminUserOrStudentDRFMixin
-               * - Only authenticated users with appropriate permissions can manage authorities
-               * @returns IssuerAuthority
-               * @throws ApiError
-               */
-      static credentialsOrgsUsersIssuersAuthorityCreate({
+       * @returns IssuerAuthority
+       * @throws ApiError
+       */
+      static credentialsOrgsUsersIssuersAuthorityCreate2({
         platformKey,
         username,
         requestBody
@@ -16981,7 +17378,7 @@
        * @returns CredentialProviderConfig
        * @throws ApiError
        */
-      static credentialsOrgsUsersProviderConfigRetrieve({
+      static credentialsOrgsUsersProviderConfigRetrieve2({
         platformKey,
         username
       }) {
@@ -17013,7 +17410,7 @@
            * @returns CredentialProviderConfig
            * @throws ApiError
            */
-      static credentialsOrgsUsersProviderConfigCreate({
+      static credentialsOrgsUsersProviderConfigCreate2({
         platformKey,
         username,
         requestBody
@@ -17039,7 +17436,7 @@
            * @returns void
            * @throws ApiError
            */
-      static credentialsOrgsUsersProviderConfigDestroy({
+      static credentialsOrgsUsersProviderConfigDestroy2({
         platformKey,
         username
       }) {