@iblai/iblai-api 4.305.0-core → 4.306.0-core

package/src/services/CatalogService.ts

@@ -72,6 +72,10 @@ 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 { PatchedPlatformApplicationFormUpdate } from '../models/PatchedPlatformApplicationFormUpdate';
+import type { PatchedPlatformApplicationNote } from '../models/PatchedPlatformApplicationNote';
+import type { PatchedPlatformApplicationPlacementUpdate } from '../models/PatchedPlatformApplicationPlacementUpdate';
+import type { PatchedPlatformApplicationUpdate } from '../models/PatchedPlatformApplicationUpdate';
 import type { Pathway } from '../models/Pathway';
 import type { PathwayCompletionResponse } from '../models/PathwayCompletionResponse';
 import type { PathwayCreateUpdateRequest } from '../models/PathwayCreateUpdateRequest';
@@ -85,6 +89,20 @@ 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 { PlatformApplicationAdminSubmit } from '../models/PlatformApplicationAdminSubmit';
+import type { PlatformApplicationAttachmentUpload } from '../models/PlatformApplicationAttachmentUpload';
+import type { PlatformApplicationCandidateLink } from '../models/PlatformApplicationCandidateLink';
+import type { PlatformApplicationCourseAssignment } from '../models/PlatformApplicationCourseAssignment';
+import type { PlatformApplicationCreate } from '../models/PlatformApplicationCreate';
+import type { PlatformApplicationDetail } from '../models/PlatformApplicationDetail';
+import type { PlatformApplicationFeeAction } from '../models/PlatformApplicationFeeAction';
+import type { PlatformApplicationFormCreate } from '../models/PlatformApplicationFormCreate';
+import type { PlatformApplicationFormDetail } from '../models/PlatformApplicationFormDetail';
+import type { PlatformApplicationNote } from '../models/PlatformApplicationNote';
+import type { PlatformApplicationPlacementCreate } from '../models/PlatformApplicationPlacementCreate';
+import type { PlatformApplicationSubmit } from '../models/PlatformApplicationSubmit';
+import type { PlatformApplicationTransition } from '../models/PlatformApplicationTransition';
+import type { PlatformApplicationWaiver } from '../models/PlatformApplicationWaiver';
 import type { PlatformInvitationCreate } from '../models/PlatformInvitationCreate';
 import type { PlatformInvitationDetail } from '../models/PlatformInvitationDetail';
 import type { PlatformInvitationRedemption } from '../models/PlatformInvitationRedemption';
@@ -352,6 +370,1184 @@ export class CatalogService {
             },
         });
     }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns any Own submissions
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformRetrieve({
+        formId,
+        platformKey,
+        platformOrg,
+    }: {
+        formId?: number,
+        platformKey?: string,
+        platformOrg?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/',
+            query: {
+                'form_id': formId,
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+            },
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns PlatformApplicationDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformCreate({
+        requestBody,
+    }: {
+        requestBody: PlatformApplicationCreate,
+    }): CancelablePromise<PlatformApplicationDetail> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns PlatformApplicationDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformRetrieve2({
+        submissionId,
+    }: {
+        submissionId: string,
+    }): CancelablePromise<PlatformApplicationDetail> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/{submission_id}/',
+            path: {
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns PlatformApplicationDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformPartialUpdate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody?: PatchedPlatformApplicationUpdate,
+    }): CancelablePromise<PlatformApplicationDetail> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/catalog/applications/platform/{submission_id}/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns any Attachment stored
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformAttachmentsCreate({
+        submissionId,
+        formData,
+    }: {
+        submissionId: string,
+        formData: PlatformApplicationAttachmentUpload,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/{submission_id}/attachments/',
+            path: {
+                'submission_id': submissionId,
+            },
+            formData: formData,
+            mediaType: 'multipart/form-data',
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns void
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformAttachmentsDestroy({
+        attachmentId,
+        submissionId,
+    }: {
+        attachmentId: string,
+        submissionId: string,
+    }): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/catalog/applications/platform/{submission_id}/attachments/{attachment_id}/',
+            path: {
+                'attachment_id': attachmentId,
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns PlatformApplicationDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformSubmitCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody?: PlatformApplicationSubmit,
+    }): CancelablePromise<PlatformApplicationDetail> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/{submission_id}/submit/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns PlatformApplicationDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformWithdrawCreate({
+        submissionId,
+    }: {
+        submissionId: string,
+    }): CancelablePromise<PlatformApplicationDetail> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/{submission_id}/withdraw/',
+            path: {
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns any Active form
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformFormRetrieve({
+        formId,
+        platformKey,
+        platformOrg,
+    }: {
+        formId?: number,
+        platformKey?: string,
+        platformOrg?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/form/',
+            query: {
+                'form_id': formId,
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+            },
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns any Forms for the platform
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformFormsManageRetrieve({
+        platformKey,
+        platformOrg,
+        sort,
+    }: {
+        platformKey?: string,
+        platformOrg?: string,
+        sort?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/forms/manage/',
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'sort': sort,
+            },
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns PlatformApplicationFormDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformFormsManageCreate({
+        requestBody,
+        platformKey,
+        platformOrg,
+        sort,
+    }: {
+        requestBody: PlatformApplicationFormCreate,
+        platformKey?: string,
+        platformOrg?: string,
+        sort?: string,
+    }): CancelablePromise<PlatformApplicationFormDetail> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/forms/manage/',
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'sort': sort,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns PlatformApplicationFormDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformFormsManageRetrieve2({
+        formId,
+        platformKey,
+        platformOrg,
+        sort,
+    }: {
+        formId: string,
+        platformKey?: string,
+        platformOrg?: string,
+        sort?: string,
+    }): CancelablePromise<PlatformApplicationFormDetail> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/forms/manage/{form_id}/',
+            path: {
+                'form_id': formId,
+            },
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'sort': sort,
+            },
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns PlatformApplicationFormDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformFormsManagePartialUpdate({
+        formId,
+        platformKey,
+        platformOrg,
+        sort,
+        requestBody,
+    }: {
+        formId: string,
+        platformKey?: string,
+        platformOrg?: string,
+        sort?: string,
+        requestBody?: PatchedPlatformApplicationFormUpdate,
+    }): CancelablePromise<PlatformApplicationFormDetail> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/catalog/applications/platform/forms/manage/{form_id}/',
+            path: {
+                'form_id': formId,
+            },
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'sort': sort,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns any Submissions for the platform
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageRetrieve({
+        platformKey,
+        platformOrg,
+        search,
+        sort,
+        status,
+    }: {
+        platformKey?: string,
+        platformOrg?: string,
+        search?: string,
+        sort?: string,
+        status?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/',
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'search': search,
+                'sort': sort,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns any Full submission detail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageRetrieve2({
+        submissionId,
+        platformKey,
+        platformOrg,
+        search,
+        sort,
+        status,
+    }: {
+        submissionId: string,
+        platformKey?: string,
+        platformOrg?: string,
+        search?: string,
+        sort?: string,
+        status?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/',
+            path: {
+                'submission_id': submissionId,
+            },
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'search': search,
+                'sort': sort,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Reviewer download: redirect to the storage's (signed, on S3) file URL.
+     *
+     * Gated by ``IsDMAdmin | IsPlatformAdmin`` plus the RBAC verb check on the
+     * attachment's own platform when RBAC is enabled.
+     * @returns void
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageAttachmentsDownloadRetrieve({
+        attachmentId,
+        submissionId,
+    }: {
+        attachmentId: string,
+        submissionId: string,
+    }): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/attachments/{attachment_id}/download/',
+            path: {
+                'attachment_id': attachmentId,
+                'submission_id': submissionId,
+            },
+            errors: {
+                302: `Redirect to the file URL`,
+            },
+        });
+    }
+    /**
+     * Re-run settlement provisioning for one accepted candidate: links them
+     * if an account with their designated email now exists, or re-issues the
+     * platform invitation if none is active. Covers the invite-missing state.
+     * @returns any Candidate after provisioning
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageCandidatesInviteCreate({
+        candidateId,
+        submissionId,
+    }: {
+        candidateId: string,
+        submissionId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/candidates/{candidate_id}/invite/',
+            path: {
+                'candidate_id': candidateId,
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Manually link an accepted candidate to an existing account (the
+     * account-unlinked state: the family signed up outside invitation
+     * redemption, or under a different email than designated).
+     * @returns any Candidate linked
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageCandidatesLinkCreate({
+        candidateId,
+        submissionId,
+        requestBody,
+    }: {
+        candidateId: string,
+        submissionId: string,
+        requestBody?: PlatformApplicationCandidateLink,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/candidates/{candidate_id}/link/',
+            path: {
+                'candidate_id': candidateId,
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Course assignments for a submission (#2134): list, and assign courses to
+     * accepted candidates individually or in bulk. Each successful item issues a
+     * CourseInvitation that the existing pipeline enrolls.
+     * @returns any Assignments for the submission
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageCourseAssignmentsRetrieve({
+        submissionId,
+    }: {
+        submissionId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/course-assignments/',
+            path: {
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Course assignments for a submission (#2134): list, and assign courses to
+     * accepted candidates individually or in bulk. Each successful item issues a
+     * CourseInvitation that the existing pipeline enrolls.
+     * @returns any Per-item assignment results
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageCourseAssignmentsCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody: PlatformApplicationCourseAssignment,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/course-assignments/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Remove one course assignment (§9.2 "enrollment changes after the school
+     * year begins" — the record side).
+     *
+     * Deactivates the assignment and cancels its invitation when the student has
+     * not yet been enrolled through it. It never unenrolls an already-enrolled
+     * student: platform admins un-enroll deliberately through the catalog
+     * enrollment endpoints, not from an admissions record.
+     * @returns void
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageCourseAssignmentsDestroy({
+        assignmentId,
+        submissionId,
+    }: {
+        assignmentId: string,
+        submissionId: string,
+    }): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/course-assignments/{assignment_id}/',
+            path: {
+                'assignment_id': assignmentId,
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Reviewer/admin view of a submission's application fee (#2132, §5).
+     *
+     * GET returns the charge and its event history; POST records an out-of-band
+     * payment or a waiver/refund/credit. Money collection through Stripe is a
+     * later segment; this is the domain side.
+     * @returns any Charge + events
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageFeeRetrieve({
+        submissionId,
+    }: {
+        submissionId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/fee/',
+            path: {
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Reviewer/admin view of a submission's application fee (#2132, §5).
+     *
+     * GET returns the charge and its event history; POST records an out-of-band
+     * payment or a waiver/refund/credit. Money collection through Stripe is a
+     * later segment; this is the domain side.
+     * @returns any Charge updated
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageFeeCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody: PlatformApplicationFeeAction,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/fee/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Internal reviewer notes on a submission (#2089, §6). Never surfaced on
+     * applicant endpoints. GET lists (optional ``kind`` filter); POST adds one.
+     * @returns any Notes for the submission
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageNotesRetrieve({
+        submissionId,
+        platformKey,
+        platformOrg,
+        search,
+        sort,
+        status,
+    }: {
+        submissionId: string,
+        platformKey?: string,
+        platformOrg?: string,
+        search?: string,
+        sort?: string,
+        status?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/notes/',
+            path: {
+                'submission_id': submissionId,
+            },
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'search': search,
+                'sort': sort,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Internal reviewer notes on a submission (#2089, §6). Never surfaced on
+     * applicant endpoints. GET lists (optional ``kind`` filter); POST adds one.
+     * @returns any Note created
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageNotesCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody: PlatformApplicationNote,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/notes/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Edit or remove a single internal reviewer note.
+     * @returns any Note updated
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageNotesPartialUpdate({
+        noteId,
+        submissionId,
+        requestBody,
+    }: {
+        noteId: string,
+        submissionId: string,
+        requestBody?: PatchedPlatformApplicationNote,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/notes/{note_id}/',
+            path: {
+                'note_id': noteId,
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Edit or remove a single internal reviewer note.
+     * @returns void
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageNotesDestroy({
+        noteId,
+        submissionId,
+    }: {
+        noteId: string,
+        submissionId: string,
+    }): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/notes/{note_id}/',
+            path: {
+                'note_id': noteId,
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Placements for a submission (#2133): list, and assign a new placement
+     * linking an accepted candidate to the placement mentor.
+     * @returns any Placements for the submission
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManagePlacementsRetrieve({
+        submissionId,
+    }: {
+        submissionId: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/placements/',
+            path: {
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * Placements for a submission (#2133): list, and assign a new placement
+     * linking an accepted candidate to the placement mentor.
+     * @returns any Per-item placement results
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManagePlacementsCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody: PlatformApplicationPlacementCreate,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/placements/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Advance a single placement: status, the agent's result, admin override.
+     * @returns any Placement updated
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManagePlacementsPartialUpdate({
+        placementId,
+        submissionId,
+        requestBody,
+    }: {
+        placementId: string,
+        submissionId: string,
+        requestBody?: PatchedPlatformApplicationPlacementUpdate,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/placements/{placement_id}/',
+            path: {
+                'placement_id': placementId,
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Admin submit-with-exceptions (§2.1 "administratively waived"): push a
+     * family's editable application to Submitted, recording a waiver for every
+     * required item still missing and bypassing an unpaid fee gate (the charge
+     * stays payable/waivable). Present-but-invalid answers still block (400).
+     * @returns any Application submitted
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageSubmitCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody?: PlatformApplicationAdminSubmit,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/submit/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Advance a submission or a single candidate through the review pipeline
+     * (#2089, §5-6). A ``candidate_id`` scopes the action to one person; without
+     * it the action applies to every candidate that can legally accept it. When
+     * ``action`` is ``decline`` and ``block`` is set, the applicant is also added
+     * to the platform ban-list (deny-with-block).
+     * @returns any Updated submission detail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageTransitionCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody: PlatformApplicationTransition,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/transition/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Waive a required item on one application (§2.1 "administratively
+     * waived"): POST excuses a missing required field so it no longer blocks
+     * submission; DELETE reinstates it. Waivers excuse absence only — a
+     * present-but-invalid answer still blocks. The fee is waived through its own
+     * fee endpoint action, which also settles the money record.
+     * @returns any Waiver recorded
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageWaiversCreate({
+        submissionId,
+        requestBody,
+    }: {
+        submissionId: string,
+        requestBody: PlatformApplicationWaiver,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/waivers/',
+            path: {
+                'submission_id': submissionId,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Waive a required item on one application (§2.1 "administratively
+     * waived"): POST excuses a missing required field so it no longer blocks
+     * submission; DELETE reinstates it. Waivers excuse absence only — a
+     * present-but-invalid answer still blocks. The fee is waived through its own
+     * fee endpoint action, which also settles the money record.
+     * @returns void
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageWaiversDestroy({
+        submissionId,
+    }: {
+        submissionId: string,
+    }): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/catalog/applications/platform/manage/{submission_id}/waivers/',
+            path: {
+                'submission_id': submissionId,
+            },
+        });
+    }
+    /**
+     * List the active application blocks (ban-list) for a platform.
+     * @returns any Active blocks
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageBlocksRetrieve({
+        platformKey,
+        platformOrg,
+        search,
+        sort,
+        status,
+    }: {
+        platformKey?: string,
+        platformOrg?: string,
+        search?: string,
+        sort?: string,
+        status?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/blocks/',
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'search': search,
+                'sort': sort,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Lift a single active application block (unblock).
+     * @returns void
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageBlocksDestroy({
+        blockId,
+        platformKey,
+        platformOrg,
+        search,
+        sort,
+        status,
+    }: {
+        blockId: string,
+        platformKey?: string,
+        platformOrg?: string,
+        search?: string,
+        sort?: string,
+        status?: string,
+    }): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/catalog/applications/platform/manage/blocks/{block_id}/',
+            path: {
+                'block_id': blockId,
+            },
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'search': search,
+                'sort': sort,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Wires RBAC into a DRF view.
+     *
+     * Two responsibilities:
+     *
+     * 1. When RBAC is enabled, replace the view's `permission_classes` with
+     * `RbacAuthGate` (the gate the RBAC layer assumes — `IsEdxAuthenticated`
+     * semantics, plus opt-in acceptance of token-policies PlatformApiKeys for
+     * views that set `token_policies_enabled = True`).
+     *
+     * 2. Detect server-to-server (Django auth) callers via `is_service_account`.
+     * Server-to-server tokens authenticate as Django auth users with no
+     * relationship to a platform EdxUser. The convention is "we trust this
+     * caller — bypass RBAC and serve the request."
+     *
+     * Combine it with the RBAC-disabled check at the top of `initial()` so
+     * the early exit skips all RBAC prep work:
+     *
+     * if not ConfigFlags.rbac_enabled() or self.is_service_account:
+     * return
+     *
+     * Use `is_service_account` at any other touch points where caller
+     * identity matters (queryset ownership filters, owner attribution on
+     * create, serializer context, etc.).
+     * @returns any Per-status counts
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformManageStatsRetrieve({
+        platformKey,
+        platformOrg,
+        search,
+        sort,
+        status,
+    }: {
+        platformKey?: string,
+        platformOrg?: string,
+        search?: string,
+        sort?: string,
+        status?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/manage/stats/',
+            query: {
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'search': search,
+                'sort': sort,
+                'status': status,
+            },
+        });
+    }
+    /**
+     * Start an annual re-enrollment (#2135): a normal draft create whose
+     * responses are pre-filled from the caller's most recent approved submission
+     * (current-schema fields only; signatures, consents, files, and fields the
+     * form flags fresh are re-asked), linked to that prior submission. With no
+     * prior approved submission this behaves as a plain create.
+     * @returns PlatformApplicationDetail
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformRenewCreate({
+        requestBody,
+    }: {
+        requestBody: PlatformApplicationCreate,
+    }): CancelablePromise<PlatformApplicationDetail> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/catalog/applications/platform/renew/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Authenticated applicants, including learners on AXD student tokens.
+     *
+     * Prepends StudentTokenAuthentication like core UserPlatformSelfLinkView (it is
+     * not in the DRF defaults, but learners self-applying use it). An anonymous
+     * request returns 401, not 403: DRF's ``permission_denied`` raises
+     * ``NotAuthenticated`` whenever no authenticator succeeded.
+     * @returns any Gate state
+     * @throws ApiError
+     */
+    public static catalogApplicationsPlatformStatusRetrieve({
+        formId,
+        platformKey,
+        platformOrg,
+    }: {
+        formId?: number,
+        platformKey?: string,
+        platformOrg?: string,
+    }): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/catalog/applications/platform/status/',
+            query: {
+                'form_id': formId,
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+            },
+        });
+    }
     /**
      * GET
      * Retrieve prerequisite eligibility info for user/course