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

package/src/services/CredentialsService.ts

@@ -82,17 +82,17 @@ export class CredentialsService {
      */
     public static credentialsOrgsUsersRetrieve({
         platformKey,
-        username,
+        userId,
     }: {
         platformKey: string,
-        username: string,
+        userId: number,
     }): CancelablePromise<Credential> {
         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,
             },
         });
     }
@@ -178,19 +178,19 @@ export class CredentialsService {
                      */
                     public static credentialsOrgsUsersCreate({
                         platformKey,
-                        username,
+                        userId,
                         requestBody,
                     }: {
                         platformKey: string,
-                        username: string,
+                        userId: number,
                         requestBody: Credential,
                     }): CancelablePromise<Credential> {
                         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',
@@ -239,166 +239,91 @@ export 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
-                             */
-                            public static credentialsOrgsUsersRetrieve2({
-                                entityId,
-                                platformKey,
-                                username,
-                            }: {
-                                entityId: string,
-                                platformKey: string,
-                                username: string,
-                            }): CancelablePromise<Credential> {
-                                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:
+                             * DELETE: A JSON response indicating success:
                              * {
-                                 * "status": {"success": true, "description": "Ok"},
-                                 * "result": {credential object}
+                                 * "status": {"success": true, "description": "Deleted"}
                                  * }
                                  *
-                                 * PUT: A JSON response containing:
+                                 * 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
+                                 */
+                                public static credentialsOrgsUsersRetrieve2({
+                                    entityId,
+                                    platformKey,
+                                    userId,
+                                }: {
+                                    entityId: string,
+                                    platformKey: string,
+                                    userId: number,
+                                }): CancelablePromise<Credential> {
+                                    return __request(OpenAPI, {
+                                        method: 'GET',
+                                        url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}',
+                                        path: {
+                                            'entity_id': entityId,
+                                            'platform_key': platformKey,
+                                            'user_id': userId,
+                                        },
+                                    });
+                                }
+                                /**
+                                 * 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": "Updated"},
+                                     * "status": {"success": true, "description": "Ok"},
                                      * "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
-                                     */
-                                    public static credentialsOrgsUsersUpdate({
-                                        entityId,
-                                        platformKey,
-                                        username,
-                                        requestBody,
-                                    }: {
-                                        entityId: string,
-                                        platformKey: string,
-                                        username: string,
-                                        requestBody: Credential,
-                                    }): CancelablePromise<Credential> {
-                                        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:
+                                     * PUT: A JSON response containing:
                                      * {
-                                         * "status": {"success": true, "description": "Ok"},
+                                         * "status": {"success": true, "description": "Updated"},
                                          * "result": {credential object}
                                          * }
                                          *
-                                         * PUT: A JSON response containing:
+                                         * DELETE: A JSON response indicating success:
                                          * {
-                                             * "status": {"success": true, "description": "Updated"},
-                                             * "result": {credential object}
+                                             * "status": {"success": true, "description": "Deleted"}
                                              * }
                                              *
-                                             * DELETE: No content (204)
-                                             *
                                              * Error Responses:
                                              * 400 Bad Request: If the request data is invalid
                                              * 401 Unauthorized: If the user is not authenticated
@@ -409,857 +334,1003 @@ export class CredentialsService {
                                              * Access Control:
                                              * - Requires CredentialAssignmentPermission
                                              * - Users can only manage credentials they have permission to access
-                                             * @returns void
-                                             * @throws ApiError
-                                             */
-                                            public static credentialsOrgsUsersDestroy({
-                                                entityId,
-                                                platformKey,
-                                                username,
-                                            }: {
-                                                entityId: string,
-                                                platformKey: string,
-                                                username: string,
-                                            }): CancelablePromise<void> {
-                                                return __request(OpenAPI, {
-                                                    method: 'DELETE',
-                                                    url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}',
-                                                    path: {
-                                                        'entity_id': entityId,
-                                                        'platform_key': platformKey,
-                                                        'username': username,
-                                                    },
-                                                });
-                                            }
-                                            /**
-                                             * 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
-                                             */
-                                            public static credentialsOrgsUsersAssertionsRetrieve3({
-                                                entityId,
-                                                platformKey,
-                                                username,
-                                            }: {
-                                                entityId: string,
-                                                platformKey: string,
-                                                username: string,
-                                            }): CancelablePromise<PaginatedAssertionsResponse> {
-                                                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,
-                                                    },
-                                                });
-                                            }
-                                            /**
-                                             * 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
+                                             * @returns Credential
                                              * @throws ApiError
                                              */
-                                            public static credentialsOrgsUsersAssertionsCreate({
+                                            public static credentialsOrgsUsersUpdate({
                                                 entityId,
                                                 platformKey,
-                                                username,
+                                                userId,
                                                 requestBody,
                                             }: {
                                                 entityId: string,
                                                 platformKey: string,
-                                                username: string,
-                                                requestBody: Assertion,
-                                            }): CancelablePromise<Assertion> {
+                                                userId: number,
+                                                requestBody: Credential,
+                                            }): CancelablePromise<Credential> {
                                                 return __request(OpenAPI, {
-                                                    method: 'POST',
-                                                    url: '/api/credentials/orgs/{platform_key}/users/{username}/{entity_id}/assertions/',
+                                                    method: 'PUT',
+                                                    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',
                                                 });
                                             }
                                             /**
-                                             * Endpoint to issue credential assertions in bulk for a specific credential.
+                                             * API View for managing individual credentials.
                                              *
-                                             * This endpoint allows issuing credential assertions to multiple users at once.
+                                             * 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
                                              *
-                                             * POST Request Body:
-                                             * A JSON object containing:
-                                             * - users (list): List of usernames to issue the credential to
-                                             * - Additional metadata required for issuing the credential
+                                             * 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:
-                                             * A JSON response containing:
+                                             * GET: 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
+                                                 * "status": {"success": true, "description": "Ok"},
+                                                 * "result": {credential object}
                                                  * }
                                                  *
-                                                 * 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
-                                                 */
-                                                public static credentialsOrgsUsersAssertionsBulkCreate({
-                                                    entityId,
-                                                    platformKey,
-                                                    username,
-                                                    requestBody,
-                                                }: {
-                                                    entityId: string,
-                                                    platformKey: string,
-                                                    username: string,
-                                                    requestBody: BulkCreateAssertion,
-                                                }): CancelablePromise<BulkCreateAssertion> {
-                                                    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',
-                                                    });
-                                                }
-                                                /**
-                                                 * 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
-                                                 * @returns PaginatedAssertionsResponse
-                                                 * @throws ApiError
-                                                 */
-                                                public static credentialsOrgsUsersAssertionsRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                    course,
-                                                    excludeMainTenantAssertions,
-                                                    includeExpired,
-                                                    includeRevoked,
-                                                    page,
-                                                    pageSize,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                    course?: string,
-                                                    excludeMainTenantAssertions?: boolean,
-                                                    includeExpired?: boolean,
-                                                    includeRevoked?: boolean,
-                                                    page?: number,
-                                                    pageSize?: number,
-                                                }): CancelablePromise<PaginatedAssertionsResponse> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersAssertionsOverTimeRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                    departmentId,
-                                                    endDate,
-                                                    format = 'json',
-                                                    includeMainPlatform = true,
-                                                    startDate,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                    /**
-                                                     * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
-                                                     */
-                                                    departmentId?: number,
-                                                    /**
-                                                     * end date. ISO 8601
-                                                     */
-                                                    endDate?: string,
-                                                    /**
-                                                     * Format
-                                                     *
-                                                     * * `json` - json
-                                                     */
-                                                    format?: 'json',
-                                                    /**
-                                                     * Include main platform data
-                                                     */
-                                                    includeMainPlatform?: boolean,
-                                                    /**
-                                                     * start date. ISO 8601
-                                                     */
-                                                    startDate?: string,
-                                                }): CancelablePromise<OvertimeWithChangeInfo> {
-                                                    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,
-                                                        },
-                                                    });
-                                                }
-                                                /**
-                                                 * 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
-                                                 */
-                                                public static credentialsOrgsUsersAssertionsRetrieve2({
-                                                    entityId,
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    entityId: string,
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<Assertion> {
-                                                    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,
-                                                        },
-                                                    });
-                                                }
-                                                /**
-                                                 * 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
-                                                 */
-                                                public static credentialsOrgsUsersAssertionsUpdate({
-                                                    entityId,
-                                                    platformKey,
-                                                    username,
-                                                    requestBody,
-                                                }: {
-                                                    entityId: string,
-                                                    platformKey: string,
-                                                    username: string,
-                                                    requestBody: Assertion,
-                                                }): CancelablePromise<Assertion> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersAssignmentsDestroy({
-                                                    assignmentId,
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    assignmentId: string,
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<void> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersAssignmentsGroupsRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<any> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersAssignmentsGroupsCreate({
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<any> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersAssignmentsUsersRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<any> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersAssignmentsUsersCreate({
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<any> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                    departmentId,
-                                                    endDate,
-                                                    format = 'json',
-                                                    includeMainPlatform = true,
-                                                    startDate,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                    /**
-                                                     * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
-                                                     */
-                                                    departmentId?: number,
-                                                    /**
-                                                     * end date. ISO 8601
-                                                     */
-                                                    endDate?: string,
-                                                    /**
-                                                     * Format
-                                                     *
-                                                     * * `json` - json
-                                                     */
-                                                    format?: 'json',
-                                                    /**
-                                                     * Include main platform data
-                                                     */
-                                                    includeMainPlatform?: boolean,
-                                                    /**
-                                                     * start date. ISO 8601
-                                                     */
-                                                    startDate?: string,
-                                                }): CancelablePromise<OverTime> {
-                                                    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,
-                                                        },
-                                                    });
-                                                }
-                                                /**
-                                                 * 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
-                                                 */
-                                                public static credentialsOrgsUsersCourseCredentialsList({
-                                                    platformKey,
-                                                    username,
-                                                    page,
-                                                    pageSize,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                    /**
-                                                     * A page number within the paginated result set.
-                                                     */
-                                                    page?: number,
-                                                    /**
-                                                     * Number of results to return per page.
-                                                     */
-                                                    pageSize?: number,
-                                                }): CancelablePromise<any> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersCredentialsOverTimeRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                    departmentId,
-                                                    endDate,
-                                                    format = 'json',
-                                                    includeMainPlatform = true,
-                                                    startDate,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                    /**
-                                                     * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
-                                                     */
-                                                    departmentId?: number,
-                                                    /**
-                                                     * end date. ISO 8601
-                                                     */
-                                                    endDate?: string,
-                                                    /**
-                                                     * Format
-                                                     *
-                                                     * * `json` - json
-                                                     */
-                                                    format?: 'json',
-                                                    /**
-                                                     * Include main platform data
-                                                     */
-                                                    includeMainPlatform?: boolean,
-                                                    /**
-                                                     * start date. ISO 8601
-                                                     */
-                                                    startDate?: string,
-                                                }): CancelablePromise<OverTime> {
-                                                    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
-                                                 */
-                                                public static credentialsOrgsUsersExternalMappingRetrieve({
-                                                    platformKey,
-                                                    username,
-                                                }: {
-                                                    platformKey: string,
-                                                    username: string,
-                                                }): CancelablePromise<ExternalCredentialMapping> {
-                                                    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:
+                                                 * PUT: A JSON response containing:
                                                  * {
-                                                     * "credential_id": "credential-entity-id",  // Required
-                                                     * "provider_name": "accredible",            // Required
-                                                     * "external_template_id": "123456",         // Optional
-                                                     * "metadata": {}                            // Optional
+                                                     * "status": {"success": true, "description": "Updated"},
+                                                     * "result": {credential object}
                                                      * }
                                                      *
-                                                     * Returns:
-                                                     * - 201 Created: When creating a new mapping
-                                                     * - 200 OK: When updating an existing mapping
-                                                     * @returns ExternalCredentialMapping
-                                                     * @throws ApiError
-                                                     */
-                                                    public static credentialsOrgsUsersExternalMappingCreate({
-                                                        platformKey,
-                                                        username,
-                                                        requestBody,
-                                                    }: {
-                                                        platformKey: string,
-                                                        username: string,
-                                                        requestBody: ExternalCredentialMapping,
-                                                    }): CancelablePromise<ExternalCredentialMapping> {
-                                                        return __request(OpenAPI, {
-                                                            method: 'POST',
-                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
-                                                            path: {
-                                                                'platform_key': platformKey,
-                                                                'username': username,
-                                                            },
-                                                            body: requestBody,
-                                                            mediaType: 'application/json',
-                                                        });
-                                                    }
-                                                    /**
-                                                     * Delete an external credential mapping.
-                                                     *
-                                                     * Request Body:
+                                                     * DELETE: A JSON response indicating success:
                                                      * {
-                                                         * "credential_id": "credential-entity-id",  // Required
-                                                         * "provider_name": "accredible"             // Required
+                                                         * "status": {"success": true, "description": "Deleted"}
                                                          * }
                                                          *
-                                                         * Returns:
-                                                         * A JSON response confirming deletion
+                                                         * 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
                                                          */
-                                                        public static credentialsOrgsUsersExternalMappingDestroy({
+                                                        public static credentialsOrgsUsersDestroy({
+                                                            entityId,
                                                             platformKey,
-                                                            username,
+                                                            userId,
                                                         }: {
+                                                            entityId: string,
                                                             platformKey: string,
-                                                            username: string,
+                                                            userId: number,
                                                         }): CancelablePromise<void> {
                                                             return __request(OpenAPI, {
                                                                 method: 'DELETE',
-                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}',
                                                                 path: {
+                                                                    'entity_id': entityId,
                                                                     'platform_key': platformKey,
-                                                                    'username': username,
+                                                                    'user_id': userId,
                                                                 },
                                                             });
                                                         }
                                                         /**
-                                                         * 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
+                                                         * @returns PaginatedAssertionsResponse
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsRetrieve3({
+                                                            entityId,
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            entityId: string,
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<PaginatedAssertionsResponse> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}/assertions/',
+                                                                path: {
+                                                                    'entity_id': entityId,
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * @returns Assertion
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsCreate({
+                                                            entityId,
+                                                            platformKey,
+                                                            userId,
+                                                            requestBody,
+                                                        }: {
+                                                            entityId: string,
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            requestBody: Assertion,
+                                                        }): CancelablePromise<Assertion> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'POST',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}/assertions/',
+                                                                path: {
+                                                                    'entity_id': entityId,
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                body: requestBody,
+                                                                mediaType: 'application/json',
+                                                            });
+                                                        }
+                                                        /**
+                                                         * @returns BulkCreateAssertion
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsBulkCreate({
+                                                            entityId,
+                                                            platformKey,
+                                                            userId,
+                                                            requestBody,
+                                                        }: {
+                                                            entityId: string,
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            requestBody: BulkCreateAssertion,
+                                                        }): CancelablePromise<BulkCreateAssertion> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'POST',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/{entity_id}/assertions/bulk/',
+                                                                path: {
+                                                                    'entity_id': entityId,
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                body: requestBody,
+                                                                mediaType: 'application/json',
+                                                            });
+                                                        }
+                                                        /**
+                                                         * A GET View that validates QueryParams and returns results to a serializer
+                                                         * @returns PaginatedAssertionsResponse
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                            course,
+                                                            excludeMainTenantAssertions,
+                                                            includeExpired,
+                                                            includeRevoked,
+                                                            page,
+                                                            pageSize,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            course?: string,
+                                                            excludeMainTenantAssertions?: boolean,
+                                                            includeExpired?: boolean,
+                                                            includeRevoked?: boolean,
+                                                            page?: number,
+                                                            pageSize?: number,
+                                                        }): CancelablePromise<PaginatedAssertionsResponse> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                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
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsOverTimeRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                            departmentId,
+                                                            endDate,
+                                                            format = 'json',
+                                                            includeMainPlatform = true,
+                                                            startDate,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            /**
+                                                             * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                             */
+                                                            departmentId?: number,
+                                                            /**
+                                                             * end date. ISO 8601
+                                                             */
+                                                            endDate?: string,
+                                                            /**
+                                                             * Format
+                                                             *
+                                                             * * `json` - json
+                                                             */
+                                                            format?: 'json',
+                                                            /**
+                                                             * Include main platform data
+                                                             */
+                                                            includeMainPlatform?: boolean,
+                                                            /**
+                                                             * start date. ISO 8601
+                                                             */
+                                                            startDate?: string,
+                                                        }): CancelablePromise<OvertimeWithChangeInfo> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions-over-time/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                query: {
+                                                                    'department_id': departmentId,
+                                                                    'end_date': endDate,
+                                                                    'format': format,
+                                                                    'include_main_platform': includeMainPlatform,
+                                                                    'start_date': startDate,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * @returns Assertion
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsRetrieve2({
+                                                            entityId,
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            entityId: string,
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<Assertion> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions/{entity_id}',
+                                                                path: {
+                                                                    'entity_id': entityId,
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * @returns Assertion
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssertionsUpdate({
+                                                            entityId,
+                                                            platformKey,
+                                                            userId,
+                                                            requestBody,
+                                                        }: {
+                                                            entityId: string,
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            requestBody: Assertion,
+                                                        }): CancelablePromise<Assertion> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'PUT',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assertions/{entity_id}',
+                                                                path: {
+                                                                    'entity_id': entityId,
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                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
+                                                         */
+                                                        public static credentialsOrgsUsersAssignmentsDestroy({
+                                                            assignmentId,
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            assignmentId: string,
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<void> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'DELETE',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/{assignment_id}',
+                                                                path: {
+                                                                    'assignment_id': assignmentId,
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Get group assignments with department-aware filtering
+                                                         * @returns any No response body
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssignmentsGroupsRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<any> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/groups/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Create group assignment with department access validation
+                                                         * @returns any No response body
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssignmentsGroupsCreate({
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<any> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'POST',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/groups/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * 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
+                                                         */
+                                                        public static credentialsOrgsUsersAssignmentsUsersRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<any> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/users/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Create assignments with department access validation
+                                                         * @returns any No response body
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersAssignmentsUsersCreate({
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<any> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'POST',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/assignments/users/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Get all credentials of a given tenant
+                                                         * @returns OverTime
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                            departmentId,
+                                                            endDate,
+                                                            format = 'json',
+                                                            includeMainPlatform = true,
+                                                            startDate,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            /**
+                                                             * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                             */
+                                                            departmentId?: number,
+                                                            /**
+                                                             * end date. ISO 8601
+                                                             */
+                                                            endDate?: string,
+                                                            /**
+                                                             * Format
+                                                             *
+                                                             * * `json` - json
+                                                             */
+                                                            format?: 'json',
+                                                            /**
+                                                             * Include main platform data
+                                                             */
+                                                            includeMainPlatform?: boolean,
+                                                            /**
+                                                             * start date. ISO 8601
+                                                             */
+                                                            startDate?: string,
+                                                        }): CancelablePromise<OverTime> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/course-assertions-over-time/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                query: {
+                                                                    'department_id': departmentId,
+                                                                    'end_date': endDate,
+                                                                    'format': format,
+                                                                    'include_main_platform': includeMainPlatform,
+                                                                    'start_date': startDate,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * @returns any No response body
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersCourseCredentialsList({
+                                                            platformKey,
+                                                            userId,
+                                                            page,
+                                                            pageSize,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            /**
+                                                             * A page number within the paginated result set.
+                                                             */
+                                                            page?: number,
+                                                            /**
+                                                             * Number of results to return per page.
+                                                             */
+                                                            pageSize?: number,
+                                                        }): CancelablePromise<any> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/course-credentials/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                query: {
+                                                                    'page': page,
+                                                                    'page_size': pageSize,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Get all credentials of a given tenant
+                                                         * @returns OverTime
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersCredentialsOverTimeRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                            departmentId,
+                                                            endDate,
+                                                            format = 'json',
+                                                            includeMainPlatform = true,
+                                                            startDate,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                            /**
+                                                             * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                             */
+                                                            departmentId?: number,
+                                                            /**
+                                                             * end date. ISO 8601
+                                                             */
+                                                            endDate?: string,
+                                                            /**
+                                                             * Format
+                                                             *
+                                                             * * `json` - json
+                                                             */
+                                                            format?: 'json',
+                                                            /**
+                                                             * Include main platform data
+                                                             */
+                                                            includeMainPlatform?: boolean,
+                                                            /**
+                                                             * start date. ISO 8601
+                                                             */
+                                                            startDate?: string,
+                                                        }): CancelablePromise<OverTime> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/credentials-over-time/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                                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:
-                                                         * query (str, required for GET): Search term to filter images by name
+                                                         * 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
                                                          *
-                                                         * Methods:
-                                                         * GET: Retrieve images matching a search query
-                                                         * POST: Upload a new image
+                                                         * Returns all mappings for the platform if the user is an admin.
+                                                         * @returns ExternalCredentialMapping
+                                                         * @throws ApiError
+                                                         */
+                                                        public static credentialsOrgsUsersExternalMappingRetrieve({
+                                                            platformKey,
+                                                            userId,
+                                                        }: {
+                                                            platformKey: string,
+                                                            userId: number,
+                                                        }): CancelablePromise<ExternalCredentialMapping> {
+                                                            return __request(OpenAPI, {
+                                                                method: 'GET',
+                                                                url: '/api/credentials/orgs/{platform_key}/users/{user_id}/external-mapping/',
+                                                                path: {
+                                                                    'platform_key': platformKey,
+                                                                    'user_id': userId,
+                                                                },
+                                                            });
+                                                        }
+                                                        /**
+                                                         * Create or update an external credential mapping.
                                                          *
-                                                         * POST Request Body:
-                                                         * Multipart form data containing:
-                                                         * - image (file, required): The image file to upload
-                                                         * - name (str, optional): A descriptive name for the image
+                                                         * If a mapping doesn't exist for the credential + platform + provider combination,
+                                                         * it will be created. If it exists, it will be updated.
                                                          *
-                                                         * Returns:
-                                                         * GET: A JSON array of image objects:
-                                                         * [
+                                                         * 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
+                                                             */
+                                                            public static credentialsOrgsUsersExternalMappingCreate({
+                                                                platformKey,
+                                                                userId,
+                                                                requestBody,
+                                                            }: {
+                                                                platformKey: string,
+                                                                userId: number,
+                                                                requestBody: ExternalCredentialMapping,
+                                                            }): CancelablePromise<ExternalCredentialMapping> {
+                                                                return __request(OpenAPI, {
+                                                                    method: 'POST',
+                                                                    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:
                                                              * {
-                                                                 * "id": 123,
-                                                                 * "name": "Logo",
-                                                                 * "image": "https://example.com/media/uploaded_images/logo.png"
-                                                                 * },
+                                                                 * "credential_id": "credential-entity-id",  // Required
+                                                                 * "provider_name": "accredible"             // Required
+                                                                 * }
+                                                                 *
+                                                                 * Returns:
+                                                                 * A JSON response confirming deletion
+                                                                 * @returns void
+                                                                 * @throws ApiError
+                                                                 */
+                                                                public static credentialsOrgsUsersExternalMappingDestroy({
+                                                                    platformKey,
+                                                                    userId,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                }): CancelablePromise<void> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersImagesRetrieve({
+                                                                    platformKey,
+                                                                    userId,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                }): CancelablePromise<UploadedImage> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersImagesCreate({
+                                                                    platformKey,
+                                                                    userId,
+                                                                    requestBody,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                    requestBody?: UploadedImage,
+                                                                }): CancelablePromise<UploadedImage> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersIssuersRetrieve({
+                                                                    platformKey,
+                                                                    q,
+                                                                    userId,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    q: string,
+                                                                    userId: number,
+                                                                }): CancelablePromise<Issuer> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersIssuersCreate({
+                                                                    platformKey,
+                                                                    q,
+                                                                    userId,
+                                                                    requestBody,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    q: string,
+                                                                    userId: number,
+                                                                    requestBody: Issuer,
+                                                                }): CancelablePromise<Issuer> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersIssuersRetrieve2({
+                                                                    entityId,
+                                                                    platformKey,
+                                                                    userId,
+                                                                }: {
+                                                                    entityId: string,
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                }): CancelablePromise<Issuer> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersIssuersUpdate({
+                                                                    entityId,
+                                                                    platformKey,
+                                                                    userId,
+                                                                    requestBody,
+                                                                }: {
+                                                                    entityId: string,
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                    requestBody: Issuer,
+                                                                }): CancelablePromise<Issuer> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersIssuersDestroy({
+                                                                    entityId,
+                                                                    platformKey,
+                                                                    userId,
+                                                                }: {
+                                                                    entityId: string,
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                }): CancelablePromise<void> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersIssuersAuthorityCreate({
+                                                                    platformKey,
+                                                                    userId,
+                                                                    requestBody,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                    requestBody: IssuerAuthority,
+                                                                }): CancelablePromise<IssuerAuthority> {
+                                                                    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
+                                                                 */
+                                                                public static credentialsOrgsUsersProviderConfigRetrieve({
+                                                                    platformKey,
+                                                                    userId,
+                                                                }: {
+                                                                    platformKey: string,
+                                                                    userId: number,
+                                                                }): CancelablePromise<CredentialProviderConfig> {
+                                                                    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:
                                                                  * {
-                                                                     * "id": 124,
-                                                                     * "name": "Background",
-                                                                     * "image": "https://example.com/media/uploaded_images/background.jpg"
-                                                                     * },
-                                                                     * ...
-                                                                     * ]
+                                                                     * "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
+                                                                     */
+                                                                    public static credentialsOrgsUsersProviderConfigCreate({
+                                                                        platformKey,
+                                                                        userId,
+                                                                        requestBody,
+                                                                    }: {
+                                                                        platformKey: string,
+                                                                        userId: number,
+                                                                        requestBody: CredentialProviderConfig,
+                                                                    }): CancelablePromise<CredentialProviderConfig> {
+                                                                        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).
                                                                      *
-                                                                     * POST: A JSON object containing the uploaded image details:
+                                                                     * Request Body:
                                                                      * {
-                                                                         * "id": 125,
-                                                                         * "name": "Certificate Icon",
-                                                                         * "image": "https://example.com/media/uploaded_images/certificate-icon.png"
+                                                                         * "provider_name": "accredible"  // Required
                                                                          * }
+                                                                         * @returns void
+                                                                         * @throws ApiError
+                                                                         */
+                                                                        public static credentialsOrgsUsersProviderConfigDestroy({
+                                                                            platformKey,
+                                                                            userId,
+                                                                        }: {
+                                                                            platformKey: string,
+                                                                            userId: number,
+                                                                        }): CancelablePromise<void> {
+                                                                            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.
                                                                          *
-                                                                         * 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
+                                                                         * 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
                                                                          */
-                                                                        public static credentialsOrgsUsersImagesRetrieve({
+                                                                        public static credentialsOrgsUsersRetrieve3({
                                                                             platformKey,
                                                                             username,
                                                                         }: {
                                                                             platformKey: string,
                                                                             username: string,
-                                                                        }): CancelablePromise<UploadedImage> {
+                                                                        }): CancelablePromise<Credential> {
                                                                             return __request(OpenAPI, {
                                                                                 method: 'GET',
-                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/images/',
+                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/',
                                                                                 path: {
                                                                                     'platform_key': platformKey,
                                                                                     'username': username,
@@ -1267,74 +1338,97 @@ export class CredentialsService {
                                                                             });
                                                                         }
                                                                         /**
-                                                                         * API View for managing uploaded images for credentials.
+                                                                         * API View for managing credentials across a platform.
                                                                          *
-                                                                         * This endpoint allows uploading new images and retrieving existing images
-                                                                         * for use with credentials (icons, backgrounds, thumbnails, etc.).
+                                                                         * 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:
-                                                                         * query (str, required for GET): Search term to filter images by name
+                                                                         * # 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 images matching a search query
-                                                                         * POST: Upload a new image
+                                                                         * GET: Retrieve credentials with filtering and pagination
+                                                                         * POST: Create a new credential
                                                                          *
                                                                          * POST Request Body:
-                                                                         * Multipart form data containing:
-                                                                         * - image (file, required): The image file to upload
-                                                                         * - name (str, optional): A descriptive name for the image
+                                                                         * 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 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"
-                                                                                     * },
+                                                                         * 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 object containing the uploaded image details:
+                                                                                     * POST: A JSON response containing:
                                                                                      * {
-                                                                                         * "id": 125,
-                                                                                         * "name": "Certificate Icon",
-                                                                                         * "image": "https://example.com/media/uploaded_images/certificate-icon.png"
+                                                                                         * "status": {"success": true, "description": "Created"},
+                                                                                         * "result": {credential object}
                                                                                          * }
                                                                                          *
                                                                                          * Error Responses:
-                                                                                         * 400 Bad Request: If the request data is invalid or missing required parameters
+                                                                                         * 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 upload and retrieve images
-                                                                                         * @returns UploadedImage
+                                                                                         * - Requires CredentialAssignmentPermission
+                                                                                         * - Only public credentials are returned by default
+                                                                                         * @returns Credential
                                                                                          * @throws ApiError
                                                                                          */
-                                                                                        public static credentialsOrgsUsersImagesCreate({
+                                                                                        public static credentialsOrgsUsersCreate2({
                                                                                             platformKey,
                                                                                             username,
                                                                                             requestBody,
                                                                                         }: {
                                                                                             platformKey: string,
                                                                                             username: string,
-                                                                                            requestBody?: UploadedImage,
-                                                                                        }): CancelablePromise<UploadedImage> {
+                                                                                            requestBody: Credential,
+                                                                                        }): CancelablePromise<Credential> {
                                                                                             return __request(OpenAPI, {
                                                                                                 method: 'POST',
-                                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/images/',
+                                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/',
                                                                                                 path: {
                                                                                                     'platform_key': platformKey,
                                                                                                     'username': username,
@@ -1344,649 +1438,1159 @@ export class CredentialsService {
                                                                                             });
                                                                                         }
                                                                                         /**
-                                                                                         * API View for managing credential issuers.
+                                                                                         * API View for managing individual credentials.
                                                                                          *
-                                                                                         * This endpoint allows creating and retrieving issuers for a specific organization/tenant,
-                                                                                         * with support for filtering and pagination.
+                                                                                         * 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
-                                                                                         *
-                                                                                         * 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
+                                                                                         * entity_id (str): The credential entity ID
                                                                                          *
                                                                                          * Methods:
-                                                                                         * GET: Retrieve issuers with filtering and pagination
-                                                                                         * POST: Create a new issuer
+                                                                                         * GET: Retrieve a specific credential
+                                                                                         * PUT: Update a specific credential
+                                                                                         * DELETE: Delete a specific credential
                                                                                          *
-                                                                                         * 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
+                                                                                         * 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": {
-                                                                                                 * "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
-                                                                                                     * }
+                                                                                             * "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"}
                                                                                                      * }
                                                                                                      *
-                                                                                                     * POST: A JSON response containing:
+                                                                                                     * 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
+                                                                                                     */
+                                                                                                    public static credentialsOrgsUsersRetrieve4({
+                                                                                                        entityId,
+                                                                                                        platformKey,
+                                                                                                        username,
+                                                                                                    }: {
+                                                                                                        entityId: string,
+                                                                                                        platformKey: string,
+                                                                                                        username: string,
+                                                                                                    }): CancelablePromise<Credential> {
+                                                                                                        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": "Created"},
-                                                                                                         * "result": {issuer object}
+                                                                                                         * "status": {"success": true, "description": "Ok"},
+                                                                                                         * "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 IsAdminUserOrStudentDRFMixin
-                                                                                                         * - Only authenticated users with appropriate permissions can manage issuers
-                                                                                                         * @returns Issuer
-                                                                                                         * @throws ApiError
-                                                                                                         */
-                                                                                                        public static credentialsOrgsUsersIssuersRetrieve({
-                                                                                                            platformKey,
-                                                                                                            q,
-                                                                                                            username,
-                                                                                                        }: {
-                                                                                                            platformKey: string,
-                                                                                                            q: string,
-                                                                                                            username: string,
-                                                                                                        }): CancelablePromise<Issuer> {
-                                                                                                            return __request(OpenAPI, {
-                                                                                                                method: 'GET',
-                                                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/',
-                                                                                                                path: {
-                                                                                                                    'platform_key': platformKey,
-                                                                                                                    'username': username,
-                                                                                                                },
-                                                                                                                query: {
-                                                                                                                    'q': q,
-                                                                                                                },
-                                                                                                            });
-                                                                                                        }
-                                                                                                        /**
-                                                                                                         * 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:
+                                                                                                         * PUT: 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
-                                                                                                                     * }
+                                                                                                             * "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
+                                                                                                                 */
+                                                                                                                public static credentialsOrgsUsersUpdate2({
+                                                                                                                    entityId,
+                                                                                                                    platformKey,
+                                                                                                                    username,
+                                                                                                                    requestBody,
+                                                                                                                }: {
+                                                                                                                    entityId: string,
+                                                                                                                    platformKey: string,
+                                                                                                                    username: string,
+                                                                                                                    requestBody: Credential,
+                                                                                                                }): CancelablePromise<Credential> {
+                                                                                                                    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}
                                                                                                                      * }
                                                                                                                      *
-                                                                                                                     * POST: A JSON response containing:
+                                                                                                                     * PUT: A JSON response containing:
                                                                                                                      * {
-                                                                                                                         * "status": {"success": true, "description": "Created"},
-                                                                                                                         * "result": {issuer object}
+                                                                                                                         * "status": {"success": true, "description": "Updated"},
+                                                                                                                         * "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 IsAdminUserOrStudentDRFMixin
-                                                                                                                         * - Only authenticated users with appropriate permissions can manage issuers
-                                                                                                                         * @returns Issuer
-                                                                                                                         * @throws ApiError
-                                                                                                                         */
-                                                                                                                        public static credentialsOrgsUsersIssuersCreate({
-                                                                                                                            platformKey,
-                                                                                                                            q,
-                                                                                                                            username,
-                                                                                                                            requestBody,
-                                                                                                                        }: {
-                                                                                                                            platformKey: string,
-                                                                                                                            q: string,
-                                                                                                                            username: string,
-                                                                                                                            requestBody: Issuer,
-                                                                                                                        }): CancelablePromise<Issuer> {
-                                                                                                                            return __request(OpenAPI, {
-                                                                                                                                method: 'POST',
-                                                                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/',
-                                                                                                                                path: {
-                                                                                                                                    'platform_key': platformKey,
-                                                                                                                                    'username': username,
-                                                                                                                                },
-                                                                                                                                query: {
-                                                                                                                                    'q': q,
-                                                                                                                                },
-                                                                                                                                body: requestBody,
-                                                                                                                                mediaType: 'application/json',
-                                                                                                                            });
-                                                                                                                        }
-                                                                                                                        /**
-                                                                                                                         * 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:
-                                                                                                                         * [
+                                                                                                                         * 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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersDestroy2({
+                                                                                                                                entityId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                entityId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<void> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsRetrieve6({
+                                                                                                                                entityId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                entityId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<PaginatedAssertionsResponse> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsCreate2({
+                                                                                                                                entityId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                requestBody,
+                                                                                                                            }: {
+                                                                                                                                entityId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                requestBody: Assertion,
+                                                                                                                            }): CancelablePromise<Assertion> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsBulkCreate2({
+                                                                                                                                entityId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                requestBody,
+                                                                                                                            }: {
+                                                                                                                                entityId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                requestBody: BulkCreateAssertion,
+                                                                                                                            }): CancelablePromise<BulkCreateAssertion> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsRetrieve4({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                course,
+                                                                                                                                excludeMainTenantAssertions,
+                                                                                                                                includeExpired,
+                                                                                                                                includeRevoked,
+                                                                                                                                page,
+                                                                                                                                pageSize,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                course?: string,
+                                                                                                                                excludeMainTenantAssertions?: boolean,
+                                                                                                                                includeExpired?: boolean,
+                                                                                                                                includeRevoked?: boolean,
+                                                                                                                                page?: number,
+                                                                                                                                pageSize?: number,
+                                                                                                                            }): CancelablePromise<PaginatedAssertionsResponse> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsOverTimeRetrieve2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                departmentId,
+                                                                                                                                endDate,
+                                                                                                                                format = 'json',
+                                                                                                                                includeMainPlatform = true,
+                                                                                                                                startDate,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                /**
+                                                                                                                                 * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                                                                                                 */
+                                                                                                                                departmentId?: number,
+                                                                                                                                /**
+                                                                                                                                 * end date. ISO 8601
+                                                                                                                                 */
+                                                                                                                                endDate?: string,
+                                                                                                                                /**
+                                                                                                                                 * Format
+                                                                                                                                 *
+                                                                                                                                 * * `json` - json
+                                                                                                                                 */
+                                                                                                                                format?: 'json',
+                                                                                                                                /**
+                                                                                                                                 * Include main platform data
+                                                                                                                                 */
+                                                                                                                                includeMainPlatform?: boolean,
+                                                                                                                                /**
+                                                                                                                                 * start date. ISO 8601
+                                                                                                                                 */
+                                                                                                                                startDate?: string,
+                                                                                                                            }): CancelablePromise<OvertimeWithChangeInfo> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsRetrieve5({
+                                                                                                                                entityId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                entityId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<Assertion> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssertionsUpdate2({
+                                                                                                                                entityId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                requestBody,
+                                                                                                                            }: {
+                                                                                                                                entityId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                requestBody: Assertion,
+                                                                                                                            }): CancelablePromise<Assertion> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssignmentsDestroy2({
+                                                                                                                                assignmentId,
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                assignmentId: string,
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<void> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssignmentsGroupsRetrieve2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<any> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssignmentsGroupsCreate2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<any> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssignmentsUsersRetrieve2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<any> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersAssignmentsUsersCreate2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<any> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                departmentId,
+                                                                                                                                endDate,
+                                                                                                                                format = 'json',
+                                                                                                                                includeMainPlatform = true,
+                                                                                                                                startDate,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                /**
+                                                                                                                                 * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                                                                                                 */
+                                                                                                                                departmentId?: number,
+                                                                                                                                /**
+                                                                                                                                 * end date. ISO 8601
+                                                                                                                                 */
+                                                                                                                                endDate?: string,
+                                                                                                                                /**
+                                                                                                                                 * Format
+                                                                                                                                 *
+                                                                                                                                 * * `json` - json
+                                                                                                                                 */
+                                                                                                                                format?: 'json',
+                                                                                                                                /**
+                                                                                                                                 * Include main platform data
+                                                                                                                                 */
+                                                                                                                                includeMainPlatform?: boolean,
+                                                                                                                                /**
+                                                                                                                                 * start date. ISO 8601
+                                                                                                                                 */
+                                                                                                                                startDate?: string,
+                                                                                                                            }): CancelablePromise<OverTime> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersCourseCredentialsList2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                page,
+                                                                                                                                pageSize,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                /**
+                                                                                                                                 * A page number within the paginated result set.
+                                                                                                                                 */
+                                                                                                                                page?: number,
+                                                                                                                                /**
+                                                                                                                                 * Number of results to return per page.
+                                                                                                                                 */
+                                                                                                                                pageSize?: number,
+                                                                                                                            }): CancelablePromise<any> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersCredentialsOverTimeRetrieve2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                                departmentId,
+                                                                                                                                endDate,
+                                                                                                                                format = 'json',
+                                                                                                                                includeMainPlatform = true,
+                                                                                                                                startDate,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                                /**
+                                                                                                                                 * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                                                                                                 */
+                                                                                                                                departmentId?: number,
+                                                                                                                                /**
+                                                                                                                                 * end date. ISO 8601
+                                                                                                                                 */
+                                                                                                                                endDate?: string,
+                                                                                                                                /**
+                                                                                                                                 * Format
+                                                                                                                                 *
+                                                                                                                                 * * `json` - json
+                                                                                                                                 */
+                                                                                                                                format?: 'json',
+                                                                                                                                /**
+                                                                                                                                 * Include main platform data
+                                                                                                                                 */
+                                                                                                                                includeMainPlatform?: boolean,
+                                                                                                                                /**
+                                                                                                                                 * start date. ISO 8601
+                                                                                                                                 */
+                                                                                                                                startDate?: string,
+                                                                                                                            }): CancelablePromise<OverTime> {
+                                                                                                                                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
+                                                                                                                             */
+                                                                                                                            public static credentialsOrgsUsersExternalMappingRetrieve2({
+                                                                                                                                platformKey,
+                                                                                                                                username,
+                                                                                                                            }: {
+                                                                                                                                platformKey: string,
+                                                                                                                                username: string,
+                                                                                                                            }): CancelablePromise<ExternalCredentialMapping> {
+                                                                                                                                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:
                                                                                                                              * {
-                                                                                                                                 * "name": "Example University",
-                                                                                                                                 * "org": "example-university",
-                                                                                                                                 * "entityId": "abc123",
-                                                                                                                                 * "signatories": [...],
-                                                                                                                                 * "url": "https://example.com",
-                                                                                                                                 * "iconImage": "https://example.com/logo.png",
-                                                                                                                                 * "allowed_template_tags": [...]
+                                                                                                                                 * "credential_id": "credential-entity-id",  // Required
+                                                                                                                                 * "provider_name": "accredible",            // Required
+                                                                                                                                 * "external_template_id": "123456",         // Optional
+                                                                                                                                 * "metadata": {}                            // Optional
                                                                                                                                  * }
-                                                                                                                                 * ]
                                                                                                                                  *
-                                                                                                                                 * PUT: A JSON response containing the updated issuer details:
-                                                                                                                                 * [
+                                                                                                                                 * Returns:
+                                                                                                                                 * - 201 Created: When creating a new mapping
+                                                                                                                                 * - 200 OK: When updating an existing mapping
+                                                                                                                                 * @returns ExternalCredentialMapping
+                                                                                                                                 * @throws ApiError
+                                                                                                                                 */
+                                                                                                                                public static credentialsOrgsUsersExternalMappingCreate2({
+                                                                                                                                    platformKey,
+                                                                                                                                    username,
+                                                                                                                                    requestBody,
+                                                                                                                                }: {
+                                                                                                                                    platformKey: string,
+                                                                                                                                    username: string,
+                                                                                                                                    requestBody: ExternalCredentialMapping,
+                                                                                                                                }): CancelablePromise<ExternalCredentialMapping> {
+                                                                                                                                    return __request(OpenAPI, {
+                                                                                                                                        method: 'POST',
+                                                                                                                                        url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
+                                                                                                                                        path: {
+                                                                                                                                            'platform_key': platformKey,
+                                                                                                                                            'username': username,
+                                                                                                                                        },
+                                                                                                                                        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
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersExternalMappingDestroy2({
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                    }): CancelablePromise<void> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'DELETE',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/external-mapping/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * @returns UploadedImage
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersImagesRetrieve2({
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                    }): CancelablePromise<UploadedImage> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'GET',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/images/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * @returns UploadedImage
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersImagesCreate2({
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                        requestBody,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                        requestBody?: UploadedImage,
+                                                                                                                                    }): CancelablePromise<UploadedImage> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'POST',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/images/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                            body: requestBody,
+                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * A GET View that validates QueryParams and returns results to a serializer
+                                                                                                                                     * @returns Issuer
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersRetrieve3({
+                                                                                                                                        platformKey,
+                                                                                                                                        q,
+                                                                                                                                        username,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        q: string,
+                                                                                                                                        username: string,
+                                                                                                                                    }): CancelablePromise<Issuer> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'GET',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                            query: {
+                                                                                                                                                'q': q,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * A GET View that validates QueryParams and returns results to a serializer
+                                                                                                                                     * @returns Issuer
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersCreate2({
+                                                                                                                                        platformKey,
+                                                                                                                                        q,
+                                                                                                                                        username,
+                                                                                                                                        requestBody,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        q: string,
+                                                                                                                                        username: string,
+                                                                                                                                        requestBody: Issuer,
+                                                                                                                                    }): CancelablePromise<Issuer> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'POST',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                            query: {
+                                                                                                                                                'q': q,
+                                                                                                                                            },
+                                                                                                                                            body: requestBody,
+                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * @returns Issuer
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersRetrieve4({
+                                                                                                                                        entityId,
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                    }: {
+                                                                                                                                        entityId: string,
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                    }): CancelablePromise<Issuer> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'GET',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/{entity_id}',
+                                                                                                                                            path: {
+                                                                                                                                                'entity_id': entityId,
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * @returns Issuer
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersUpdate2({
+                                                                                                                                        entityId,
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                        requestBody,
+                                                                                                                                    }: {
+                                                                                                                                        entityId: string,
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                        requestBody: Issuer,
+                                                                                                                                    }): CancelablePromise<Issuer> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'PUT',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/{entity_id}',
+                                                                                                                                            path: {
+                                                                                                                                                'entity_id': entityId,
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                            body: requestBody,
+                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * @returns void
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersDestroy2({
+                                                                                                                                        entityId,
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                    }: {
+                                                                                                                                        entityId: string,
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                    }): CancelablePromise<void> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'DELETE',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/{entity_id}',
+                                                                                                                                            path: {
+                                                                                                                                                'entity_id': entityId,
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * @returns IssuerAuthority
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersAuthorityCreate2({
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                        requestBody,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                        requestBody: IssuerAuthority,
+                                                                                                                                    }): CancelablePromise<IssuerAuthority> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'POST',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/authority/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                            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
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersProviderConfigRetrieve2({
+                                                                                                                                        platformKey,
+                                                                                                                                        username,
+                                                                                                                                    }: {
+                                                                                                                                        platformKey: string,
+                                                                                                                                        username: string,
+                                                                                                                                    }): CancelablePromise<CredentialProviderConfig> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'GET',
+                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/provider-config/',
+                                                                                                                                            path: {
+                                                                                                                                                'platform_key': platformKey,
+                                                                                                                                                'username': username,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * 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:
                                                                                                                                      * {
-                                                                                                                                         * "name": "Example University",
-                                                                                                                                         * "org": "example-university",
-                                                                                                                                         * "entityId": "abc123",
-                                                                                                                                         * "signatories": [...],
-                                                                                                                                         * "url": "https://example.com",
-                                                                                                                                         * "iconImage": "https://example.com/new-logo.png",
-                                                                                                                                         * "allowed_template_tags": [...]
+                                                                                                                                         * "provider_name": "accredible",  // Required
+                                                                                                                                         * "config": {...},                 // Optional
+                                                                                                                                         * "enabled": true                  // Optional
                                                                                                                                          * }
-                                                                                                                                         * ]
                                                                                                                                          *
-                                                                                                                                         * DELETE: A JSON response indicating success:
+                                                                                                                                         * Returns:
+                                                                                                                                         * - 201 Created: When creating a new configuration
+                                                                                                                                         * - 200 OK: When updating an existing configuration
+                                                                                                                                         * @returns CredentialProviderConfig
+                                                                                                                                         * @throws ApiError
+                                                                                                                                         */
+                                                                                                                                        public static credentialsOrgsUsersProviderConfigCreate2({
+                                                                                                                                            platformKey,
+                                                                                                                                            username,
+                                                                                                                                            requestBody,
+                                                                                                                                        }: {
+                                                                                                                                            platformKey: string,
+                                                                                                                                            username: string,
+                                                                                                                                            requestBody: CredentialProviderConfig,
+                                                                                                                                        }): CancelablePromise<CredentialProviderConfig> {
+                                                                                                                                            return __request(OpenAPI, {
+                                                                                                                                                method: 'POST',
+                                                                                                                                                url: '/api/credentials/orgs/{platform_key}/users/{username}/provider-config/',
+                                                                                                                                                path: {
+                                                                                                                                                    'platform_key': platformKey,
+                                                                                                                                                    'username': username,
+                                                                                                                                                },
+                                                                                                                                                body: requestBody,
+                                                                                                                                                mediaType: 'application/json',
+                                                                                                                                            });
+                                                                                                                                        }
+                                                                                                                                        /**
+                                                                                                                                         * Deactivate a provider configuration (sets enabled=False).
+                                                                                                                                         *
+                                                                                                                                         * Request Body:
                                                                                                                                          * {
-                                                                                                                                             * "status": {"success": true, "description": "Deleted"}
+                                                                                                                                             * "provider_name": "accredible"  // Required
                                                                                                                                              * }
-                                                                                                                                             *
-                                                                                                                                             * 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
+                                                                                                                                             * @returns void
                                                                                                                                              * @throws ApiError
                                                                                                                                              */
-                                                                                                                                            public static credentialsOrgsUsersIssuersRetrieve2({
-                                                                                                                                                entityId,
+                                                                                                                                            public static credentialsOrgsUsersProviderConfigDestroy2({
                                                                                                                                                 platformKey,
                                                                                                                                                 username,
                                                                                                                                             }: {
-                                                                                                                                                entityId: string,
                                                                                                                                                 platformKey: string,
                                                                                                                                                 username: string,
-                                                                                                                                            }): CancelablePromise<Issuer> {
+                                                                                                                                            }): CancelablePromise<void> {
                                                                                                                                                 return __request(OpenAPI, {
-                                                                                                                                                    method: 'GET',
-                                                                                                                                                    url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/{entity_id}',
+                                                                                                                                                    method: 'DELETE',
+                                                                                                                                                    url: '/api/credentials/orgs/{platform_key}/users/{username}/provider-config/',
                                                                                                                                                     path: {
-                                                                                                                                                        'entity_id': entityId,
                                                                                                                                                         'platform_key': platformKey,
                                                                                                                                                         'username': username,
                                                                                                                                                     },
                                                                                                                                                 });
                                                                                                                                             }
                                                                                                                                             /**
-                                                                                                                                             * API View for managing individual issuers.
+                                                                                                                                             * Get list of enabled credential providers with pagination.
+                                                                                                                                             * @returns any No response body
+                                                                                                                                             * @throws ApiError
+                                                                                                                                             */
+                                                                                                                                            public static credentialsProvidersRetrieve(): CancelablePromise<any> {
+                                                                                                                                                return __request(OpenAPI, {
+                                                                                                                                                    method: 'GET',
+                                                                                                                                                    url: '/api/credentials/providers/',
+                                                                                                                                                });
+                                                                                                                                            }
+                                                                                                                                            /**
+                                                                                                                                             * Public endpoint to retrieve a specific credential assertion by its entity ID.
                                                                                                                                              *
-                                                                                                                                             * This endpoint allows retrieving, updating, and deleting specific issuers
-                                                                                                                                             * identified by their entity_id or org identifier.
+                                                                                                                                             * This endpoint allows public access to view a specific credential assertion
+                                                                                                                                             * without authentication.
                                                                                                                                              *
                                                                                                                                              * 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
+                                                                                                                                             * entity_id (str): The assertion entity ID
                                                                                                                                              *
                                                                                                                                              * 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
-                                                                                                                                                                 */
-                                                                                                                                                                public static credentialsOrgsUsersIssuersUpdate({
-                                                                                                                                                                    entityId,
-                                                                                                                                                                    platformKey,
-                                                                                                                                                                    username,
-                                                                                                                                                                    requestBody,
-                                                                                                                                                                }: {
-                                                                                                                                                                    entityId: string,
-                                                                                                                                                                    platformKey: string,
-                                                                                                                                                                    username: string,
-                                                                                                                                                                    requestBody: Issuer,
-                                                                                                                                                                }): CancelablePromise<Issuer> {
-                                                                                                                                                                    return __request(OpenAPI, {
-                                                                                                                                                                        method: 'PUT',
-                                                                                                                                                                        url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/{entity_id}',
-                                                                                                                                                                        path: {
-                                                                                                                                                                            'entity_id': entityId,
-                                                                                                                                                                            'platform_key': platformKey,
-                                                                                                                                                                            'username': username,
-                                                                                                                                                                        },
-                                                                                                                                                                        body: requestBody,
-                                                                                                                                                                        mediaType: 'application/json',
-                                                                                                                                                                    });
-                                                                                                                                                                }
-                                                                                                                                                                /**
-                                                                                                                                                                 * 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
-                                                                                                                                                                                     */
-                                                                                                                                                                                    public static credentialsOrgsUsersIssuersDestroy({
-                                                                                                                                                                                        entityId,
-                                                                                                                                                                                        platformKey,
-                                                                                                                                                                                        username,
-                                                                                                                                                                                    }: {
-                                                                                                                                                                                        entityId: string,
-                                                                                                                                                                                        platformKey: string,
-                                                                                                                                                                                        username: string,
-                                                                                                                                                                                    }): CancelablePromise<void> {
-                                                                                                                                                                                        return __request(OpenAPI, {
-                                                                                                                                                                                            method: 'DELETE',
-                                                                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/{entity_id}',
-                                                                                                                                                                                            path: {
-                                                                                                                                                                                                'entity_id': entityId,
-                                                                                                                                                                                                'platform_key': platformKey,
-                                                                                                                                                                                                'username': username,
-                                                                                                                                                                                            },
-                                                                                                                                                                                        });
-                                                                                                                                                                                    }
-                                                                                                                                                                                    /**
-                                                                                                                                                                                     * 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
-                                                                                                                                                                                             */
-                                                                                                                                                                                            public static credentialsOrgsUsersIssuersAuthorityCreate({
-                                                                                                                                                                                                platformKey,
-                                                                                                                                                                                                username,
-                                                                                                                                                                                                requestBody,
-                                                                                                                                                                                            }: {
-                                                                                                                                                                                                platformKey: string,
-                                                                                                                                                                                                username: string,
-                                                                                                                                                                                                requestBody: IssuerAuthority,
-                                                                                                                                                                                            }): CancelablePromise<IssuerAuthority> {
-                                                                                                                                                                                                return __request(OpenAPI, {
-                                                                                                                                                                                                    method: 'POST',
-                                                                                                                                                                                                    url: '/api/credentials/orgs/{platform_key}/users/{username}/issuers/authority/',
-                                                                                                                                                                                                    path: {
-                                                                                                                                                                                                        'platform_key': platformKey,
-                                                                                                                                                                                                        'username': username,
-                                                                                                                                                                                                    },
-                                                                                                                                                                                                    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
-                                                                                                                                                                                             */
-                                                                                                                                                                                            public static credentialsOrgsUsersProviderConfigRetrieve({
-                                                                                                                                                                                                platformKey,
-                                                                                                                                                                                                username,
-                                                                                                                                                                                            }: {
-                                                                                                                                                                                                platformKey: string,
-                                                                                                                                                                                                username: string,
-                                                                                                                                                                                            }): CancelablePromise<CredentialProviderConfig> {
-                                                                                                                                                                                                return __request(OpenAPI, {
-                                                                                                                                                                                                    method: 'GET',
-                                                                                                                                                                                                    url: '/api/credentials/orgs/{platform_key}/users/{username}/provider-config/',
-                                                                                                                                                                                                    path: {
-                                                                                                                                                                                                        'platform_key': platformKey,
-                                                                                                                                                                                                        'username': username,
-                                                                                                                                                                                                    },
-                                                                                                                                                                                                });
-                                                                                                                                                                                            }
-                                                                                                                                                                                            /**
-                                                                                                                                                                                             * 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
-                                                                                                                                                                                                 */
-                                                                                                                                                                                                public static credentialsOrgsUsersProviderConfigCreate({
-                                                                                                                                                                                                    platformKey,
-                                                                                                                                                                                                    username,
-                                                                                                                                                                                                    requestBody,
-                                                                                                                                                                                                }: {
-                                                                                                                                                                                                    platformKey: string,
-                                                                                                                                                                                                    username: string,
-                                                                                                                                                                                                    requestBody: CredentialProviderConfig,
-                                                                                                                                                                                                }): CancelablePromise<CredentialProviderConfig> {
-                                                                                                                                                                                                    return __request(OpenAPI, {
-                                                                                                                                                                                                        method: 'POST',
-                                                                                                                                                                                                        url: '/api/credentials/orgs/{platform_key}/users/{username}/provider-config/',
-                                                                                                                                                                                                        path: {
-                                                                                                                                                                                                            'platform_key': platformKey,
-                                                                                                                                                                                                            'username': username,
-                                                                                                                                                                                                        },
-                                                                                                                                                                                                        body: requestBody,
-                                                                                                                                                                                                        mediaType: 'application/json',
-                                                                                                                                                                                                    });
-                                                                                                                                                                                                }
-                                                                                                                                                                                                /**
-                                                                                                                                                                                                 * Deactivate a provider configuration (sets enabled=False).
-                                                                                                                                                                                                 *
-                                                                                                                                                                                                 * Request Body:
-                                                                                                                                                                                                 * {
-                                                                                                                                                                                                     * "provider_name": "accredible"  // Required
-                                                                                                                                                                                                     * }
-                                                                                                                                                                                                     * @returns void
-                                                                                                                                                                                                     * @throws ApiError
-                                                                                                                                                                                                     */
-                                                                                                                                                                                                    public static credentialsOrgsUsersProviderConfigDestroy({
-                                                                                                                                                                                                        platformKey,
-                                                                                                                                                                                                        username,
-                                                                                                                                                                                                    }: {
-                                                                                                                                                                                                        platformKey: string,
-                                                                                                                                                                                                        username: string,
-                                                                                                                                                                                                    }): CancelablePromise<void> {
-                                                                                                                                                                                                        return __request(OpenAPI, {
-                                                                                                                                                                                                            method: 'DELETE',
-                                                                                                                                                                                                            url: '/api/credentials/orgs/{platform_key}/users/{username}/provider-config/',
-                                                                                                                                                                                                            path: {
-                                                                                                                                                                                                                'platform_key': platformKey,
-                                                                                                                                                                                                                'username': username,
-                                                                                                                                                                                                            },
-                                                                                                                                                                                                        });
-                                                                                                                                                                                                    }
-                                                                                                                                                                                                    /**
-                                                                                                                                                                                                     * Get list of enabled credential providers with pagination.
-                                                                                                                                                                                                     * @returns any No response body
-                                                                                                                                                                                                     * @throws ApiError
-                                                                                                                                                                                                     */
-                                                                                                                                                                                                    public static credentialsProvidersRetrieve(): CancelablePromise<any> {
-                                                                                                                                                                                                        return __request(OpenAPI, {
-                                                                                                                                                                                                            method: 'GET',
-                                                                                                                                                                                                            url: '/api/credentials/providers/',
-                                                                                                                                                                                                        });
-                                                                                                                                                                                                    }
-                                                                                                                                                                                                    /**
-                                                                                                                                                                                                     * Public endpoint to retrieve a specific credential assertion by its entity ID.
-                                                                                                                                                                                                     *
-                                                                                                                                                                                                     * This endpoint allows public access to view a specific credential assertion
-                                                                                                                                                                                                     * without authentication.
-                                                                                                                                                                                                     *
-                                                                                                                                                                                                     * Path Parameters:
-                                                                                                                                                                                                     * entity_id (str): The assertion entity ID
-                                                                                                                                                                                                     *
-                                                                                                                                                                                                     * Returns:
-                                                                                                                                                                                                     * A JSON response containing the assertion details using the AssertionSerializer format
-                                                                                                                                                                                                     *
-                                                                                                                                                                                                     * Error Responses:
-                                                                                                                                                                                                     * 404 Not Found:
-                                                                                                                                                                                                     * - If the assertion doesn't exist: Empty response with 404 status
-                                                                                                                                                                                                     * - If the assertion has been revoked: JSON with error detail and revocation reason
-                                                                                                                                                                                                     * 500 Internal Server Error: If an unexpected error occurs
-                                                                                                                                                                                                     * @returns Assertion
-                                                                                                                                                                                                     * @throws ApiError
-                                                                                                                                                                                                     */
-                                                                                                                                                                                                    public static credentialsPublicAssertionsRetrieve({
-                                                                                                                                                                                                        entityId,
-                                                                                                                                                                                                    }: {
-                                                                                                                                                                                                        entityId: string,
-                                                                                                                                                                                                    }): CancelablePromise<Assertion> {
-                                                                                                                                                                                                        return __request(OpenAPI, {
-                                                                                                                                                                                                            method: 'GET',
-                                                                                                                                                                                                            url: '/api/credentials/public/assertions/{entity_id}/',
-                                                                                                                                                                                                            path: {
-                                                                                                                                                                                                                'entity_id': entityId,
-                                                                                                                                                                                                            },
-                                                                                                                                                                                                        });
-                                                                                                                                                                                                    }
-                                                                                                                                                                                                }
+                                                                                                                                             * A JSON response containing the assertion details using the AssertionSerializer format
+                                                                                                                                             *
+                                                                                                                                             * Error Responses:
+                                                                                                                                             * 404 Not Found:
+                                                                                                                                             * - If the assertion doesn't exist: Empty response with 404 status
+                                                                                                                                             * - If the assertion has been revoked: JSON with error detail and revocation reason
+                                                                                                                                             * 500 Internal Server Error: If an unexpected error occurs
+                                                                                                                                             * @returns Assertion
+                                                                                                                                             * @throws ApiError
+                                                                                                                                             */
+                                                                                                                                            public static credentialsPublicAssertionsRetrieve({
+                                                                                                                                                entityId,
+                                                                                                                                            }: {
+                                                                                                                                                entityId: string,
+                                                                                                                                            }): CancelablePromise<Assertion> {
+                                                                                                                                                return __request(OpenAPI, {
+                                                                                                                                                    method: 'GET',
+                                                                                                                                                    url: '/api/credentials/public/assertions/{entity_id}/',
+                                                                                                                                                    path: {
+                                                                                                                                                        'entity_id': entityId,
+                                                                                                                                                    },
+                                                                                                                                                });
+                                                                                                                                            }
+                                                                                                                                        }