@iblai/iblai-api 4.328.1-core → 4.329.0-core

package/src/models/PlacementProgramAssignmentCreate.ts

@@ -0,0 +1,15 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Grant one program to a platform user, optionally linked to a placement.
+ */
+export type PlacementProgramAssignmentCreate = {
+    user_id: number;
+    program_key: string;
+    started?: string;
+    expired?: string;
+    placement_id?: number;
+};
+

package/src/models/PlacementRecordCreate.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Assign a configured assessment to a platform user (no application).
+ */
+export type PlacementRecordCreate = {
+    user_id: number;
+    assessment_id: number;
+    session_id?: string;
+    note?: string;
+};
+

package/src/models/PlatformApplicationPlacementItem.ts

@@ -3,13 +3,12 @@
 /* tslint:disable */
 /* eslint-disable */
 /**
- * One placement assignment: which candidate, which mentor.
+ * One placement assignment: which candidate, which configured assessment.
+ * The agent and subject come from the assessment, snapshotted onto the record.
  */
 export type PlatformApplicationPlacementItem = {
     candidate_id: number;
-    mentor_unique_id: string;
-    mentor_label?: string;
-    label?: string;
+    assessment_id: number;
     session_id?: string;
     note?: string;
 };

package/src/models/SourceEnum.ts

@@ -0,0 +1,14 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * * `agent` - agent
+ * * `manual` - manual
+ * * `external` - external
+ */
+export enum SourceEnum {
+    AGENT = 'agent',
+    MANUAL = 'manual',
+    EXTERNAL = 'external',
+}

package/src/services/CatalogService.ts

@@ -72,6 +72,7 @@ import type { PaginatedSkill } from '../models/PaginatedSkill';
 import type { PaginatedUserLicense } from '../models/PaginatedUserLicense';
 import type { PaginatedUserLicenseAssignment } from '../models/PaginatedUserLicenseAssignment';
 import type { PaginatedUserLicenseGroupAssignment } from '../models/PaginatedUserLicenseGroupAssignment';
+import type { PatchedPlacementAssessmentUpdate } from '../models/PatchedPlacementAssessmentUpdate';
 import type { PatchedPlatformApplicationFormUpdate } from '../models/PatchedPlatformApplicationFormUpdate';
 import type { PatchedPlatformApplicationNote } from '../models/PatchedPlatformApplicationNote';
 import type { PatchedPlatformApplicationPlacementUpdate } from '../models/PatchedPlatformApplicationPlacementUpdate';
@@ -89,6 +90,10 @@ import type { PathwaySelfEnrollmentRequest } from '../models/PathwaySelfEnrollme
 import type { PathwaySuggestionBulkCreate } from '../models/PathwaySuggestionBulkCreate';
 import type { PathwaySuggestionCreate } from '../models/PathwaySuggestionCreate';
 import type { PathwaySuggestionDetail } from '../models/PathwaySuggestionDetail';
+import type { PlacementAssessment } from '../models/PlacementAssessment';
+import type { PlacementCourseAssignmentCreate } from '../models/PlacementCourseAssignmentCreate';
+import type { PlacementProgramAssignmentCreate } from '../models/PlacementProgramAssignmentCreate';
+import type { PlacementRecordCreate } from '../models/PlacementRecordCreate';
 import type { PlatformApplicationAdminSubmit } from '../models/PlatformApplicationAdminSubmit';
 import type { PlatformApplicationAttachmentUpload } from '../models/PlatformApplicationAttachmentUpload';
 import type { PlatformApplicationCandidateLink } from '../models/PlatformApplicationCandidateLink';
@@ -7735,6 +7740,327 @@ export class CatalogService {
                                                                                                                     },
                                                                                                                 });
                                                                                                             }
+                                                                                                            /**
+                                                                                                             * A platform's placement assessments (#2280): list and create.
+                                                                                                             * @returns any Assessments for the platform
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsAssessmentsRetrieve(): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'GET',
+                                                                                                                    url: '/api/catalog/placements/assessments/',
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * A platform's placement assessments (#2280): list and create.
+                                                                                                             * @returns any Assessment created
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsAssessmentsCreate({
+                                                                                                                requestBody,
+                                                                                                            }: {
+                                                                                                                requestBody: PlacementAssessment,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'POST',
+                                                                                                                    url: '/api/catalog/placements/assessments/',
+                                                                                                                    body: requestBody,
+                                                                                                                    mediaType: 'application/json',
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * A single placement assessment: view, edit, or delete.
+                                                                                                             * @returns any Assessment
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsAssessmentsRetrieve2({
+                                                                                                                assessmentId,
+                                                                                                            }: {
+                                                                                                                assessmentId: string,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'GET',
+                                                                                                                    url: '/api/catalog/placements/assessments/{assessment_id}/',
+                                                                                                                    path: {
+                                                                                                                        'assessment_id': assessmentId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * A single placement assessment: view, edit, or delete.
+                                                                                                             * @returns any Assessment updated
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsAssessmentsPartialUpdate({
+                                                                                                                assessmentId,
+                                                                                                                requestBody,
+                                                                                                            }: {
+                                                                                                                assessmentId: string,
+                                                                                                                requestBody?: PatchedPlacementAssessmentUpdate,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'PATCH',
+                                                                                                                    url: '/api/catalog/placements/assessments/{assessment_id}/',
+                                                                                                                    path: {
+                                                                                                                        'assessment_id': assessmentId,
+                                                                                                                    },
+                                                                                                                    body: requestBody,
+                                                                                                                    mediaType: 'application/json',
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * A single placement assessment: view, edit, or delete.
+                                                                                                             * @returns void
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsAssessmentsDestroy({
+                                                                                                                assessmentId,
+                                                                                                            }: {
+                                                                                                                assessmentId: string,
+                                                                                                            }): CancelablePromise<void> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'DELETE',
+                                                                                                                    url: '/api/catalog/placements/assessments/{assessment_id}/',
+                                                                                                                    path: {
+                                                                                                                        'assessment_id': assessmentId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Course assignments on a platform (#2280): list (optionally by user), and
+                                                                                                             * grant a course to a user. Each grant issues a ``CourseInvitation`` the
+                                                                                                             * existing pipeline enrolls.
+                                                                                                             * @returns any Course assignments
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsCourseAssignmentsRetrieve({
+                                                                                                                platformKey,
+                                                                                                                userId,
+                                                                                                            }: {
+                                                                                                                platformKey: string,
+                                                                                                                userId?: number,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'GET',
+                                                                                                                    url: '/api/catalog/placements/course-assignments/',
+                                                                                                                    query: {
+                                                                                                                        'platform_key': platformKey,
+                                                                                                                        'user_id': userId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Course assignments on a platform (#2280): list (optionally by user), and
+                                                                                                             * grant a course to a user. Each grant issues a ``CourseInvitation`` the
+                                                                                                             * existing pipeline enrolls.
+                                                                                                             * @returns any Course assigned
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsCourseAssignmentsCreate({
+                                                                                                                platformKey,
+                                                                                                                requestBody,
+                                                                                                                userId,
+                                                                                                            }: {
+                                                                                                                platformKey: string,
+                                                                                                                requestBody: PlacementCourseAssignmentCreate,
+                                                                                                                userId?: number,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'POST',
+                                                                                                                    url: '/api/catalog/placements/course-assignments/',
+                                                                                                                    query: {
+                                                                                                                        'platform_key': platformKey,
+                                                                                                                        'user_id': userId,
+                                                                                                                    },
+                                                                                                                    body: requestBody,
+                                                                                                                    mediaType: 'application/json',
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Remove one course assignment: deactivate the record and cancel its
+                                                                                                             * invitation when the student has not yet enrolled through it.
+                                                                                                             * @returns void
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsCourseAssignmentsDestroy({
+                                                                                                                assignmentId,
+                                                                                                            }: {
+                                                                                                                assignmentId: string,
+                                                                                                            }): CancelablePromise<void> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'DELETE',
+                                                                                                                    url: '/api/catalog/placements/course-assignments/{assignment_id}/',
+                                                                                                                    path: {
+                                                                                                                        'assignment_id': assignmentId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Program assignments on a platform (#2280): list (optionally by user), and
+                                                                                                             * grant a program to a user. Each grant issues a ``ProgramInvitation``.
+                                                                                                             * @returns any Program assignments
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsProgramAssignmentsRetrieve({
+                                                                                                                platformKey,
+                                                                                                                userId,
+                                                                                                            }: {
+                                                                                                                platformKey: string,
+                                                                                                                userId?: number,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'GET',
+                                                                                                                    url: '/api/catalog/placements/program-assignments/',
+                                                                                                                    query: {
+                                                                                                                        'platform_key': platformKey,
+                                                                                                                        'user_id': userId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Program assignments on a platform (#2280): list (optionally by user), and
+                                                                                                             * grant a program to a user. Each grant issues a ``ProgramInvitation``.
+                                                                                                             * @returns any Program assigned
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsProgramAssignmentsCreate({
+                                                                                                                platformKey,
+                                                                                                                requestBody,
+                                                                                                                userId,
+                                                                                                            }: {
+                                                                                                                platformKey: string,
+                                                                                                                requestBody: PlacementProgramAssignmentCreate,
+                                                                                                                userId?: number,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'POST',
+                                                                                                                    url: '/api/catalog/placements/program-assignments/',
+                                                                                                                    query: {
+                                                                                                                        'platform_key': platformKey,
+                                                                                                                        'user_id': userId,
+                                                                                                                    },
+                                                                                                                    body: requestBody,
+                                                                                                                    mediaType: 'application/json',
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Remove one program assignment: deactivate the record and cancel its
+                                                                                                             * invitation when the student has not yet enrolled through it.
+                                                                                                             * @returns void
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsProgramAssignmentsDestroy({
+                                                                                                                assignmentId,
+                                                                                                            }: {
+                                                                                                                assignmentId: string,
+                                                                                                            }): CancelablePromise<void> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'DELETE',
+                                                                                                                    url: '/api/catalog/placements/program-assignments/{assignment_id}/',
+                                                                                                                    path: {
+                                                                                                                        'assignment_id': assignmentId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Placement records on a platform (#2280): list (filter by user, assessment,
+                                                                                                             * or status), and assign a configured assessment to a user.
+                                                                                                             * @returns any Placement records
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsRecordsRetrieve({
+                                                                                                                platformKey,
+                                                                                                                assessmentId,
+                                                                                                                status,
+                                                                                                                userId,
+                                                                                                            }: {
+                                                                                                                platformKey: string,
+                                                                                                                assessmentId?: number,
+                                                                                                                /**
+                                                                                                                 * * `not_assigned` - not_assigned
+                                                                                                                 * * `assigned` - assigned
+                                                                                                                 * * `started` - started
+                                                                                                                 * * `completed` - completed
+                                                                                                                 * * `reviewed` - reviewed
+                                                                                                                 * * `confirmed` - confirmed
+                                                                                                                 */
+                                                                                                                status?: 'not_assigned' | 'assigned' | 'started' | 'completed' | 'reviewed' | 'confirmed',
+                                                                                                                userId?: number,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'GET',
+                                                                                                                    url: '/api/catalog/placements/records/',
+                                                                                                                    query: {
+                                                                                                                        'assessment_id': assessmentId,
+                                                                                                                        'platform_key': platformKey,
+                                                                                                                        'status': status,
+                                                                                                                        'user_id': userId,
+                                                                                                                    },
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Placement records on a platform (#2280): list (filter by user, assessment,
+                                                                                                             * or status), and assign a configured assessment to a user.
+                                                                                                             * @returns any Placement assigned
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsRecordsCreate({
+                                                                                                                platformKey,
+                                                                                                                requestBody,
+                                                                                                                assessmentId,
+                                                                                                                status,
+                                                                                                                userId,
+                                                                                                            }: {
+                                                                                                                platformKey: string,
+                                                                                                                requestBody: PlacementRecordCreate,
+                                                                                                                assessmentId?: number,
+                                                                                                                /**
+                                                                                                                 * * `not_assigned` - not_assigned
+                                                                                                                 * * `assigned` - assigned
+                                                                                                                 * * `started` - started
+                                                                                                                 * * `completed` - completed
+                                                                                                                 * * `reviewed` - reviewed
+                                                                                                                 * * `confirmed` - confirmed
+                                                                                                                 */
+                                                                                                                status?: 'not_assigned' | 'assigned' | 'started' | 'completed' | 'reviewed' | 'confirmed',
+                                                                                                                userId?: number,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'POST',
+                                                                                                                    url: '/api/catalog/placements/records/',
+                                                                                                                    query: {
+                                                                                                                        'assessment_id': assessmentId,
+                                                                                                                        'platform_key': platformKey,
+                                                                                                                        'status': status,
+                                                                                                                        'user_id': userId,
+                                                                                                                    },
+                                                                                                                    body: requestBody,
+                                                                                                                    mediaType: 'application/json',
+                                                                                                                });
+                                                                                                            }
+                                                                                                            /**
+                                                                                                             * Advance a single placement record: status, the agent's result, an admin
+                                                                                                             * override, or a note.
+                                                                                                             * @returns any Record updated
+                                                                                                             * @throws ApiError
+                                                                                                             */
+                                                                                                            public static catalogPlacementsRecordsPartialUpdate({
+                                                                                                                recordId,
+                                                                                                                requestBody,
+                                                                                                            }: {
+                                                                                                                recordId: string,
+                                                                                                                requestBody?: PatchedPlatformApplicationPlacementUpdate,
+                                                                                                            }): CancelablePromise<any> {
+                                                                                                                return __request(OpenAPI, {
+                                                                                                                    method: 'PATCH',
+                                                                                                                    url: '/api/catalog/placements/records/{record_id}/',
+                                                                                                                    path: {
+                                                                                                                        'record_id': recordId,
+                                                                                                                    },
+                                                                                                                    body: requestBody,
+                                                                                                                    mediaType: 'application/json',
+                                                                                                                });
+                                                                                                            }
                                                                                                             /**
                                                                                                              * Retrieve programs matching query parameters. Limited parameters include program_id, name, slug, enabled, and org.
                                                                                                              * @returns Program