@iblai/iblai-api 0.0.1-core

package/src/services/CredentialsService.ts

@@ -0,0 +1,1656 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { Assertion } from '../models/Assertion';
+import type { BulkCreateAssertion } from '../models/BulkCreateAssertion';
+import type { Credential } from '../models/Credential';
+import type { Issuer } from '../models/Issuer';
+import type { IssuerAuthority } from '../models/IssuerAuthority';
+import type { OverTime } from '../models/OverTime';
+import type { OvertimeWithChangeInfo } from '../models/OvertimeWithChangeInfo';
+import type { UploadedImage } from '../models/UploadedImage';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class CredentialsService {
+    /**
+     * Get all credentials for a platform with search and pagination support.
+     *
+     * Query Parameters:
+     * - platform_org: Platform org ID (takes precedence over URL org)
+     * - page: Page number (default: 1)
+     * - page_size: Items per page (default: 10, max: 100)
+     * - search: Search term to filter credentials
+     * - course: Course ID to filter credentials
+     * - program: Program ID to filter credentials
+     * @param org
+     * @param userId
+     * @returns Credential
+     * @throws ApiError
+     */
+    public static credentialsOrgsUsersRetrieve(
+        org: string,
+        userId: string,
+    ): CancelablePromise<Credential> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/credentials/orgs/{org}/users/{user_id}/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * API View for managing credentials across a platform.
+     *
+     * This endpoint allows creating and retrieving credentials for a specific organization/tenant,
+     * with support for filtering, searching, and pagination.
+     *
+     * Path Parameters:
+     * org (str): The organization/tenant identifier
+     * user_id (str): The user ID making the request
+     *
+     * Query Parameters:
+     * # Platform identification
+     * platform_org (str, optional): Alternative platform identifier (takes precedence over URL org)
+     *
+     * # Pagination
+     * page (int, optional): Page number (default: 1)
+     * page_size (int, optional): Items per page (default: 10, max: 100)
+     *
+     * # Filtering and search
+     * search (str, optional): Search term to filter credentials by name or description
+     * course (str, optional): Course ID to filter credentials associated with a specific course
+     * program (str, optional): Program ID to filter credentials associated with a specific program
+     *
+     * Methods:
+     * GET: Retrieve credentials with filtering and pagination
+     * POST: Create a new credential
+     *
+     * POST Request Body:
+     * A JSON object containing credential details:
+     * - name (str): Credential name
+     * - description (str, optional): Credential description
+     * - issuer (str): Issuer entity ID
+     * - credential_type (str, optional): Type of credential
+     * - html_template (str, optional): HTML template for credential rendering
+     * - css_template (str, optional): CSS template for credential styling
+     * - icon_image (str, optional): URL to credential icon
+     * - background_image (str, optional): URL to credential background
+     * - thumbnail_image (str, optional): URL to credential thumbnail
+     * - criteria_url (str, optional): URL to credential criteria
+     * - criteria_text (str, optional): Text description of credential criteria
+     * - issuing_signal (str, optional): Signal that triggers credential issuance
+     *
+     * Returns:
+     * GET: A JSON response containing:
+     * {
+         * "status": {"success": true, "description": "Ok"},
+         * "result": {
+             * "next": "URL to next page",
+             * "previous": "URL to previous page",
+             * "count": 42,
+             * "data": [
+                 * {credential object},
+                 * {credential object},
+                 * ...
+                 * ],
+                 * "num_pages": 5,
+                 * "page_number": 1,
+                 * "max_page_size": 100
+                 * }
+                 * }
+                 *
+                 * POST: A JSON response containing:
+                 * {
+                     * "status": {"success": true, "description": "Created"},
+                     * "result": {credential object}
+                     * }
+                     *
+                     * Error Responses:
+                     * 400 Bad Request: If the request data is invalid
+                     * 401 Unauthorized: If the user is not authenticated
+                     * 403 Forbidden: If the user does not have permission to access this resource
+                     * 404 Not Found: If the platform doesn't exist
+                     * 500 Internal Server Error: If an unexpected error occurs
+                     *
+                     * Access Control:
+                     * - Requires CredentialAssignmentPermission
+                     * - Only public credentials are returned by default
+                     * @param org
+                     * @param userId
+                     * @param requestBody
+                     * @returns Credential
+                     * @throws ApiError
+                     */
+                    public static credentialsOrgsUsersCreate(
+                        org: string,
+                        userId: string,
+                        requestBody: Credential,
+                    ): CancelablePromise<Credential> {
+                        return __request(OpenAPI, {
+                            method: 'POST',
+                            url: '/api/credentials/orgs/{org}/users/{user_id}/',
+                            path: {
+                                'org': org,
+                                'user_id': userId,
+                            },
+                            body: requestBody,
+                            mediaType: 'application/json',
+                        });
+                    }
+                    /**
+                     * API View for managing individual credentials.
+                     *
+                     * This endpoint allows retrieving, updating, and deleting specific credentials
+                     * identified by their entity_id.
+                     *
+                     * Path Parameters:
+                     * org (str): The organization/tenant identifier
+                     * user_id (str): The user ID making the request
+                     * entity_id (str): The credential entity ID
+                     *
+                     * Methods:
+                     * GET: Retrieve a specific credential
+                     * PUT: Update a specific credential
+                     * DELETE: Delete a specific credential
+                     *
+                     * PUT Request Body:
+                     * A JSON object containing credential details to update:
+                     * - name (str, optional): Credential name
+                     * - description (str, optional): Credential description
+                     * - credential_type (str, optional): Type of credential
+                     * - html_template (str, optional): HTML template for credential rendering
+                     * - css_template (str, optional): CSS template for credential styling
+                     * - icon_image (str, optional): URL to credential icon
+                     * - background_image (str, optional): URL to credential background
+                     * - thumbnail_image (str, optional): URL to credential thumbnail
+                     * - criteria_url (str, optional): URL to credential criteria
+                     * - criteria_text (str, optional): Text description of credential criteria
+                     * - issuing_signal (str, optional): Signal that triggers credential issuance
+                     *
+                     * Returns:
+                     * GET: A JSON response containing:
+                     * {
+                         * "status": {"success": true, "description": "Ok"},
+                         * "result": {credential object}
+                         * }
+                         *
+                         * PUT: A JSON response containing:
+                         * {
+                             * "status": {"success": true, "description": "Updated"},
+                             * "result": {credential object}
+                             * }
+                             *
+                             * DELETE: 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
+                             * @param entityId
+                             * @param org
+                             * @param userId
+                             * @returns Credential
+                             * @throws ApiError
+                             */
+                            public static credentialsOrgsUsersRetrieve2(
+                                entityId: string,
+                                org: string,
+                                userId: string,
+                            ): CancelablePromise<Credential> {
+                                return __request(OpenAPI, {
+                                    method: 'GET',
+                                    url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}',
+                                    path: {
+                                        'entity_id': entityId,
+                                        'org': org,
+                                        '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": "Ok"},
+                                 * "result": {credential object}
+                                 * }
+                                 *
+                                 * PUT: A JSON response containing:
+                                 * {
+                                     * "status": {"success": true, "description": "Updated"},
+                                     * "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
+                                     * @param entityId
+                                     * @param org
+                                     * @param userId
+                                     * @param requestBody
+                                     * @returns Credential
+                                     * @throws ApiError
+                                     */
+                                    public static credentialsOrgsUsersUpdate(
+                                        entityId: string,
+                                        org: string,
+                                        userId: string,
+                                        requestBody: Credential,
+                                    ): CancelablePromise<Credential> {
+                                        return __request(OpenAPI, {
+                                            method: 'PUT',
+                                            url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}',
+                                            path: {
+                                                'entity_id': entityId,
+                                                'org': org,
+                                                'user_id': userId,
+                                            },
+                                            body: requestBody,
+                                            mediaType: 'application/json',
+                                        });
+                                    }
+                                    /**
+                                     * API View for managing individual credentials.
+                                     *
+                                     * This endpoint allows retrieving, updating, and deleting specific credentials
+                                     * identified by their entity_id.
+                                     *
+                                     * Path Parameters:
+                                     * org (str): The organization/tenant identifier
+                                     * user_id (str): The user ID making the request
+                                     * entity_id (str): The credential entity ID
+                                     *
+                                     * Methods:
+                                     * GET: Retrieve a specific credential
+                                     * PUT: Update a specific credential
+                                     * DELETE: Delete a specific credential
+                                     *
+                                     * PUT Request Body:
+                                     * A JSON object containing credential details to update:
+                                     * - name (str, optional): Credential name
+                                     * - description (str, optional): Credential description
+                                     * - credential_type (str, optional): Type of credential
+                                     * - html_template (str, optional): HTML template for credential rendering
+                                     * - css_template (str, optional): CSS template for credential styling
+                                     * - icon_image (str, optional): URL to credential icon
+                                     * - background_image (str, optional): URL to credential background
+                                     * - thumbnail_image (str, optional): URL to credential thumbnail
+                                     * - criteria_url (str, optional): URL to credential criteria
+                                     * - criteria_text (str, optional): Text description of credential criteria
+                                     * - issuing_signal (str, optional): Signal that triggers credential issuance
+                                     *
+                                     * Returns:
+                                     * GET: A JSON response containing:
+                                     * {
+                                         * "status": {"success": true, "description": "Ok"},
+                                         * "result": {credential object}
+                                         * }
+                                         *
+                                         * PUT: A JSON response containing:
+                                         * {
+                                             * "status": {"success": true, "description": "Updated"},
+                                             * "result": {credential object}
+                                             * }
+                                             *
+                                             * DELETE: 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
+                                             * @param entityId
+                                             * @param org
+                                             * @param userId
+                                             * @returns void
+                                             * @throws ApiError
+                                             */
+                                            public static credentialsOrgsUsersDestroy(
+                                                entityId: string,
+                                                org: string,
+                                                userId: string,
+                                            ): CancelablePromise<void> {
+                                                return __request(OpenAPI, {
+                                                    method: 'DELETE',
+                                                    url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}',
+                                                    path: {
+                                                        'entity_id': entityId,
+                                                        'org': org,
+                                                        'user_id': userId,
+                                                    },
+                                                });
+                                            }
+                                            /**
+                                             * Endpoint to issue and retrieve credential assertions for a specific credential.
+                                             *
+                                             * This endpoint allows issuing new credential assertions and retrieving existing
+                                             * assertions for a specific credential.
+                                             *
+                                             * Path Parameters:
+                                             * org (str): The organization/tenant identifier
+                                             * user_id (str): The user ID making the request
+                                             * entity_id (str): The credential entity ID
+                                             *
+                                             * Methods:
+                                             * POST: Issue a new credential assertion
+                                             * GET: Retrieve assertions for a specific credential
+                                             *
+                                             * POST Request Body:
+                                             * A JSON object containing recipient information and any additional metadata
+                                             * required for issuing the credential.
+                                             *
+                                             * Returns:
+                                             * POST: A JSON response containing the created assertion using the AssertionSerializer format
+                                             * GET: A paginated list of assertions using the AssertionSerializer format
+                                             *
+                                             * Error Responses:
+                                             * 400 Bad Request: If the request data is invalid
+                                             * 401 Unauthorized: If the user is not authenticated
+                                             * 403 Forbidden: If the user does not have permission to access this resource
+                                             * 404 Not Found: If the credential doesn't exist
+                                             * 500 Internal Server Error: If an unexpected error occurs
+                                             * @param entityId
+                                             * @param org
+                                             * @param userId
+                                             * @returns Assertion
+                                             * @throws ApiError
+                                             */
+                                            public static credentialsOrgsUsersAssertionsRetrieve3(
+                                                entityId: string,
+                                                org: string,
+                                                userId: string,
+                                            ): CancelablePromise<Assertion> {
+                                                return __request(OpenAPI, {
+                                                    method: 'GET',
+                                                    url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}/assertions/',
+                                                    path: {
+                                                        'entity_id': entityId,
+                                                        'org': org,
+                                                        'user_id': userId,
+                                                    },
+                                                });
+                                            }
+                                            /**
+                                             * Endpoint to issue and retrieve credential assertions for a specific credential.
+                                             *
+                                             * This endpoint allows issuing new credential assertions and retrieving existing
+                                             * assertions for a specific credential.
+                                             *
+                                             * Path Parameters:
+                                             * org (str): The organization/tenant identifier
+                                             * user_id (str): The user ID making the request
+                                             * entity_id (str): The credential entity ID
+                                             *
+                                             * Methods:
+                                             * POST: Issue a new credential assertion
+                                             * GET: Retrieve assertions for a specific credential
+                                             *
+                                             * POST Request Body:
+                                             * A JSON object containing recipient information and any additional metadata
+                                             * required for issuing the credential.
+                                             *
+                                             * Returns:
+                                             * POST: A JSON response containing the created assertion using the AssertionSerializer format
+                                             * GET: A paginated list of assertions using the AssertionSerializer format
+                                             *
+                                             * Error Responses:
+                                             * 400 Bad Request: If the request data is invalid
+                                             * 401 Unauthorized: If the user is not authenticated
+                                             * 403 Forbidden: If the user does not have permission to access this resource
+                                             * 404 Not Found: If the credential doesn't exist
+                                             * 500 Internal Server Error: If an unexpected error occurs
+                                             * @param entityId
+                                             * @param org
+                                             * @param userId
+                                             * @param requestBody
+                                             * @returns Assertion
+                                             * @throws ApiError
+                                             */
+                                            public static credentialsOrgsUsersAssertionsCreate(
+                                                entityId: string,
+                                                org: string,
+                                                userId: string,
+                                                requestBody: Assertion,
+                                            ): CancelablePromise<Assertion> {
+                                                return __request(OpenAPI, {
+                                                    method: 'POST',
+                                                    url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}/assertions/',
+                                                    path: {
+                                                        'entity_id': entityId,
+                                                        'org': org,
+                                                        'user_id': userId,
+                                                    },
+                                                    body: requestBody,
+                                                    mediaType: 'application/json',
+                                                });
+                                            }
+                                            /**
+                                             * Endpoint to issue credential assertions in bulk for a specific credential.
+                                             *
+                                             * This endpoint allows issuing credential assertions to multiple users at once.
+                                             *
+                                             * Path Parameters:
+                                             * org (str): The organization/tenant identifier
+                                             * user_id (str): The user ID making the request
+                                             * entity_id (str): The credential entity ID
+                                             *
+                                             * POST Request Body:
+                                             * A JSON object containing:
+                                             * - users (list): List of usernames to issue the credential to
+                                             * - Additional metadata required for issuing the credential
+                                             *
+                                             * Returns:
+                                             * A JSON response containing:
+                                             * {
+                                                 * "skipped": ["username1", "username3"],  // Users that were skipped (e.g., already have the credential)
+                                                 * "issued": ["username2", "username4"]    // Users that were successfully issued the credential
+                                                 * }
+                                                 *
+                                                 * Error Responses:
+                                                 * 400 Bad Request: If the request data is invalid or missing required fields
+                                                 * 401 Unauthorized: If the user is not authenticated
+                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                 * 404 Not Found: If the credential doesn't exist
+                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                 * @param entityId
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param requestBody
+                                                 * @returns BulkCreateAssertion
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssertionsBulkCreate(
+                                                    entityId: string,
+                                                    org: string,
+                                                    userId: string,
+                                                    requestBody: BulkCreateAssertion,
+                                                ): CancelablePromise<BulkCreateAssertion> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'POST',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}/assertions/bulk/',
+                                                        path: {
+                                                            'entity_id': entityId,
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                        body: requestBody,
+                                                        mediaType: 'application/json',
+                                                    });
+                                                }
+                                                /**
+                                                 * Endpoint to retrieve all credential assertions for a user within an organization.
+                                                 *
+                                                 * This endpoint provides access to all credential assertions (issued credentials)
+                                                 * for a specific user within an organization, with support for filtering.
+                                                 *
+                                                 * Path Parameters:
+                                                 * org (str): The organization/tenant identifier
+                                                 * user_id (str): The user ID to retrieve assertions for
+                                                 *
+                                                 * Query Parameters:
+                                                 * course (str, optional): Filter by course ID
+                                                 * include_revoked (bool, optional): Include revoked assertions (default: false)
+                                                 * include_expired (bool, optional): Include expired assertions (default: false)
+                                                 * exclude_main_tenant_assertions (bool, optional): Exclude assertions from the main tenant (default: false)
+                                                 *
+                                                 * Returns:
+                                                 * A paginated response using the AssertionSerializer format
+                                                 *
+                                                 * Error Responses:
+                                                 * 401 Unauthorized: If the user is not authenticated
+                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                 * 404 Not Found: If the user or organization doesn't exist
+                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param course
+                                                 * @param excludeMainTenantAssertions
+                                                 * @param includeExpired
+                                                 * @param includeRevoked
+                                                 * @param page
+                                                 * @param pageSize
+                                                 * @returns Assertion
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssertionsRetrieve(
+                                                    org: string,
+                                                    userId: string,
+                                                    course?: string,
+                                                    excludeMainTenantAssertions?: boolean,
+                                                    includeExpired?: boolean,
+                                                    includeRevoked?: boolean,
+                                                    page?: number,
+                                                    pageSize?: number,
+                                                ): CancelablePromise<Assertion> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assertions/',
+                                                        path: {
+                                                            'org': org,
+                                                            '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
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param departmentId When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                 * @param endDate end date. ISO 8601
+                                                 * @param format Format
+                                                 *
+                                                 * * `json` - json
+                                                 * @param includeMainPlatform Include main platform data
+                                                 * @param startDate start date. ISO 8601
+                                                 * @returns OvertimeWithChangeInfo
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssertionsOverTimeRetrieve(
+                                                    org: string,
+                                                    userId: string,
+                                                    departmentId?: number,
+                                                    endDate?: string,
+                                                    format: 'json' = 'json',
+                                                    includeMainPlatform: boolean = true,
+                                                    startDate?: string,
+                                                ): CancelablePromise<OvertimeWithChangeInfo> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assertions-over-time/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                        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
+                                                 * @param entityId
+                                                 * @param org
+                                                 * @param userId
+                                                 * @returns Assertion
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssertionsRetrieve2(
+                                                    entityId: string,
+                                                    org: string,
+                                                    userId: string,
+                                                ): CancelablePromise<Assertion> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assertions/{entity_id}',
+                                                        path: {
+                                                            'entity_id': entityId,
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * Endpoint to retrieve and update a specific credential assertion.
+                                                 *
+                                                 * This endpoint allows retrieving details of a specific credential assertion
+                                                 * and updating its status (e.g., revoking it).
+                                                 *
+                                                 * Path Parameters:
+                                                 * org (str): The organization/tenant identifier
+                                                 * user_id (str): The user ID making the request
+                                                 * entity_id (str): The assertion entity ID
+                                                 *
+                                                 * Methods:
+                                                 * GET: Retrieve assertion details
+                                                 * PUT: Update assertion status (e.g., revoke)
+                                                 *
+                                                 * PUT Request Body:
+                                                 * A JSON object containing:
+                                                 * - revoked (bool): Set to true to revoke the assertion
+                                                 * - revocationReason (str): Reason for revocation (required when revoking)
+                                                 *
+                                                 * Returns:
+                                                 * GET: A JSON response containing the assertion details using the AssertionSerializer format
+                                                 * PUT: A JSON response containing the updated assertion using the AssertionSerializer format
+                                                 *
+                                                 * Error Responses:
+                                                 * 400 Bad Request: If the request data is invalid
+                                                 * 401 Unauthorized: If the user is not authenticated
+                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                 * 404 Not Found: If the assertion doesn't exist
+                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                 * @param entityId
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param requestBody
+                                                 * @returns Assertion
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssertionsUpdate(
+                                                    entityId: string,
+                                                    org: string,
+                                                    userId: string,
+                                                    requestBody: Assertion,
+                                                ): CancelablePromise<Assertion> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'PUT',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assertions/{entity_id}',
+                                                        path: {
+                                                            'entity_id': entityId,
+                                                            'org': org,
+                                                            '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.
+                                                 * @param assignmentId
+                                                 * @param org
+                                                 * @param userId
+                                                 * @returns void
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssignmentsDestroy(
+                                                    assignmentId: string,
+                                                    org: string,
+                                                    userId: string,
+                                                ): CancelablePromise<void> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'DELETE',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/{assignment_id}',
+                                                        path: {
+                                                            'assignment_id': assignmentId,
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * Get group assignments with department-aware filtering
+                                                 * @param org
+                                                 * @param userId
+                                                 * @returns any No response body
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssignmentsGroupsRetrieve(
+                                                    org: string,
+                                                    userId: string,
+                                                ): CancelablePromise<any> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/groups/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * Create group assignment with department access validation
+                                                 * @param org
+                                                 * @param userId
+                                                 * @returns any No response body
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssignmentsGroupsCreate(
+                                                    org: string,
+                                                    userId: string,
+                                                ): CancelablePromise<any> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'POST',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/groups/',
+                                                        path: {
+                                                            'org': org,
+                                                            '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
+                                                 * @param org
+                                                 * @param userId
+                                                 * @returns any No response body
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssignmentsUsersRetrieve(
+                                                    org: string,
+                                                    userId: string,
+                                                ): CancelablePromise<any> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/users/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * Create assignments with department access validation
+                                                 * @param org
+                                                 * @param userId
+                                                 * @returns any No response body
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersAssignmentsUsersCreate(
+                                                    org: string,
+                                                    userId: string,
+                                                ): CancelablePromise<any> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'POST',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/users/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * Get all credentials of a given tenant
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param departmentId When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                 * @param endDate end date. ISO 8601
+                                                 * @param format Format
+                                                 *
+                                                 * * `json` - json
+                                                 * @param includeMainPlatform Include main platform data
+                                                 * @param startDate start date. ISO 8601
+                                                 * @returns OverTime
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve(
+                                                    org: string,
+                                                    userId: string,
+                                                    departmentId?: number,
+                                                    endDate?: string,
+                                                    format: 'json' = 'json',
+                                                    includeMainPlatform: boolean = true,
+                                                    startDate?: string,
+                                                ): CancelablePromise<OverTime> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/course-assertions-over-time/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                        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
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param page A page number within the paginated result set.
+                                                 * @param pageSize Number of results to return per page.
+                                                 * @returns any No response body
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersCourseCredentialsList(
+                                                    org: string,
+                                                    userId: string,
+                                                    page?: number,
+                                                    pageSize?: number,
+                                                ): CancelablePromise<any> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/course-credentials/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                        query: {
+                                                            'page': page,
+                                                            'page_size': pageSize,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * Get all credentials of a given tenant
+                                                 * @param org
+                                                 * @param userId
+                                                 * @param departmentId When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                 * @param endDate end date. ISO 8601
+                                                 * @param format Format
+                                                 *
+                                                 * * `json` - json
+                                                 * @param includeMainPlatform Include main platform data
+                                                 * @param startDate start date. ISO 8601
+                                                 * @returns OverTime
+                                                 * @throws ApiError
+                                                 */
+                                                public static credentialsOrgsUsersCredentialsOverTimeRetrieve(
+                                                    org: string,
+                                                    userId: string,
+                                                    departmentId?: number,
+                                                    endDate?: string,
+                                                    format: 'json' = 'json',
+                                                    includeMainPlatform: boolean = true,
+                                                    startDate?: string,
+                                                ): CancelablePromise<OverTime> {
+                                                    return __request(OpenAPI, {
+                                                        method: 'GET',
+                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/credentials-over-time/',
+                                                        path: {
+                                                            'org': org,
+                                                            'user_id': userId,
+                                                        },
+                                                        query: {
+                                                            'department_id': departmentId,
+                                                            'end_date': endDate,
+                                                            'format': format,
+                                                            'include_main_platform': includeMainPlatform,
+                                                            'start_date': startDate,
+                                                        },
+                                                    });
+                                                }
+                                                /**
+                                                 * API View for managing uploaded images for credentials.
+                                                 *
+                                                 * This endpoint allows uploading new images and retrieving existing images
+                                                 * for use with credentials (icons, backgrounds, thumbnails, etc.).
+                                                 *
+                                                 * Path Parameters:
+                                                 * org (str): The organization/tenant identifier
+                                                 * user_id (str): The user ID making the request
+                                                 *
+                                                 * Query Parameters:
+                                                 * query (str, required for GET): Search term to filter images by name
+                                                 *
+                                                 * Methods:
+                                                 * GET: Retrieve images matching a search query
+                                                 * POST: Upload a new image
+                                                 *
+                                                 * POST Request Body:
+                                                 * Multipart form data containing:
+                                                 * - image (file, required): The image file to upload
+                                                 * - name (str, optional): A descriptive name for the image
+                                                 *
+                                                 * Returns:
+                                                 * GET: A JSON array of image objects:
+                                                 * [
+                                                     * {
+                                                         * "id": 123,
+                                                         * "name": "Logo",
+                                                         * "image": "https://example.com/media/uploaded_images/logo.png"
+                                                         * },
+                                                         * {
+                                                             * "id": 124,
+                                                             * "name": "Background",
+                                                             * "image": "https://example.com/media/uploaded_images/background.jpg"
+                                                             * },
+                                                             * ...
+                                                             * ]
+                                                             *
+                                                             * POST: A JSON object containing the uploaded image details:
+                                                             * {
+                                                                 * "id": 125,
+                                                                 * "name": "Certificate Icon",
+                                                                 * "image": "https://example.com/media/uploaded_images/certificate-icon.png"
+                                                                 * }
+                                                                 *
+                                                                 * Error Responses:
+                                                                 * 400 Bad Request: If the request data is invalid or missing required parameters
+                                                                 * 401 Unauthorized: If the user is not authenticated
+                                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                                 *
+                                                                 * Access Control:
+                                                                 * - Requires IsAdminUserOrStudentDRFMixin
+                                                                 * - Only authenticated users with appropriate permissions can upload and retrieve images
+                                                                 * @param org
+                                                                 * @param userId
+                                                                 * @returns UploadedImage
+                                                                 * @throws ApiError
+                                                                 */
+                                                                public static credentialsOrgsUsersImagesRetrieve(
+                                                                    org: string,
+                                                                    userId: string,
+                                                                ): CancelablePromise<UploadedImage> {
+                                                                    return __request(OpenAPI, {
+                                                                        method: 'GET',
+                                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/images/',
+                                                                        path: {
+                                                                            'org': org,
+                                                                            '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
+                                                                 *
+                                                                 * Query Parameters:
+                                                                 * query (str, required for GET): Search term to filter images by name
+                                                                 *
+                                                                 * Methods:
+                                                                 * GET: Retrieve images matching a search query
+                                                                 * POST: Upload a new image
+                                                                 *
+                                                                 * POST Request Body:
+                                                                 * Multipart form data containing:
+                                                                 * - image (file, required): The image file to upload
+                                                                 * - name (str, optional): A descriptive name for the image
+                                                                 *
+                                                                 * Returns:
+                                                                 * GET: A JSON array of image objects:
+                                                                 * [
+                                                                     * {
+                                                                         * "id": 123,
+                                                                         * "name": "Logo",
+                                                                         * "image": "https://example.com/media/uploaded_images/logo.png"
+                                                                         * },
+                                                                         * {
+                                                                             * "id": 124,
+                                                                             * "name": "Background",
+                                                                             * "image": "https://example.com/media/uploaded_images/background.jpg"
+                                                                             * },
+                                                                             * ...
+                                                                             * ]
+                                                                             *
+                                                                             * POST: A JSON object containing the uploaded image details:
+                                                                             * {
+                                                                                 * "id": 125,
+                                                                                 * "name": "Certificate Icon",
+                                                                                 * "image": "https://example.com/media/uploaded_images/certificate-icon.png"
+                                                                                 * }
+                                                                                 *
+                                                                                 * Error Responses:
+                                                                                 * 400 Bad Request: If the request data is invalid or missing required parameters
+                                                                                 * 401 Unauthorized: If the user is not authenticated
+                                                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                                                 *
+                                                                                 * Access Control:
+                                                                                 * - Requires IsAdminUserOrStudentDRFMixin
+                                                                                 * - Only authenticated users with appropriate permissions can upload and retrieve images
+                                                                                 * @param org
+                                                                                 * @param userId
+                                                                                 * @param requestBody
+                                                                                 * @returns UploadedImage
+                                                                                 * @throws ApiError
+                                                                                 */
+                                                                                public static credentialsOrgsUsersImagesCreate(
+                                                                                    org: string,
+                                                                                    userId: string,
+                                                                                    requestBody?: UploadedImage,
+                                                                                ): CancelablePromise<UploadedImage> {
+                                                                                    return __request(OpenAPI, {
+                                                                                        method: 'POST',
+                                                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/images/',
+                                                                                        path: {
+                                                                                            'org': org,
+                                                                                            'user_id': userId,
+                                                                                        },
+                                                                                        body: requestBody,
+                                                                                        mediaType: 'application/json',
+                                                                                    });
+                                                                                }
+                                                                                /**
+                                                                                 * API View for managing credential issuers.
+                                                                                 *
+                                                                                 * This endpoint allows creating and retrieving issuers for a specific organization/tenant,
+                                                                                 * with support for filtering and pagination.
+                                                                                 *
+                                                                                 * Path Parameters:
+                                                                                 * org (str): The organization/tenant identifier
+                                                                                 * user_id (str): The user ID making the request
+                                                                                 *
+                                                                                 * Query Parameters:
+                                                                                 * q (str, optional): Search term to filter issuers by name
+                                                                                 * limit (int, optional): Number of results per page (default: 50)
+                                                                                 * offset (int, optional): Starting position for pagination
+                                                                                 *
+                                                                                 * Methods:
+                                                                                 * GET: Retrieve issuers with filtering and pagination
+                                                                                 * POST: Create a new issuer
+                                                                                 *
+                                                                                 * POST Request Body:
+                                                                                 * A JSON object containing issuer details:
+                                                                                 * - name (str): Issuer name
+                                                                                 * - iconImage (str, optional): URL to issuer icon
+                                                                                 * - email (str, optional): Contact email for the issuer
+                                                                                 * - url (str, optional): Website URL for the issuer
+                                                                                 * - allowed_template_tags (array, optional): List of allowed template tags
+                                                                                 *
+                                                                                 * Returns:
+                                                                                 * GET: A JSON response containing:
+                                                                                 * {
+                                                                                     * "status": {"success": true, "description": "Ok"},
+                                                                                     * "result": {
+                                                                                         * "next": "URL to next page",
+                                                                                         * "previous": "URL to previous page",
+                                                                                         * "count": 10,
+                                                                                         * "data": [
+                                                                                             * {issuer object},
+                                                                                             * {issuer object},
+                                                                                             * ...
+                                                                                             * ],
+                                                                                             * "num_pages": 1,
+                                                                                             * "page_number": 1,
+                                                                                             * "max_page_size": 1000
+                                                                                             * }
+                                                                                             * }
+                                                                                             *
+                                                                                             * POST: A JSON response containing:
+                                                                                             * {
+                                                                                                 * "status": {"success": true, "description": "Created"},
+                                                                                                 * "result": {issuer object}
+                                                                                                 * }
+                                                                                                 *
+                                                                                                 * Error Responses:
+                                                                                                 * 400 Bad Request: If the request data is invalid
+                                                                                                 * 401 Unauthorized: If the user is not authenticated
+                                                                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                                                                 * 404 Not Found: If the platform doesn't exist
+                                                                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                                                                 *
+                                                                                                 * Access Control:
+                                                                                                 * - Requires IsAdminUserOrStudentDRFMixin
+                                                                                                 * - Only authenticated users with appropriate permissions can manage issuers
+                                                                                                 * @param org
+                                                                                                 * @param q
+                                                                                                 * @param userId
+                                                                                                 * @returns Issuer
+                                                                                                 * @throws ApiError
+                                                                                                 */
+                                                                                                public static credentialsOrgsUsersIssuersRetrieve(
+                                                                                                    org: string,
+                                                                                                    q: string,
+                                                                                                    userId: string,
+                                                                                                ): CancelablePromise<Issuer> {
+                                                                                                    return __request(OpenAPI, {
+                                                                                                        method: 'GET',
+                                                                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/',
+                                                                                                        path: {
+                                                                                                            'org': org,
+                                                                                                            'user_id': userId,
+                                                                                                        },
+                                                                                                        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:
+                                                                                                 * {
+                                                                                                     * "status": {"success": true, "description": "Ok"},
+                                                                                                     * "result": {
+                                                                                                         * "next": "URL to next page",
+                                                                                                         * "previous": "URL to previous page",
+                                                                                                         * "count": 10,
+                                                                                                         * "data": [
+                                                                                                             * {issuer object},
+                                                                                                             * {issuer object},
+                                                                                                             * ...
+                                                                                                             * ],
+                                                                                                             * "num_pages": 1,
+                                                                                                             * "page_number": 1,
+                                                                                                             * "max_page_size": 1000
+                                                                                                             * }
+                                                                                                             * }
+                                                                                                             *
+                                                                                                             * POST: A JSON response containing:
+                                                                                                             * {
+                                                                                                                 * "status": {"success": true, "description": "Created"},
+                                                                                                                 * "result": {issuer object}
+                                                                                                                 * }
+                                                                                                                 *
+                                                                                                                 * Error Responses:
+                                                                                                                 * 400 Bad Request: If the request data is invalid
+                                                                                                                 * 401 Unauthorized: If the user is not authenticated
+                                                                                                                 * 403 Forbidden: If the user does not have permission to access this resource
+                                                                                                                 * 404 Not Found: If the platform doesn't exist
+                                                                                                                 * 500 Internal Server Error: If an unexpected error occurs
+                                                                                                                 *
+                                                                                                                 * Access Control:
+                                                                                                                 * - Requires IsAdminUserOrStudentDRFMixin
+                                                                                                                 * - Only authenticated users with appropriate permissions can manage issuers
+                                                                                                                 * @param org
+                                                                                                                 * @param q
+                                                                                                                 * @param userId
+                                                                                                                 * @param requestBody
+                                                                                                                 * @returns Issuer
+                                                                                                                 * @throws ApiError
+                                                                                                                 */
+                                                                                                                public static credentialsOrgsUsersIssuersCreate(
+                                                                                                                    org: string,
+                                                                                                                    q: string,
+                                                                                                                    userId: string,
+                                                                                                                    requestBody: Issuer,
+                                                                                                                ): CancelablePromise<Issuer> {
+                                                                                                                    return __request(OpenAPI, {
+                                                                                                                        method: 'POST',
+                                                                                                                        url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/',
+                                                                                                                        path: {
+                                                                                                                            'org': org,
+                                                                                                                            'user_id': userId,
+                                                                                                                        },
+                                                                                                                        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:
+                                                                                                                 * [
+                                                                                                                     * {
+                                                                                                                         * "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
+                                                                                                                                     * @param entityId
+                                                                                                                                     * @param org
+                                                                                                                                     * @param userId
+                                                                                                                                     * @returns Issuer
+                                                                                                                                     * @throws ApiError
+                                                                                                                                     */
+                                                                                                                                    public static credentialsOrgsUsersIssuersRetrieve2(
+                                                                                                                                        entityId: string,
+                                                                                                                                        org: string,
+                                                                                                                                        userId: string,
+                                                                                                                                    ): CancelablePromise<Issuer> {
+                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                            method: 'GET',
+                                                                                                                                            url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/{entity_id}',
+                                                                                                                                            path: {
+                                                                                                                                                'entity_id': entityId,
+                                                                                                                                                'org': org,
+                                                                                                                                                'user_id': userId,
+                                                                                                                                            },
+                                                                                                                                        });
+                                                                                                                                    }
+                                                                                                                                    /**
+                                                                                                                                     * 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
+                                                                                                                                                         * @param entityId
+                                                                                                                                                         * @param org
+                                                                                                                                                         * @param userId
+                                                                                                                                                         * @param requestBody
+                                                                                                                                                         * @returns Issuer
+                                                                                                                                                         * @throws ApiError
+                                                                                                                                                         */
+                                                                                                                                                        public static credentialsOrgsUsersIssuersUpdate(
+                                                                                                                                                            entityId: string,
+                                                                                                                                                            org: string,
+                                                                                                                                                            userId: string,
+                                                                                                                                                            requestBody: Issuer,
+                                                                                                                                                        ): CancelablePromise<Issuer> {
+                                                                                                                                                            return __request(OpenAPI, {
+                                                                                                                                                                method: 'PUT',
+                                                                                                                                                                url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/{entity_id}',
+                                                                                                                                                                path: {
+                                                                                                                                                                    'entity_id': entityId,
+                                                                                                                                                                    'org': org,
+                                                                                                                                                                    'user_id': userId,
+                                                                                                                                                                },
+                                                                                                                                                                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
+                                                                                                                                                                             * @param entityId
+                                                                                                                                                                             * @param org
+                                                                                                                                                                             * @param userId
+                                                                                                                                                                             * @returns void
+                                                                                                                                                                             * @throws ApiError
+                                                                                                                                                                             */
+                                                                                                                                                                            public static credentialsOrgsUsersIssuersDestroy(
+                                                                                                                                                                                entityId: string,
+                                                                                                                                                                                org: string,
+                                                                                                                                                                                userId: string,
+                                                                                                                                                                            ): CancelablePromise<void> {
+                                                                                                                                                                                return __request(OpenAPI, {
+                                                                                                                                                                                    method: 'DELETE',
+                                                                                                                                                                                    url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/{entity_id}',
+                                                                                                                                                                                    path: {
+                                                                                                                                                                                        'entity_id': entityId,
+                                                                                                                                                                                        'org': org,
+                                                                                                                                                                                        'user_id': userId,
+                                                                                                                                                                                    },
+                                                                                                                                                                                });
+                                                                                                                                                                            }
+                                                                                                                                                                            /**
+                                                                                                                                                                             * 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
+                                                                                                                                                                                     * @param org
+                                                                                                                                                                                     * @param userId
+                                                                                                                                                                                     * @param requestBody
+                                                                                                                                                                                     * @returns IssuerAuthority
+                                                                                                                                                                                     * @throws ApiError
+                                                                                                                                                                                     */
+                                                                                                                                                                                    public static credentialsOrgsUsersIssuersAuthorityCreate(
+                                                                                                                                                                                        org: string,
+                                                                                                                                                                                        userId: string,
+                                                                                                                                                                                        requestBody: IssuerAuthority,
+                                                                                                                                                                                    ): CancelablePromise<IssuerAuthority> {
+                                                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                                                            method: 'POST',
+                                                                                                                                                                                            url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/authority/',
+                                                                                                                                                                                            path: {
+                                                                                                                                                                                                'org': org,
+                                                                                                                                                                                                'user_id': userId,
+                                                                                                                                                                                            },
+                                                                                                                                                                                            body: requestBody,
+                                                                                                                                                                                            mediaType: 'application/json',
+                                                                                                                                                                                        });
+                                                                                                                                                                                    }
+                                                                                                                                                                                    /**
+                                                                                                                                                                                     * 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
+                                                                                                                                                                                     * @param entityId
+                                                                                                                                                                                     * @returns any No response body
+                                                                                                                                                                                     * @throws ApiError
+                                                                                                                                                                                     */
+                                                                                                                                                                                    public static credentialsPublicAssertionsRetrieve(
+                                                                                                                                                                                        entityId: string,
+                                                                                                                                                                                    ): CancelablePromise<any> {
+                                                                                                                                                                                        return __request(OpenAPI, {
+                                                                                                                                                                                            method: 'GET',
+                                                                                                                                                                                            url: '/api/credentials/public/assertions/{entity_id}/',
+                                                                                                                                                                                            path: {
+                                                                                                                                                                                                'entity_id': entityId,
+                                                                                                                                                                                            },
+                                                                                                                                                                                        });
+                                                                                                                                                                                    }
+                                                                                                                                                                                }