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

package/dist/index.esm.js

@@ -108,7 +108,7 @@ class CancelablePromise {
 
 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,
@@ -15390,14 +15390,14 @@ class CredentialsService {
    */
   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
       }
     });
   }
@@ -15483,15 +15483,15 @@ class CredentialsService {
                    */
   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'
@@ -15540,33 +15540,36 @@ class CredentialsService {
            * "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
       }
     });
   }
@@ -15613,34 +15616,37 @@ class CredentialsService {
            * "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'
@@ -15689,212 +15695,110 @@ class CredentialsService {
            * "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,
@@ -15904,10 +15808,10 @@ class CredentialsService {
   }) {
     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,
@@ -15926,7 +15830,7 @@ class CredentialsService {
    */
   static credentialsOrgsUsersAssertionsOverTimeRetrieve({
     platformKey,
-    username,
+    userId,
     departmentId,
     endDate,
     format = 'json',
@@ -15935,10 +15839,10 @@ class CredentialsService {
   }) {
     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,
@@ -15950,99 +15854,41 @@ class CredentialsService {
     });
   }
   /**
-   * 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'
@@ -16057,15 +15903,15 @@ class CredentialsService {
   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
       }
     });
   }
@@ -16076,14 +15922,14 @@ class CredentialsService {
    */
   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
       }
     });
   }
@@ -16094,14 +15940,14 @@ class CredentialsService {
    */
   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
       }
     });
   }
@@ -16115,14 +15961,14 @@ class CredentialsService {
    */
   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
       }
     });
   }
@@ -16133,14 +15979,14 @@ class CredentialsService {
    */
   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
       }
     });
   }
@@ -16151,7 +15997,7 @@ class CredentialsService {
    */
   static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve({
     platformKey,
-    username,
+    userId,
     departmentId,
     endDate,
     format = 'json',
@@ -16160,10 +16006,10 @@ class CredentialsService {
   }) {
     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,
@@ -16175,42 +16021,21 @@ class CredentialsService {
     });
   }
   /**
-   * 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,
@@ -16225,7 +16050,7 @@ class CredentialsService {
    */
   static credentialsOrgsUsersCredentialsOverTimeRetrieve({
     platformKey,
-    username,
+    userId,
     departmentId,
     endDate,
     format = 'json',
@@ -16234,10 +16059,10 @@ class CredentialsService {
   }) {
     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,
@@ -16263,14 +16088,14 @@ class CredentialsService {
    */
   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
       }
     });
   }
@@ -16296,12 +16121,1046 @@ class CredentialsService {
        */
   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
@@ -16324,7 +17183,7 @@ class CredentialsService {
        * @returns void
        * @throws ApiError
        */
-  static credentialsOrgsUsersExternalMappingDestroy({
+  static credentialsOrgsUsersExternalMappingDestroy2({
     platformKey,
     username
   }) {
@@ -16338,63 +17197,10 @@ class CredentialsService {
     });
   }
   /**
-   * 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
   }) {
@@ -16408,63 +17214,10 @@ class CredentialsService {
     });
   }
   /**
-   * 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
@@ -16481,71 +17234,11 @@ class CredentialsService {
     });
   }
   /**
-   * 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
@@ -16563,71 +17256,11 @@ class CredentialsService {
     });
   }
   /**
-   * 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,
@@ -16648,75 +17281,10 @@ class CredentialsService {
     });
   }
   /**
-   * 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
@@ -16732,75 +17300,10 @@ class CredentialsService {
     });
   }
   /**
-   * 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,
@@ -16819,75 +17322,10 @@ class CredentialsService {
     });
   }
   /**
-   * 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
@@ -16903,51 +17341,10 @@ class CredentialsService {
     });
   }
   /**
-   * 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
@@ -16975,7 +17372,7 @@ class CredentialsService {
    * @returns CredentialProviderConfig
    * @throws ApiError
    */
-  static credentialsOrgsUsersProviderConfigRetrieve({
+  static credentialsOrgsUsersProviderConfigRetrieve2({
     platformKey,
     username
   }) {
@@ -17007,7 +17404,7 @@ class CredentialsService {
        * @returns CredentialProviderConfig
        * @throws ApiError
        */
-  static credentialsOrgsUsersProviderConfigCreate({
+  static credentialsOrgsUsersProviderConfigCreate2({
     platformKey,
     username,
     requestBody
@@ -17033,7 +17430,7 @@ class CredentialsService {
        * @returns void
        * @throws ApiError
        */
-  static credentialsOrgsUsersProviderConfigDestroy({
+  static credentialsOrgsUsersProviderConfigDestroy2({
     platformKey,
     username
   }) {