@iblai/iblai-api 0.0.1-core

package/src/services/CoreService.ts

@@ -0,0 +1,1278 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CeleryHeartbeat } from '../models/CeleryHeartbeat';
+import type { EdxSignalReceiverRequest } from '../models/EdxSignalReceiverRequest';
+import type { ImageUpload } from '../models/ImageUpload';
+import type { LauncherViewPostRequest } from '../models/LauncherViewPostRequest';
+import type { LtiKey } from '../models/LtiKey';
+import type { LtiTool } from '../models/LtiTool';
+import type { PatchedPlatformPublicMetadata } from '../models/PatchedPlatformPublicMetadata';
+import type { PlatformApiKey } from '../models/PlatformApiKey';
+import type { PlatformList } from '../models/PlatformList';
+import type { PlatformPublicMetadata } from '../models/PlatformPublicMetadata';
+import type { PlatformUpdatePostRequest } from '../models/PlatformUpdatePostRequest';
+import type { RedirectTokenRequest } from '../models/RedirectTokenRequest';
+import type { RedirectTokenResponse } from '../models/RedirectTokenResponse';
+import type { TokenProxyInput } from '../models/TokenProxyInput';
+import type { TokenProxyOutput } from '../models/TokenProxyOutput';
+import type { UserDeleteAPIRequest } from '../models/UserDeleteAPIRequest';
+import type { UserDeleteAPIResponse } from '../models/UserDeleteAPIResponse';
+import type { UserPlatformLink } from '../models/UserPlatformLink';
+import type { UserPlatformManagementListViewGetResponse } from '../models/UserPlatformManagementListViewGetResponse';
+import type { UserPlatformViewPostRequest } from '../models/UserPlatformViewPostRequest';
+import type { UserProxyBulkRequest } from '../models/UserProxyBulkRequest';
+import type { UserProxyGetResponse } from '../models/UserProxyGetResponse';
+import type { UserProxyPostRequest } from '../models/UserProxyPostRequest';
+import type { UserProxyPostResponse } from '../models/UserProxyPostResponse';
+import type { UserSearchViewGetResponse } from '../models/UserSearchViewGetResponse';
+import type { WhitelistedDomain } from '../models/WhitelistedDomain';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class CoreService {
+    /**
+     * Create DM and AXD Tokens for user and platform_key
+     *
+     * Params:
+     * - Any of user_id, username, or email (choose one only, required)
+     * - platform_key: str (required)
+     * @param requestBody
+     * @returns TokenProxyOutput
+     * @throws ApiError
+     */
+    public static coreConsolidatedTokenProxyCreate(
+        requestBody: TokenProxyInput,
+    ): CancelablePromise<TokenProxyOutput> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/consolidated-token/proxy/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Show (active) departments associated with a platform
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDepartmentsRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/departments/',
+        });
+    }
+    /**
+     * Create/update a department
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDepartmentsCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/departments/',
+        });
+    }
+    /**
+     * Delete department
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreDepartmentsDestroy(): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/departments/',
+        });
+    }
+    /**
+     * Show active users in department (paginated)
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDepartmentsMembersRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/departments/members/',
+        });
+    }
+    /**
+     * Add single user to department, or update status
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDepartmentsMembersCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/departments/members/',
+        });
+    }
+    /**
+     * Delete department member
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreDepartmentsMembersDestroy(): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/departments/members/',
+        });
+    }
+    /**
+     * Add users to department, or update status
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDepartmentsMembersBulkCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/departments/members/bulk/',
+        });
+    }
+    /**
+     * Get department member admin info of requesting user
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDepartmentsMembersCheckRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/departments/members/check/',
+        });
+    }
+    /**
+     * Check if a domain is whitelisted
+     * @param url
+     * @param isActive
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreDomainsWhitelistRetrieve(
+        url: string,
+        isActive?: boolean,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/domains/whitelist/',
+            query: {
+                'is_active': isActive,
+                'url': url,
+            },
+        });
+    }
+    /**
+     * Add a new domain to whitelist
+     * @param requestBody
+     * @returns WhitelistedDomain
+     * @throws ApiError
+     */
+    public static coreDomainsWhitelistCreate(
+        requestBody: WhitelistedDomain,
+    ): CancelablePromise<WhitelistedDomain> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/domains/whitelist/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * **Use Case**
+     *
+     * Celery heartbeat endpoint.
+     *
+     * **Example Request**
+     *
+     * GET /api/core/heartbeat/celery/
+     *
+     * **Response Values**
+     *
+     * * 200 on success.
+     * * 500 on failure.
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreHeartbeatCeleryRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/heartbeat/celery/',
+        });
+    }
+    /**
+     * **Use Case**
+     *
+     * Celery Beat heartbeat endpoint.
+     *
+     * **Example Request**
+     *
+     * GET /api/core/heartbeat/celery-beat/
+     *
+     * **Response Values**
+     *
+     * * 200 on success.
+     * * 500 on failure.
+     * @returns CeleryHeartbeat
+     * @throws ApiError
+     */
+    public static coreHeartbeatCeleryBeatRetrieve(): CancelablePromise<CeleryHeartbeat> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/heartbeat/celery-beat/',
+        });
+    }
+    /**
+     * GET Launch status
+     *
+     * Params:
+     * key
+     * user_id: Optional
+     * @param key
+     * @param userId
+     * @returns PlatformList
+     * @throws ApiError
+     */
+    public static coreLauncherRetrieve(
+        key: string,
+        userId?: number,
+    ): CancelablePromise<PlatformList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/launcher/',
+            query: {
+                'key': key,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * POST: Launch a new edX platform
+     *
+     * Params:
+     * user_id: The ID of the requesting user (required)
+     * key: The Deep LMS subdomain (required)
+     * name: The edX platform name ("optional")
+     * org: The edX organization ("optional")
+     * lms_url: LMS URL ("optional")
+     * cms_url: CMS URL ("optional")
+     * portal_url: Portal URL ("optional")
+     * @param requestBody
+     * @returns PlatformList
+     * @throws ApiError
+     */
+    public static coreLauncherCreate(
+        requestBody: LauncherViewPostRequest,
+    ): CancelablePromise<PlatformList> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/launcher/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * List your LTI Provider Key's
+     * @param platformKey Platform Key
+     * @returns LtiKey
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiKeysList(
+        platformKey: string,
+    ): CancelablePromise<Array<LtiKey>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/lti/1p3/provider/lti-keys/',
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Create a new LTI Provider Key
+     * @param requestBody
+     * @returns LtiKey
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiKeysCreate(
+        requestBody: LtiKey,
+    ): CancelablePromise<LtiKey> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/lti/1p3/provider/lti-keys/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get details about a specific LTI Provider Key
+     * @param id
+     * @param platformKey Platform Key
+     * @returns LtiKey
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiKeysRetrieve(
+        id: string,
+        platformKey: string,
+    ): CancelablePromise<LtiKey> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/lti/1p3/provider/lti-keys/{id}/',
+            path: {
+                'id': id,
+            },
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Update an LTI Provider Key
+     * @param id
+     * @param requestBody
+     * @returns LtiKey
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiKeysUpdate(
+        id: string,
+        requestBody: LtiKey,
+    ): CancelablePromise<LtiKey> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/core/lti/1p3/provider/lti-keys/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete an LTI Provider Key
+     *
+     * **DANGER:** Deleting a key will also delete all Tools that reference that Key. If you need to delete a Key you should first create a new one and update all Tools to reference the new Key before deleting the old one.
+     * @param id
+     * @param platformKey Platform Key
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiKeysDestroy(
+        id: string,
+        platformKey: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/lti/1p3/provider/lti-keys/{id}/',
+            path: {
+                'id': id,
+            },
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * List your LTI Tool's
+     * @param platformKey Platform Key
+     * @returns LtiTool
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiToolsList(
+        platformKey: string,
+    ): CancelablePromise<Array<LtiTool>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/lti/1p3/provider/lti-tools/',
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Create a new LTI Tool
+     * @param requestBody
+     * @returns LtiTool
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiToolsCreate(
+        requestBody: LtiTool,
+    ): CancelablePromise<LtiTool> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/lti/1p3/provider/lti-tools/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get details about a specific LTI Tool
+     * @param id
+     * @param platformKey Platform Key
+     * @returns LtiTool
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiToolsRetrieve(
+        id: string,
+        platformKey: string,
+    ): CancelablePromise<LtiTool> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/lti/1p3/provider/lti-tools/{id}/',
+            path: {
+                'id': id,
+            },
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Update an LTI Tool
+     * @param id
+     * @param requestBody
+     * @returns LtiTool
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiToolsUpdate(
+        id: string,
+        requestBody: LtiTool,
+    ): CancelablePromise<LtiTool> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/core/lti/1p3/provider/lti-tools/{id}/',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete an LTI Tool
+     * @param id
+     * @param platformKey Platform Key
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreLti1P3ProviderLtiToolsDestroy(
+        id: string,
+        platformKey: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/lti/1p3/provider/lti-tools/{id}/',
+            path: {
+                'id': id,
+            },
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Get platform logo
+     * @param org
+     * @returns any
+     * @throws ApiError
+     */
+    public static coreOrgsDarkModeLogoRetrieve(
+        org: string,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/orgs/{org}/dark-mode-logo/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * Upload a new platform logo
+     * @param org
+     * @param requestBody
+     * @returns ImageUpload
+     * @throws ApiError
+     */
+    public static coreOrgsDarkModeLogoCreateCreate(
+        org: string,
+        requestBody: ImageUpload,
+    ): CancelablePromise<ImageUpload> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/orgs/{org}/dark-mode-logo/create/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get platform logo
+     * @param org
+     * @returns any
+     * @throws ApiError
+     */
+    public static coreOrgsFaviconRetrieve(
+        org: string,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/orgs/{org}/favicon/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * Upload a new platform logo
+     * @param org
+     * @param requestBody
+     * @returns ImageUpload
+     * @throws ApiError
+     */
+    public static coreOrgsFaviconCreateCreate(
+        org: string,
+        requestBody: ImageUpload,
+    ): CancelablePromise<ImageUpload> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/orgs/{org}/favicon/create/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get platform logo
+     * @param org
+     * @returns any
+     * @throws ApiError
+     */
+    public static coreOrgsLogoRetrieve(
+        org: string,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/orgs/{org}/logo/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * Upload a new platform logo
+     * @param org
+     * @param requestBody
+     * @returns ImageUpload
+     * @throws ApiError
+     */
+    public static coreOrgsLogoCreateCreate(
+        org: string,
+        requestBody: ImageUpload,
+    ): CancelablePromise<ImageUpload> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/orgs/{org}/logo/create/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param org
+     * @returns PlatformPublicMetadata
+     * @throws ApiError
+     */
+    public static coreOrgsMetadataRetrieve(
+        org: string,
+    ): CancelablePromise<PlatformPublicMetadata> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/orgs/{org}/metadata/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * @param org
+     * @param requestBody
+     * @returns PlatformPublicMetadata
+     * @throws ApiError
+     */
+    public static coreOrgsMetadataUpdate(
+        org: string,
+        requestBody?: PlatformPublicMetadata,
+    ): CancelablePromise<PlatformPublicMetadata> {
+        return __request(OpenAPI, {
+            method: 'PUT',
+            url: '/api/core/orgs/{org}/metadata/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param org
+     * @param requestBody
+     * @returns PlatformPublicMetadata
+     * @throws ApiError
+     */
+    public static coreOrgsMetadataPartialUpdate(
+        org: string,
+        requestBody?: PatchedPlatformPublicMetadata,
+    ): CancelablePromise<PlatformPublicMetadata> {
+        return __request(OpenAPI, {
+            method: 'PATCH',
+            url: '/api/core/orgs/{org}/metadata/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Creates redirect tokens for a URL specified by for a platform
+     * @param org
+     * @param requestBody
+     * @returns RedirectTokenResponse
+     * @throws ApiError
+     */
+    public static coreOrgsRedirectTokensCreate(
+        org: string,
+        requestBody: RedirectTokenRequest,
+    ): CancelablePromise<RedirectTokenResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/orgs/{org}/redirect-tokens/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Returns Redirect URL for the token specified.
+     *
+     * ```
+     * Requires user to be a member of the platform with the token passed
+     * ```
+     * @param org
+     * @param redirectToken
+     * @returns RedirectTokenResponse
+     * @throws ApiError
+     */
+    public static coreOrgsRedirectTokensRetrieve(
+        org: string,
+        redirectToken: string,
+    ): CancelablePromise<RedirectTokenResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/orgs/{org}/redirect-tokens/{redirect_token}/',
+            path: {
+                'org': org,
+                'redirect_token': redirectToken,
+            },
+        });
+    }
+    /**
+     * Delete specific token
+     * @param org
+     * @param redirectToken
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreOrgsRedirectTokensDeleteDestroy(
+        org: string,
+        redirectToken: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/orgs/{org}/redirect-tokens/{redirect_token}/delete',
+            path: {
+                'org': org,
+                'redirect_token': redirectToken,
+            },
+        });
+    }
+    /**
+     * Get platform logo
+     * @param org
+     * @returns any
+     * @throws ApiError
+     */
+    public static coreOrgsThumbnailRetrieve(
+        org: string,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/orgs/{org}/thumbnail/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * Upload a new platform logo
+     * @param org
+     * @param requestBody
+     * @returns ImageUpload
+     * @throws ApiError
+     */
+    public static coreOrgsThumbnailCreateCreate(
+        org: string,
+        requestBody: ImageUpload,
+    ): CancelablePromise<ImageUpload> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/orgs/{org}/thumbnail/create/',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * GET /api/core/platform/
+     * Get main platform info.
+     *
+     * POST /api/core/platform/
+     * Save main platform settings.
+     *
+     * Params:
+     * user_id (optional)
+     * key
+     * field_key (POST)
+     * value (POST)
+     * @param key
+     * @param userId
+     * @returns PlatformList
+     * @throws ApiError
+     */
+    public static corePlatformRetrieve(
+        key: string,
+        userId?: number,
+    ): CancelablePromise<PlatformList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/platform/',
+            query: {
+                'key': key,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * Update platform object
+     *
+     * Params:
+     * user_id
+     *
+     * key
+     * new_key (If changing platform key)
+     * name
+     *
+     * Advanced Params (Don't expose these to users)
+     * lms_url
+     * cms_url
+     * portal_url
+     * @param requestBody
+     * @returns PlatformList
+     * @throws ApiError
+     */
+    public static corePlatformCreate(
+        requestBody: PlatformUpdatePostRequest,
+    ): CancelablePromise<PlatformList> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/platform/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * List Platform API Key's belonging to the target platform
+     * @param platformKey Platform key of target platform
+     * @returns PlatformApiKey
+     * @throws ApiError
+     */
+    public static corePlatformApiTokensList(
+        platformKey: string,
+    ): CancelablePromise<Array<PlatformApiKey>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/platform/api-tokens/',
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * Create a new Platform Api Key for the target platform
+     * @param requestBody
+     * @returns PlatformApiKey
+     * @throws ApiError
+     */
+    public static corePlatformApiTokensCreate(
+        requestBody: PlatformApiKey,
+    ): CancelablePromise<PlatformApiKey> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/platform/api-tokens/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Delete Platform Api Key by name in the target platform
+     * @param name
+     * @param platformKey Platform key of target platform
+     * @returns void
+     * @throws ApiError
+     */
+    public static corePlatformApiTokensDestroy(
+        name: string,
+        platformKey: string,
+    ): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/platform/api-tokens/{name}',
+            path: {
+                'name': name,
+            },
+            query: {
+                'platform_key': platformKey,
+            },
+        });
+    }
+    /**
+     * GET /site
+     * Get site settings.
+     *
+     * POST /site
+     * Save site settings.
+     *
+     * Params:
+     * user_id
+     * key
+     * field_key (POST)
+     * value (POST)
+     * @param key
+     * @param userId
+     * @returns any
+     * @throws ApiError
+     */
+    public static corePlatformConfigSiteRetrieve(
+        key: string,
+        userId?: number,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/platform/config/site/',
+            query: {
+                'key': key,
+                'user_id': userId,
+            },
+        });
+    }
+    /**
+     * GET /site
+     * Get site settings.
+     *
+     * POST /site
+     * Save site settings.
+     *
+     * Params:
+     * user_id
+     * key
+     * field_key (POST)
+     * value (POST)
+     * @param requestBody
+     * @returns any
+     * @throws ApiError
+     */
+    public static corePlatformConfigSiteCreate(
+        requestBody?: Record<string, any>,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/platform/config/site/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Retrieve users associated with platform
+     *
+     * Params:
+     * platform_key
+     * platform_org
+     *
+     * query
+     * sort
+     *
+     * is_admin: Return tenant admin users
+     * @param page
+     * @param pageSize
+     * @param platformKey
+     * @param platformOrg
+     * @param query
+     * @param sort
+     * @returns UserPlatformManagementListViewGetResponse
+     * @throws ApiError
+     */
+    public static corePlatformUsersRetrieve(
+        page?: number,
+        pageSize?: number,
+        platformKey?: string,
+        platformOrg?: string,
+        query?: string,
+        sort?: string,
+    ): CancelablePromise<UserPlatformManagementListViewGetResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/platform/users/',
+            query: {
+                'page': page,
+                'page_size': pageSize,
+                'platform_key': platformKey,
+                'platform_org': platformOrg,
+                'query': query,
+                'sort': sort,
+            },
+        });
+    }
+    /**
+     * Invalidate all tokens for the authenticated user
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreSessionLogoutCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/session/logout/',
+        });
+    }
+    /**
+     * POST signals/edx/
+     * @param requestBody
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreSignalsEdxCreate(
+        requestBody: EdxSignalReceiverRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/signals/edx/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Param:
+     * Any of user_id/username/email
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreTokenProxyCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/token/proxy/',
+        });
+    }
+    /**
+     * Check token user
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreTokenVerifyRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/token/verify/',
+        });
+    }
+    /**
+     * Show (active) user groups associated with a platform
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUserGroupsRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/user_groups/',
+        });
+    }
+    /**
+     * Create/update a user group
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUserGroupsCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/user_groups/',
+        });
+    }
+    /**
+     * Delete user group
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreUserGroupsDestroy(): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/user_groups/',
+        });
+    }
+    /**
+     * Show active users in user group (paginated)
+     *
+     * group_id is numeric ID of group
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUserGroupsLinkRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/user_groups/link/',
+        });
+    }
+    /**
+     * Add single user to user group, or update status
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUserGroupsLinkCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/user_groups/link/',
+        });
+    }
+    /**
+     * Delete user group link
+     * @returns void
+     * @throws ApiError
+     */
+    public static coreUserGroupsLinkDestroy(): CancelablePromise<void> {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/api/core/user_groups/link/',
+        });
+    }
+    /**
+     * Add users to user group, or update status
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUserGroupsLinkBulkCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/user_groups/link/bulk/',
+        });
+    }
+    /**
+     * Initiates the account deletion process for the authenticated user or specified username.
+     * @param requestBody
+     * @returns UserDeleteAPIResponse
+     * @throws ApiError
+     */
+    public static coreUsersDeleteCreate(
+        requestBody?: UserDeleteAPIRequest,
+    ): CancelablePromise<UserDeleteAPIResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/users/delete/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Get detailed user information.
+     *
+     * Make permission check for platform admins here,
+     * then proxy request to edx.
+     * @param email
+     * @param userId
+     * @param username
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUsersMetadataProxyRetrieve(
+        email?: string,
+        userId?: number,
+        username?: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/users/metadata/proxy/',
+            query: {
+                'email': email,
+                'user_id': userId,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * Retrieve platforms associated with user_id
+     *
+     * Params:
+     * user_id
+     * username
+     * email
+     * @param email
+     * @param userId
+     * @param username
+     * @returns UserPlatformLink
+     * @throws ApiError
+     */
+    public static coreUsersPlatformsList(
+        email?: string,
+        userId?: number,
+        username?: string,
+    ): CancelablePromise<Array<UserPlatformLink>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/users/platforms/',
+            query: {
+                'email': email,
+                'user_id': userId,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * Explicitly link platform to user_id
+     *
+     * Params:
+     * user_id
+     * platform_key
+     * added_on (optional)
+     * expired_on (optional)
+     * is_admin (optional)
+     * active (optional)
+     * @param requestBody
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static coreUsersPlatformsCreate(
+        requestBody: UserPlatformViewPostRequest,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/users/platforms/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Retrieve proxy user information by user_id
+     * @param email
+     * @param userId
+     * @param username
+     * @returns UserProxyGetResponse
+     * @throws ApiError
+     */
+    public static coreUsersProxyRetrieve(
+        email?: string,
+        userId?: number,
+        username?: string,
+    ): CancelablePromise<UserProxyGetResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/core/users/proxy/',
+            query: {
+                'email': email,
+                'user_id': userId,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * Add proxy user
+     *
+     * Params:
+     * user_id
+     * username
+     * email
+     * edx_data
+     * data
+     * @param requestBody
+     * @returns UserProxyPostResponse
+     * @throws ApiError
+     */
+    public static coreUsersProxyCreate(
+        requestBody: UserProxyPostRequest,
+    ): CancelablePromise<UserProxyPostResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/core/users/proxy/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Add proxy users by bulk
+     *
+     * Params:
+     * users: list of user objects
+     * ```
+     * [
+         * {"user_id": 1, ...},
+         * {"user_id": 2, ...}
+         * ]
+         * ```
+         * @param requestBody
+         * @returns string
+         * @throws ApiError
+         */
+        public static coreUsersProxyBulkCreate(
+            requestBody: UserProxyBulkRequest,
+        ): CancelablePromise<Array<Record<string, string>>> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/core/users/proxy/bulk/',
+                body: requestBody,
+                mediaType: 'application/json',
+            });
+        }
+        /**
+         * Retrieve users based on query
+         * Not intended for public use with multitenant platforms
+         *
+         * Params:
+         * query
+         * sort
+         * @param page
+         * @param pageSize
+         * @param query
+         * @param sort
+         * @returns UserSearchViewGetResponse
+         * @throws ApiError
+         */
+        public static coreUsersSearchRetrieve(
+            page?: number,
+            pageSize?: number,
+            query?: string,
+            sort?: string,
+        ): CancelablePromise<UserSearchViewGetResponse> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/core/users/search/',
+                query: {
+                    'page': page,
+                    'page_size': pageSize,
+                    'query': query,
+                    'sort': sort,
+                },
+            });
+        }
+    }