@iblai/iblai-api 0.0.1-core

package/src/services/ProviderAssociationService.ts

@@ -0,0 +1,32 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ProviderAssociationService {
+    /**
+     * Handle callbacks from Stripe after successful checkout.
+     *
+     * Updates:
+     * - Platform launch state
+     * - Association configuration status
+     * @param launchId
+     * @returns any
+     * @throws ApiError
+     */
+    public static providerAssociationStripeCallbackRetrieve(
+        launchId: string,
+    ): CancelablePromise<{
+        message?: string;
+    }> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/provider-association/stripe/callback/{launch_id}/',
+            path: {
+                'launch_id': launchId,
+            },
+        });
+    }
+}

package/src/services/ProvidersService.ts

@@ -0,0 +1,271 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { AppleSubscriptionStatusRequest } from '../models/AppleSubscriptionStatusRequest';
+import type { AppleSubscriptionStatusView } from '../models/AppleSubscriptionStatusView';
+import type { AppleVerifyTransactionId } from '../models/AppleVerifyTransactionId';
+import type { AssociateAccountResponse } from '../models/AssociateAccountResponse';
+import type { AssociateAppleAccount } from '../models/AssociateAppleAccount';
+import type { AWSTenantLaunchRequest } from '../models/AWSTenantLaunchRequest';
+import type { BaseResponse } from '../models/BaseResponse';
+import type { GCPTenantLaunchRequest } from '../models/GCPTenantLaunchRequest';
+import type { GooglePayAccountResponse } from '../models/GooglePayAccountResponse';
+import type { GooglePayVerifyToken } from '../models/GooglePayVerifyToken';
+import type { TenantLaunchResponse } from '../models/TenantLaunchResponse';
+import type { VerifyGCPMarketPlaceRequest } from '../models/VerifyGCPMarketPlaceRequest';
+import type { VerifyGCPMarketPlaceResponse } from '../models/VerifyGCPMarketPlaceResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ProvidersService {
+    /**
+     * Associate an Apple account with a user known user
+     * @param requestBody
+     * @returns AssociateAccountResponse
+     * @throws ApiError
+     */
+    public static providersAppleAssociateAccountCreate(
+        requestBody: AssociateAppleAccount,
+    ): CancelablePromise<AssociateAccountResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/apple/associate-account/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * View to handle apple webhooks
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersAppleHookCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/apple/hook/',
+        });
+    }
+    /**
+     * Returns information about a user subscription status
+     * @param requestBody
+     * @returns AppleSubscriptionStatusView
+     * @throws ApiError
+     */
+    public static providersAppleSubscriptionStatusCreate(
+        requestBody?: AppleSubscriptionStatusRequest,
+    ): CancelablePromise<AppleSubscriptionStatusView> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/apple/subscription-status/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Checks if a provided transaction_id is valid
+     * @param requestBody
+     * @returns BaseResponse
+     * @throws ApiError
+     */
+    public static providersAppleValidateTransactionIdCreate(
+        requestBody: AppleVerifyTransactionId,
+    ): CancelablePromise<BaseResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/apple/validate-transaction-id/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Serves a view that redirects to the AWS marketplace create organization page
+     *
+     * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the
+     * URL of the AWS marketplace create organization page
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersAwsCreateOrganizationCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/aws/create-organization/',
+        });
+    }
+    /**
+     * API endpoint to get domain setup status
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersAwsDomainStatusRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/providers/aws/domain-status/',
+        });
+    }
+    /**
+     * Proxy to the Platform launch API
+     *
+     * We cannot expose launching a tenant to an authorized user hence the need for the API
+     *
+     * The API validates the x_amzn_marketplace_token and then proxies the request to the Platform Launch API
+     * @param requestBody
+     * @returns TenantLaunchResponse
+     * @throws ApiError
+     */
+    public static providersAwsLaunchTenantCreate(
+        requestBody: AWSTenantLaunchRequest,
+    ): CancelablePromise<TenantLaunchResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/aws/launch-tenant/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * API endpoint to get/update CNAME records for domain setup
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersAwsSyncDomainRecordsRetrieve(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/providers/aws/sync-domain-records/',
+        });
+    }
+    /**
+     * API endpoint to get/update CNAME records for domain setup
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersAwsSyncDomainRecordsCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/aws/sync-domain-records/',
+        });
+    }
+    /**
+     * Serves a view that redirects to the GCP marketplace create organization page
+     *
+     * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the URL of the GCP marketplace create organization
+     * page
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersGcpCreateOrganizationCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/gcp/create-organization/',
+        });
+    }
+    /**
+     * Serves a view that redirects to the GCP marketplace create organization page
+     *
+     * Set CREATE_ORGANIZATION_URL in GlobalConfigurationFetcher to the URL of the GCP marketplace create organization
+     * page
+     * @param productId
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersGcpCreateOrganizationCreate2(
+        productId: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/gcp/create-organization/{product_id}/',
+            path: {
+                'product_id': productId,
+            },
+        });
+    }
+    /**
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersGcpHookCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/gcp/hook/',
+        });
+    }
+    /**
+     * Proxy to the Platform launch API
+     *
+     * We cannot expose launching a tenant to an authorized user hence the need for the API
+     *
+     * The API validates the x_gcp_marketplace_token and then proxies the request to the Platform Launc API
+     * @param requestBody
+     * @returns TenantLaunchResponse
+     * @throws ApiError
+     */
+    public static providersGcpLaunchTenantCreate(
+        requestBody: GCPTenantLaunchRequest,
+    ): CancelablePromise<TenantLaunchResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/gcp/launch-tenant/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * @param requestBody
+     * @returns VerifyGCPMarketPlaceResponse
+     * @throws ApiError
+     */
+    public static providersGcpValidateSignupTokenCreate(
+        requestBody: VerifyGCPMarketPlaceRequest,
+    ): CancelablePromise<VerifyGCPMarketPlaceResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/gcp/validate-signup-token/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Google Allows us to pass an obfuscated account id to be sent to during a subscription purchase
+     * @param bundleId
+     * @returns GooglePayAccountResponse
+     * @throws ApiError
+     */
+    public static providersGooglePayGetAccountRetrieve(
+        bundleId: string,
+    ): CancelablePromise<GooglePayAccountResponse> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/providers/google-pay/get-account/{bundle_id}',
+            path: {
+                'bundle_id': bundleId,
+            },
+        });
+    }
+    /**
+     * View to handle Google Pay webhooks
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static providersGooglePayHookCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/google-pay/hook/',
+        });
+    }
+    /**
+     * Associate a Google Pay account with a known user
+     * @param requestBody
+     * @returns BaseResponse
+     * @throws ApiError
+     */
+    public static providersGooglePayValidateTransactionIdCreate(
+        requestBody: GooglePayVerifyToken,
+    ): CancelablePromise<BaseResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/providers/google-pay/validate-transaction-id/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}

package/src/services/ProvisionService.ts

@@ -0,0 +1,30 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ProvisionService {
+    /**
+     * POST
+     * Update platform provisioning config
+     *
+     * request body:
+     * {"config_name": "demo_config}
+     * @param configName
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static provisionCreate(
+        configName: string,
+    ): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/provision/{config_name}/',
+            path: {
+                'config_name': configName,
+            },
+        });
+    }
+}

package/src/services/RecommendationsService.ts

@@ -0,0 +1,31 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { RecommendationSearchAPI } from '../models/RecommendationSearchAPI';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class RecommendationsService {
+    /**
+     * API endpoint that returns a search api url prepopulated with context data
+     * See http://localhost:8000/api/schema/swagger-ui/#/recommendations
+     * @param org
+     * @param userId
+     * @returns RecommendationSearchAPI
+     * @throws ApiError
+     */
+    public static recommendationsOrgsUsersRetrieve(
+        org: string,
+        userId: string,
+    ): CancelablePromise<RecommendationSearchAPI> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/recommendations/orgs/{org}/users/{user_id}/',
+            path: {
+                'org': org,
+                'user_id': userId,
+            },
+        });
+    }
+}

package/src/services/ReportsService.ts

@@ -0,0 +1,218 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ReportCreate } from '../models/ReportCreate';
+import type { ReportDetail } from '../models/ReportDetail';
+import type { ReportList } from '../models/ReportList';
+import type { ReportRequest } from '../models/ReportRequest';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ReportsService {
+    /**
+     * Lists all available reports in the system.
+     *
+     * This endpoint returns a list of all reports available to the user, including:
+     * - Report metadata (name, description, icon)
+     * - Available query parameters for each report
+     * - Result columns that will be returned
+     * - Current status of any previously requested reports
+     *
+     * If a report has been previously requested by the user, its status will be included
+     * in the response. Expired reports are automatically cleaned up.
+     *
+     * Returns:
+     * A list of report objects with their metadata and status information.
+     * @param org
+     * @returns ReportList
+     * @throws ApiError
+     */
+    public static reportsOrgsRetrieve(
+        org: string,
+    ): CancelablePromise<ReportList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/orgs/{org}/',
+            path: {
+                'org': org,
+            },
+        });
+    }
+    /**
+     * Retrieves detailed information about a specific report type.
+     *
+     * This endpoint provides:
+     * - Metadata about the report (name, description, icon)
+     * - Available query parameters for the report
+     * - Result columns that will be returned
+     * - Current status of the most recent report of this type requested by the user
+     *
+     * Path Parameters:
+     * report_name (str): The identifier of the report to retrieve details for
+     *
+     * Returns:
+     * Detailed information about the report type and its current status if previously requested.
+     *
+     * Error Responses:
+     * 404 Not Found: If the specified report type doesn't exist
+     * @param org
+     * @param reportName
+     * @returns ReportDetail
+     * @throws ApiError
+     */
+    public static reportsOrgsRetrieve2(
+        org: string,
+        reportName: string,
+    ): CancelablePromise<ReportDetail> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/orgs/{org}/{report_name}',
+            path: {
+                'org': org,
+                'report_name': reportName,
+            },
+        });
+    }
+    /**
+     * Creates and manages report generation requests.
+     *
+     * This endpoint allows users to:
+     * 1. Request a new report generation
+     * 2. Check the status of a previously requested report
+     * 3. Force regeneration of an existing report
+     *
+     * Reports expire after a configured time period (default is typically 24-48 hours).
+     *
+     * Request Parameters:
+     * report_name (str): The identifier of the report to generate
+     * owner (str): The username of the report owner (usually the current user)
+     * learner_id (str, optional): Filter by specific learner
+     * course_id (str, optional): Filter by specific course
+     * start_date (str, optional): Start date for report data (ISO format)
+     * end_date (str, optional): End date for report data (ISO format)
+     * filters (dict, optional): Additional filters specific to the report type
+     * force (bool, optional): Force regeneration even if a valid report exists
+     *
+     * Returns:
+     * For new reports:
+     * - report_id: The unique identifier for the report task
+     * - state: The current state of the report (PENDING, RUNNING, etc.)
+     *
+     * For completed reports:
+     * - report_id: The unique identifier for the report task
+     * - report_name: The name of the report
+     * - url: Download URL for the report
+     * - state: COMPLETED
+     * - expires: Expiration timestamp for the report
+     *
+     * For in-progress reports:
+     * - report_id: The unique identifier for the report task
+     * - state: Current state (PENDING, RUNNING)
+     * - started_on: When the report generation started
+     * - owner: Username of the report owner
+     *
+     * Error Responses:
+     * 400 Bad Request: Invalid parameters or report configuration
+     * 404 Not Found: Report type not found
+     * 403 Forbidden: User doesn't have permission for the requested report
+     * @param org
+     * @param requestBody
+     * @returns ReportCreate
+     * @throws ApiError
+     */
+    public static reportsOrgsNewCreate(
+        org: string,
+        requestBody?: ReportRequest,
+    ): CancelablePromise<ReportCreate> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/reports/orgs/{org}/new',
+            path: {
+                'org': org,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * Returns a list of reports available in the system.
+     *
+     * For each report, it includes:
+     * - display_name: Human-readable name of the report
+     * - description: Description of what the report contains
+     * - icon: URL to an icon representing the report
+     * - report_name: Unique identifier for the report
+     * - extra_query_params: Additional parameters that can be passed when creating the report
+     * - result_columns: Columns that will be included in the report results
+     * - status: Current status of the report if it has been previously requested
+     *
+     * The status will include details like the report ID, state, and download URL if completed.
+     * @param key
+     * @returns ReportList
+     * @throws ApiError
+     */
+    public static reportsPlatformsRetrieve(
+        key: string,
+    ): CancelablePromise<ReportList> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/platforms/{key}/',
+            path: {
+                'key': key,
+            },
+        });
+    }
+    /**
+     * Returns details of a specific report type including its status if previously requested.
+     * @param key
+     * @param reportName
+     * @returns ReportDetail
+     * @throws ApiError
+     */
+    public static reportsPlatformsRetrieve2(
+        key: string,
+        reportName: string,
+    ): CancelablePromise<ReportDetail> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/reports/platforms/{key}/{report_name}',
+            path: {
+                'key': key,
+                'report_name': reportName,
+            },
+        });
+    }
+    /**
+     * Triggers a new report generation.
+     *
+     * If the report has been previously requested, it returns the status of the report.
+     * Reports expire after a configured duration.
+     *
+     * The request body should include:
+     * - report_name: Name of the report to generate
+     * - learner_id: (optional) ID of the learner to filter by
+     * - course_id: (optional) ID of the course to filter by
+     * - force: (optional) Force generation of a new report even if one exists
+     * - filters: (optional) Additional filters for the report
+     * - departments: (optional) Department IDs to filter by
+     * @param key
+     * @param requestBody
+     * @returns ReportCreate
+     * @throws ApiError
+     */
+    public static reportsPlatformsNewCreate(
+        key: string,
+        requestBody?: ReportRequest,
+    ): CancelablePromise<ReportCreate> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/reports/platforms/{key}/new',
+            path: {
+                'key': key,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}

package/src/services/RolesService.ts

@@ -0,0 +1,87 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { DesiredRole } from '../models/DesiredRole';
+import type { ReportedRole } from '../models/ReportedRole';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class RolesService {
+    /**
+     * Retrieve a user's desired role information.
+     *
+     * This endpoint returns the role and skills that a user has indicated
+     * they want to develop or acquire. This represents the user's career
+     * goals and learning objectives.
+     *
+     * Path Parameters:
+     * org (str): The platform/organization identifier
+     * username (str): The username of the user to retrieve role information for
+     *
+     * Returns:
+     * The user's desired role information including:
+     * - Target role title
+     * - Skills needed for the role
+     * - Current progress toward skill acquisition
+     *
+     * Error Responses:
+     * 400 Bad Request: If the user doesn't exist in the platform or has no desired role
+     * 404 Not Found: If the specified platform doesn't exist
+     * @param org
+     * @param username
+     * @returns DesiredRole
+     * @throws ApiError
+     */
+    public static rolesPlatformOrgsRolesUsersDesiredRolesRetrieve(
+        org: string,
+        username: string,
+    ): CancelablePromise<DesiredRole> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/roles/platform/orgs/{org}/roles/users/{username}/desired-roles/',
+            path: {
+                'org': org,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * Retrieve a user's reported role information.
+     *
+     * This endpoint returns the role and skills that a user has reported
+     * having in their profile. This represents the user's current skills
+     * and professional role.
+     *
+     * Path Parameters:
+     * org (str): The platform/organization identifier
+     * username (str): The username of the user to retrieve role information for
+     *
+     * Returns:
+     * The user's reported role information including:
+     * - Role title
+     * - Skills associated with the role
+     * - Experience level
+     *
+     * Error Responses:
+     * 400 Bad Request: If the user doesn't exist in the platform or has no reported role
+     * 404 Not Found: If the specified platform doesn't exist
+     * @param org
+     * @param username
+     * @returns ReportedRole
+     * @throws ApiError
+     */
+    public static rolesPlatformOrgsRolesUsersReportedRolesRetrieve(
+        org: string,
+        username: string,
+    ): CancelablePromise<ReportedRole> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/roles/platform/orgs/{org}/roles/users/{username}/reported-roles/',
+            path: {
+                'org': org,
+                'username': username,
+            },
+        });
+    }
+}