@iblai/iblai-api 0.0.2-core → 0.0.12-scan-core

package/src/services/CredentialsService.ts

@@ -9,6 +9,7 @@ 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 { PaginatedAssertionsResponse } from '../models/PaginatedAssertionsResponse';
 import type { UploadedImage } from '../models/UploadedImage';
 import type { CancelablePromise } from '../core/CancelablePromise';
 import { OpenAPI } from '../core/OpenAPI';
@@ -24,15 +25,16 @@ export class CredentialsService {
      * - 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(
+    public static credentialsOrgsUsersRetrieve({
+        org,
+        userId,
+    }: {
         org: string,
         userId: string,
-    ): CancelablePromise<Credential> {
+    }): CancelablePromise<Credential> {
         return __request(OpenAPI, {
             method: 'GET',
             url: '/api/credentials/orgs/{org}/users/{user_id}/',
@@ -119,17 +121,18 @@ export class CredentialsService {
                      * Access Control:
                      * - Requires CredentialAssignmentPermission
                      * - Only public credentials are returned by default
-                     * @param org
-                     * @param userId
-                     * @param requestBody
                      * @returns Credential
                      * @throws ApiError
                      */
-                    public static credentialsOrgsUsersCreate(
+                    public static credentialsOrgsUsersCreate({
+                        org,
+                        userId,
+                        requestBody,
+                    }: {
                         org: string,
                         userId: string,
                         requestBody: Credential,
-                    ): CancelablePromise<Credential> {
+                    }): CancelablePromise<Credential> {
                         return __request(OpenAPI, {
                             method: 'POST',
                             url: '/api/credentials/orgs/{org}/users/{user_id}/',
@@ -196,17 +199,18 @@ export class CredentialsService {
                              * 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(
+                            public static credentialsOrgsUsersRetrieve2({
+                                entityId,
+                                org,
+                                userId,
+                            }: {
                                 entityId: string,
                                 org: string,
                                 userId: string,
-                            ): CancelablePromise<Credential> {
+                            }): CancelablePromise<Credential> {
                                 return __request(OpenAPI, {
                                     method: 'GET',
                                     url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}',
@@ -272,19 +276,20 @@ export class CredentialsService {
                                      * 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(
+                                    public static credentialsOrgsUsersUpdate({
+                                        entityId,
+                                        org,
+                                        userId,
+                                        requestBody,
+                                    }: {
                                         entityId: string,
                                         org: string,
                                         userId: string,
                                         requestBody: Credential,
-                                    ): CancelablePromise<Credential> {
+                                    }): CancelablePromise<Credential> {
                                         return __request(OpenAPI, {
                                             method: 'PUT',
                                             url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}',
@@ -352,17 +357,18 @@ export class CredentialsService {
                                              * 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(
+                                            public static credentialsOrgsUsersDestroy({
+                                                entityId,
+                                                org,
+                                                userId,
+                                            }: {
                                                 entityId: string,
                                                 org: string,
                                                 userId: string,
-                                            ): CancelablePromise<void> {
+                                            }): CancelablePromise<void> {
                                                 return __request(OpenAPI, {
                                                     method: 'DELETE',
                                                     url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}',
@@ -402,17 +408,18 @@ export class CredentialsService {
                                              * 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
+                                             * @returns PaginatedAssertionsResponse
                                              * @throws ApiError
                                              */
-                                            public static credentialsOrgsUsersAssertionsRetrieve3(
+                                            public static credentialsOrgsUsersAssertionsRetrieve3({
+                                                entityId,
+                                                org,
+                                                userId,
+                                            }: {
                                                 entityId: string,
                                                 org: string,
                                                 userId: string,
-                                            ): CancelablePromise<Assertion> {
+                                            }): CancelablePromise<PaginatedAssertionsResponse> {
                                                 return __request(OpenAPI, {
                                                     method: 'GET',
                                                     url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}/assertions/',
@@ -452,19 +459,20 @@ export class CredentialsService {
                                              * 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(
+                                            public static credentialsOrgsUsersAssertionsCreate({
+                                                entityId,
+                                                org,
+                                                userId,
+                                                requestBody,
+                                            }: {
                                                 entityId: string,
                                                 org: string,
                                                 userId: string,
                                                 requestBody: Assertion,
-                                            ): CancelablePromise<Assertion> {
+                                            }): CancelablePromise<Assertion> {
                                                 return __request(OpenAPI, {
                                                     method: 'POST',
                                                     url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}/assertions/',
@@ -505,19 +513,20 @@ export class CredentialsService {
                                                  * 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(
+                                                public static credentialsOrgsUsersAssertionsBulkCreate({
+                                                    entityId,
+                                                    org,
+                                                    userId,
+                                                    requestBody,
+                                                }: {
                                                     entityId: string,
                                                     org: string,
                                                     userId: string,
                                                     requestBody: BulkCreateAssertion,
-                                                ): CancelablePromise<BulkCreateAssertion> {
+                                                }): CancelablePromise<BulkCreateAssertion> {
                                                     return __request(OpenAPI, {
                                                         method: 'POST',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/{entity_id}/assertions/bulk/',
@@ -554,18 +563,19 @@ export class CredentialsService {
                                                  * 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
+                                                 * @returns PaginatedAssertionsResponse
                                                  * @throws ApiError
                                                  */
-                                                public static credentialsOrgsUsersAssertionsRetrieve(
+                                                public static credentialsOrgsUsersAssertionsRetrieve({
+                                                    org,
+                                                    userId,
+                                                    course,
+                                                    excludeMainTenantAssertions,
+                                                    includeExpired,
+                                                    includeRevoked,
+                                                    page,
+                                                    pageSize,
+                                                }: {
                                                     org: string,
                                                     userId: string,
                                                     course?: string,
@@ -574,7 +584,7 @@ export class CredentialsService {
                                                     includeRevoked?: boolean,
                                                     page?: number,
                                                     pageSize?: number,
-                                                ): CancelablePromise<Assertion> {
+                                                }): CancelablePromise<PaginatedAssertionsResponse> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assertions/',
@@ -594,27 +604,43 @@ export class CredentialsService {
                                                 }
                                                 /**
                                                  * 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(
+                                                public static credentialsOrgsUsersAssertionsOverTimeRetrieve({
+                                                    org,
+                                                    userId,
+                                                    departmentId,
+                                                    endDate,
+                                                    format = 'json',
+                                                    includeMainPlatform = true,
+                                                    startDate,
+                                                }: {
                                                     org: string,
                                                     userId: string,
+                                                    /**
+                                                     * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                     */
                                                     departmentId?: number,
+                                                    /**
+                                                     * end date. ISO 8601
+                                                     */
                                                     endDate?: string,
-                                                    format: 'json' = 'json',
-                                                    includeMainPlatform: boolean = true,
+                                                    /**
+                                                     * Format
+                                                     *
+                                                     * * `json` - json
+                                                     */
+                                                    format?: 'json',
+                                                    /**
+                                                     * Include main platform data
+                                                     */
+                                                    includeMainPlatform?: boolean,
+                                                    /**
+                                                     * start date. ISO 8601
+                                                     */
                                                     startDate?: string,
-                                                ): CancelablePromise<OvertimeWithChangeInfo> {
+                                                }): CancelablePromise<OvertimeWithChangeInfo> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assertions-over-time/',
@@ -661,17 +687,18 @@ export class CredentialsService {
                                                  * 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(
+                                                public static credentialsOrgsUsersAssertionsRetrieve2({
+                                                    entityId,
+                                                    org,
+                                                    userId,
+                                                }: {
                                                     entityId: string,
                                                     org: string,
                                                     userId: string,
-                                                ): CancelablePromise<Assertion> {
+                                                }): CancelablePromise<Assertion> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assertions/{entity_id}',
@@ -712,19 +739,20 @@ export class CredentialsService {
                                                  * 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(
+                                                public static credentialsOrgsUsersAssertionsUpdate({
+                                                    entityId,
+                                                    org,
+                                                    userId,
+                                                    requestBody,
+                                                }: {
                                                     entityId: string,
                                                     org: string,
                                                     userId: string,
                                                     requestBody: Assertion,
-                                                ): CancelablePromise<Assertion> {
+                                                }): CancelablePromise<Assertion> {
                                                     return __request(OpenAPI, {
                                                         method: 'PUT',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assertions/{entity_id}',
@@ -740,17 +768,18 @@ export class CredentialsService {
                                                 /**
                                                  * 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(
+                                                public static credentialsOrgsUsersAssignmentsDestroy({
+                                                    assignmentId,
+                                                    org,
+                                                    userId,
+                                                }: {
                                                     assignmentId: string,
                                                     org: string,
                                                     userId: string,
-                                                ): CancelablePromise<void> {
+                                                }): CancelablePromise<void> {
                                                     return __request(OpenAPI, {
                                                         method: 'DELETE',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/{assignment_id}',
@@ -763,15 +792,16 @@ export class CredentialsService {
                                                 }
                                                 /**
                                                  * Get group assignments with department-aware filtering
-                                                 * @param org
-                                                 * @param userId
                                                  * @returns any No response body
                                                  * @throws ApiError
                                                  */
-                                                public static credentialsOrgsUsersAssignmentsGroupsRetrieve(
+                                                public static credentialsOrgsUsersAssignmentsGroupsRetrieve({
+                                                    org,
+                                                    userId,
+                                                }: {
                                                     org: string,
                                                     userId: string,
-                                                ): CancelablePromise<any> {
+                                                }): CancelablePromise<any> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/groups/',
@@ -783,15 +813,16 @@ export class CredentialsService {
                                                 }
                                                 /**
                                                  * Create group assignment with department access validation
-                                                 * @param org
-                                                 * @param userId
                                                  * @returns any No response body
                                                  * @throws ApiError
                                                  */
-                                                public static credentialsOrgsUsersAssignmentsGroupsCreate(
+                                                public static credentialsOrgsUsersAssignmentsGroupsCreate({
+                                                    org,
+                                                    userId,
+                                                }: {
                                                     org: string,
                                                     userId: string,
-                                                ): CancelablePromise<any> {
+                                                }): CancelablePromise<any> {
                                                     return __request(OpenAPI, {
                                                         method: 'POST',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/groups/',
@@ -806,15 +837,16 @@ export class CredentialsService {
                                                  * - 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(
+                                                public static credentialsOrgsUsersAssignmentsUsersRetrieve({
+                                                    org,
+                                                    userId,
+                                                }: {
                                                     org: string,
                                                     userId: string,
-                                                ): CancelablePromise<any> {
+                                                }): CancelablePromise<any> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/users/',
@@ -826,15 +858,16 @@ export class CredentialsService {
                                                 }
                                                 /**
                                                  * Create assignments with department access validation
-                                                 * @param org
-                                                 * @param userId
                                                  * @returns any No response body
                                                  * @throws ApiError
                                                  */
-                                                public static credentialsOrgsUsersAssignmentsUsersCreate(
+                                                public static credentialsOrgsUsersAssignmentsUsersCreate({
+                                                    org,
+                                                    userId,
+                                                }: {
                                                     org: string,
                                                     userId: string,
-                                                ): CancelablePromise<any> {
+                                                }): CancelablePromise<any> {
                                                     return __request(OpenAPI, {
                                                         method: 'POST',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/assignments/users/',
@@ -846,27 +879,43 @@ export class CredentialsService {
                                                 }
                                                 /**
                                                  * 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(
+                                                public static credentialsOrgsUsersCourseAssertionsOverTimeRetrieve({
+                                                    org,
+                                                    userId,
+                                                    departmentId,
+                                                    endDate,
+                                                    format = 'json',
+                                                    includeMainPlatform = true,
+                                                    startDate,
+                                                }: {
                                                     org: string,
                                                     userId: string,
+                                                    /**
+                                                     * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                     */
                                                     departmentId?: number,
+                                                    /**
+                                                     * end date. ISO 8601
+                                                     */
                                                     endDate?: string,
-                                                    format: 'json' = 'json',
-                                                    includeMainPlatform: boolean = true,
+                                                    /**
+                                                     * Format
+                                                     *
+                                                     * * `json` - json
+                                                     */
+                                                    format?: 'json',
+                                                    /**
+                                                     * Include main platform data
+                                                     */
+                                                    includeMainPlatform?: boolean,
+                                                    /**
+                                                     * start date. ISO 8601
+                                                     */
                                                     startDate?: string,
-                                                ): CancelablePromise<OverTime> {
+                                                }): CancelablePromise<OverTime> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/course-assertions-over-time/',
@@ -905,19 +954,26 @@ export class CredentialsService {
                                                  * 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(
+                                                public static credentialsOrgsUsersCourseCredentialsList({
+                                                    org,
+                                                    userId,
+                                                    page,
+                                                    pageSize,
+                                                }: {
                                                     org: string,
                                                     userId: string,
+                                                    /**
+                                                     * A page number within the paginated result set.
+                                                     */
                                                     page?: number,
+                                                    /**
+                                                     * Number of results to return per page.
+                                                     */
                                                     pageSize?: number,
-                                                ): CancelablePromise<any> {
+                                                }): CancelablePromise<any> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/course-credentials/',
@@ -933,27 +989,43 @@ export class CredentialsService {
                                                 }
                                                 /**
                                                  * 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(
+                                                public static credentialsOrgsUsersCredentialsOverTimeRetrieve({
+                                                    org,
+                                                    userId,
+                                                    departmentId,
+                                                    endDate,
+                                                    format = 'json',
+                                                    includeMainPlatform = true,
+                                                    startDate,
+                                                }: {
                                                     org: string,
                                                     userId: string,
+                                                    /**
+                                                     * When `department_mode=1` is passed, it allows to filter data for only user content groups for the specified department
+                                                     */
                                                     departmentId?: number,
+                                                    /**
+                                                     * end date. ISO 8601
+                                                     */
                                                     endDate?: string,
-                                                    format: 'json' = 'json',
-                                                    includeMainPlatform: boolean = true,
+                                                    /**
+                                                     * Format
+                                                     *
+                                                     * * `json` - json
+                                                     */
+                                                    format?: 'json',
+                                                    /**
+                                                     * Include main platform data
+                                                     */
+                                                    includeMainPlatform?: boolean,
+                                                    /**
+                                                     * start date. ISO 8601
+                                                     */
                                                     startDate?: string,
-                                                ): CancelablePromise<OverTime> {
+                                                }): CancelablePromise<OverTime> {
                                                     return __request(OpenAPI, {
                                                         method: 'GET',
                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/credentials-over-time/',
@@ -1024,15 +1096,16 @@ export class CredentialsService {
                                                                  * 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(
+                                                                public static credentialsOrgsUsersImagesRetrieve({
+                                                                    org,
+                                                                    userId,
+                                                                }: {
                                                                     org: string,
                                                                     userId: string,
-                                                                ): CancelablePromise<UploadedImage> {
+                                                                }): CancelablePromise<UploadedImage> {
                                                                     return __request(OpenAPI, {
                                                                         method: 'GET',
                                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/images/',
@@ -1096,17 +1169,18 @@ export class CredentialsService {
                                                                                  * 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(
+                                                                                public static credentialsOrgsUsersImagesCreate({
+                                                                                    org,
+                                                                                    userId,
+                                                                                    requestBody,
+                                                                                }: {
                                                                                     org: string,
                                                                                     userId: string,
                                                                                     requestBody?: UploadedImage,
-                                                                                ): CancelablePromise<UploadedImage> {
+                                                                                }): CancelablePromise<UploadedImage> {
                                                                                     return __request(OpenAPI, {
                                                                                         method: 'POST',
                                                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/images/',
@@ -1180,17 +1254,18 @@ export class CredentialsService {
                                                                                                  * 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(
+                                                                                                public static credentialsOrgsUsersIssuersRetrieve({
+                                                                                                    org,
+                                                                                                    q,
+                                                                                                    userId,
+                                                                                                }: {
                                                                                                     org: string,
                                                                                                     q: string,
                                                                                                     userId: string,
-                                                                                                ): CancelablePromise<Issuer> {
+                                                                                                }): CancelablePromise<Issuer> {
                                                                                                     return __request(OpenAPI, {
                                                                                                         method: 'GET',
                                                                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/',
@@ -1265,19 +1340,20 @@ export class CredentialsService {
                                                                                                                  * 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(
+                                                                                                                public static credentialsOrgsUsersIssuersCreate({
+                                                                                                                    org,
+                                                                                                                    q,
+                                                                                                                    userId,
+                                                                                                                    requestBody,
+                                                                                                                }: {
                                                                                                                     org: string,
                                                                                                                     q: string,
                                                                                                                     userId: string,
                                                                                                                     requestBody: Issuer,
-                                                                                                                ): CancelablePromise<Issuer> {
+                                                                                                                }): CancelablePromise<Issuer> {
                                                                                                                     return __request(OpenAPI, {
                                                                                                                         method: 'POST',
                                                                                                                         url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/',
@@ -1358,17 +1434,18 @@ export class CredentialsService {
                                                                                                                                      * 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(
+                                                                                                                                    public static credentialsOrgsUsersIssuersRetrieve2({
+                                                                                                                                        entityId,
+                                                                                                                                        org,
+                                                                                                                                        userId,
+                                                                                                                                    }: {
                                                                                                                                         entityId: string,
                                                                                                                                         org: string,
                                                                                                                                         userId: string,
-                                                                                                                                    ): CancelablePromise<Issuer> {
+                                                                                                                                    }): CancelablePromise<Issuer> {
                                                                                                                                         return __request(OpenAPI, {
                                                                                                                                             method: 'GET',
                                                                                                                                             url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/{entity_id}',
@@ -1445,19 +1522,20 @@ export class CredentialsService {
                                                                                                                                                          * 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(
+                                                                                                                                                        public static credentialsOrgsUsersIssuersUpdate({
+                                                                                                                                                            entityId,
+                                                                                                                                                            org,
+                                                                                                                                                            userId,
+                                                                                                                                                            requestBody,
+                                                                                                                                                        }: {
                                                                                                                                                             entityId: string,
                                                                                                                                                             org: string,
                                                                                                                                                             userId: string,
                                                                                                                                                             requestBody: Issuer,
-                                                                                                                                                        ): CancelablePromise<Issuer> {
+                                                                                                                                                        }): CancelablePromise<Issuer> {
                                                                                                                                                             return __request(OpenAPI, {
                                                                                                                                                                 method: 'PUT',
                                                                                                                                                                 url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/{entity_id}',
@@ -1536,17 +1614,18 @@ export class CredentialsService {
                                                                                                                                                                              * 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(
+                                                                                                                                                                            public static credentialsOrgsUsersIssuersDestroy({
+                                                                                                                                                                                entityId,
+                                                                                                                                                                                org,
+                                                                                                                                                                                userId,
+                                                                                                                                                                            }: {
                                                                                                                                                                                 entityId: string,
                                                                                                                                                                                 org: string,
                                                                                                                                                                                 userId: string,
-                                                                                                                                                                            ): CancelablePromise<void> {
+                                                                                                                                                                            }): CancelablePromise<void> {
                                                                                                                                                                                 return __request(OpenAPI, {
                                                                                                                                                                                     method: 'DELETE',
                                                                                                                                                                                     url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/{entity_id}',
@@ -1599,17 +1678,18 @@ export class CredentialsService {
                                                                                                                                                                                      * 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(
+                                                                                                                                                                                    public static credentialsOrgsUsersIssuersAuthorityCreate({
+                                                                                                                                                                                        org,
+                                                                                                                                                                                        userId,
+                                                                                                                                                                                        requestBody,
+                                                                                                                                                                                    }: {
                                                                                                                                                                                         org: string,
                                                                                                                                                                                         userId: string,
                                                                                                                                                                                         requestBody: IssuerAuthority,
-                                                                                                                                                                                    ): CancelablePromise<IssuerAuthority> {
+                                                                                                                                                                                    }): CancelablePromise<IssuerAuthority> {
                                                                                                                                                                                         return __request(OpenAPI, {
                                                                                                                                                                                             method: 'POST',
                                                                                                                                                                                             url: '/api/credentials/orgs/{org}/users/{user_id}/issuers/authority/',
@@ -1638,13 +1718,14 @@ export class CredentialsService {
                                                                                                                                                                                      * - 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
+                                                                                                                                                                                     * @returns Assertion
                                                                                                                                                                                      * @throws ApiError
                                                                                                                                                                                      */
-                                                                                                                                                                                    public static credentialsPublicAssertionsRetrieve(
+                                                                                                                                                                                    public static credentialsPublicAssertionsRetrieve({
+                                                                                                                                                                                        entityId,
+                                                                                                                                                                                    }: {
                                                                                                                                                                                         entityId: string,
-                                                                                                                                                                                    ): CancelablePromise<any> {
+                                                                                                                                                                                    }): CancelablePromise<Assertion> {
                                                                                                                                                                                         return __request(OpenAPI, {
                                                                                                                                                                                             method: 'GET',
                                                                                                                                                                                             url: '/api/credentials/public/assertions/{entity_id}/',