@iblai/iblai-api 1.0.0-add-mcp-server-test-mount-core

package/src/services/SearchService.ts

@@ -0,0 +1,332 @@
+/* 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 SearchService {
+    /**
+     * Search and filter content across the learning catalog
+     * @param allowSkillSearch Enable skill-based search
+     * @param alphabetical Sort alphabetically by name
+     * @param certificate Filter by certificate type
+     * @param content Content types to include in results
+     * @param courseId Filter by specific course ID
+     * @param duration Filter by course duration range
+     * @param language Filter by content language
+     * @param level Filter by difficulty level
+     * @param limit Number of results per page
+     * @param offset Starting position for pagination
+     * @param orderAscending Sort direction
+     * @param orderBy Field to sort results by
+     * @param pathwayId Filter by specific pathway ID
+     * @param price Filter by price/audit status
+     * @param programId Filter by specific program ID
+     * @param programType Filter by program type
+     * @param promotion Filter by promotion status
+     * @param query Search term to filter content by name or description
+     * @param resourceType Filter by resource type
+     * @param returnFacet Include facet data in response
+     * @param returnItems Include items in programs/pathways
+     * @param selfPaced Filter by course format
+     * @param skillId Filter by specific skill ID
+     * @param skills Filter by skills
+     * @param subject Filter by subject areas
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param topics Filter by topic areas
+     * @param updateFacet Force facet update
+     * @returns any
+     * @throws ApiError
+     */
+    public static searchCatalogRetrieve(
+        allowSkillSearch: boolean = false,
+        alphabetical: boolean = false,
+        certificate?: Array<string>,
+        content?: Array<string>,
+        courseId?: string,
+        duration?: Array<string>,
+        language?: Array<string>,
+        level?: Array<string>,
+        limit: number = 12,
+        offset?: number,
+        orderAscending: boolean = false,
+        orderBy?: string,
+        pathwayId?: string,
+        price?: string,
+        programId?: string,
+        programType?: Array<string>,
+        promotion?: Array<string>,
+        query?: string,
+        resourceType?: Array<string>,
+        returnFacet: boolean = true,
+        returnItems: boolean = false,
+        selfPaced?: Array<string>,
+        skillId?: string,
+        skills?: Array<string>,
+        subject?: Array<string>,
+        tags?: Array<string>,
+        tenant?: Array<string>,
+        topics?: Array<string>,
+        updateFacet?: string,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/search/catalog/',
+            query: {
+                'allow_skill_search': allowSkillSearch,
+                'alphabetical': alphabetical,
+                'certificate': certificate,
+                'content': content,
+                'course_id': courseId,
+                'duration': duration,
+                'language': language,
+                'level': level,
+                'limit': limit,
+                'offset': offset,
+                'order_ascending': orderAscending,
+                'order_by': orderBy,
+                'pathway_id': pathwayId,
+                'price': price,
+                'program_id': programId,
+                'program_type': programType,
+                'promotion': promotion,
+                'query': query,
+                'resource_type': resourceType,
+                'return_facet': returnFacet,
+                'return_items': returnItems,
+                'self_paced': selfPaced,
+                'skill_id': skillId,
+                'skills': skills,
+                'subject': subject,
+                'tags': tags,
+                'tenant': tenant,
+                'topics': topics,
+                'update_facet': updateFacet,
+            },
+        });
+    }
+    /**
+     * Get personalized content for a specific user
+     * @param username
+     * @param allowSkillSearch Enable skill-based search
+     * @param alphabetical Sort alphabetically by name
+     * @param certificate Filter by certificate type
+     * @param content Content types to include in results
+     * @param courseId Retrieve a specific course by ID
+     * @param duration Filter by course duration range
+     * @param language Filter by content language
+     * @param level Filter by difficulty level
+     * @param limit Number of results per page
+     * @param offset Starting position for pagination
+     * @param orderAscending Sort direction
+     * @param orderBy Field to sort results by
+     * @param pathwayId Retrieve a specific pathway by ID
+     * @param price Filter by price/audit status
+     * @param programId Retrieve a specific program by ID
+     * @param programType Filter by program type
+     * @param promotion Filter by promotion status
+     * @param query Search term to filter content by name or description
+     * @param recommended Show only recommended content
+     * @param resourceId Retrieve a specific resource by ID
+     * @param resourceType Filter by resource type
+     * @param returnFacet Include facet data in response
+     * @param returnItems Include items in programs/pathways
+     * @param roleId Retrieve a specific role by ID
+     * @param selfPaced Filter by course format
+     * @param skillId Retrieve a specific skill by ID
+     * @param skills Filter by skills
+     * @param subject Filter by subject areas
+     * @param tags Filter by tags
+     * @param tenant Filter by tenant/organization
+     * @param topics Filter by topic areas
+     * @param updateFacet Force facet update
+     * @returns any
+     * @throws ApiError
+     */
+    public static searchPersonalizedCatalogRetrieve(
+        username: string,
+        allowSkillSearch: boolean = false,
+        alphabetical: boolean = false,
+        certificate?: Array<string>,
+        content?: Array<string>,
+        courseId?: string,
+        duration?: Array<string>,
+        language?: Array<string>,
+        level?: Array<string>,
+        limit: number = 12,
+        offset?: number,
+        orderAscending: boolean = false,
+        orderBy?: string,
+        pathwayId?: string,
+        price?: string,
+        programId?: string,
+        programType?: Array<string>,
+        promotion?: Array<string>,
+        query?: string,
+        recommended: boolean = false,
+        resourceId?: string,
+        resourceType?: Array<string>,
+        returnFacet: boolean = true,
+        returnItems: boolean = false,
+        roleId?: string,
+        selfPaced?: Array<string>,
+        skillId?: string,
+        skills?: Array<string>,
+        subject?: Array<string>,
+        tags?: Array<string>,
+        tenant?: Array<string>,
+        topics?: Array<string>,
+        updateFacet?: string,
+    ): CancelablePromise<Record<string, any>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/search/personalized-catalog/{username}/',
+            path: {
+                'username': username,
+            },
+            query: {
+                'allow_skill_search': allowSkillSearch,
+                'alphabetical': alphabetical,
+                'certificate': certificate,
+                'content': content,
+                'course_id': courseId,
+                'duration': duration,
+                'language': language,
+                'level': level,
+                'limit': limit,
+                'offset': offset,
+                'order_ascending': orderAscending,
+                'order_by': orderBy,
+                'pathway_id': pathwayId,
+                'price': price,
+                'program_id': programId,
+                'program_type': programType,
+                'promotion': promotion,
+                'query': query,
+                'recommended': recommended,
+                'resource_id': resourceId,
+                'resource_type': resourceType,
+                'return_facet': returnFacet,
+                'return_items': returnItems,
+                'role_id': roleId,
+                'self_paced': selfPaced,
+                'skill_id': skillId,
+                'skills': skills,
+                'subject': subject,
+                'tags': tags,
+                'tenant': tenant,
+                'topics': topics,
+                'update_facet': updateFacet,
+            },
+        });
+    }
+    /**
+     * Search and filter users within a specific organization/tenant.
+     *
+     * This endpoint provides a search interface for discovering users within an organization,
+     * with support for filtering by departments, pagination, and faceted filtering.
+     *
+     * Path Parameters:
+     * org (str): The organization/tenant identifier
+     * username (str): The username of the user making the request
+     *
+     * Query Parameters:
+     * # Search parameters
+     * query (str, optional): Search term to filter users by name, username, or email
+     *
+     * # Department filtering
+     * department_mode (bool, optional): Enable department-based filtering (default: false)
+     * user_department (bool, optional): Legacy parameter for department_mode (default: false)
+     * department (list, optional): Filter by specific departments
+     *
+     * # Additional filters
+     * role (list, optional): Filter by user role
+     * status (list, optional): Filter by user status (active, inactive)
+     * joined_date (list, optional): Filter by join date range
+     * last_login (list, optional): Filter by last login date range
+     *
+     * # Pagination
+     * limit (int, optional): Number of results per page (default: 10)
+     * offset (int, optional): Starting position for pagination
+     *
+     * Returns:
+     * A JSON response containing:
+     * ```
+     * {
+         * "results": [
+             * {
+                 * "id": 123,
+                 * "username": "john.doe",
+                 * "email": "john.doe@example.com",
+                 * "first_name": "John",
+                 * "last_name": "Doe",
+                 * "full_name": "John Doe",
+                 * "profile_image": "https://example.com/profiles/john-doe.jpg",
+                 * "role": "Student",
+                 * "departments": ["Computer Science", "Data Science"],
+                 * "status": "active",
+                 * "joined_date": "2023-01-15T12:00:00Z",
+                 * "last_login": "2023-06-20T15:30:00Z",
+                 * "metadata": {
+                     * "location": "New York",
+                     * "title": "Software Engineer",
+                     * "bio": "Experienced software engineer with a passion for education"
+                     * }
+                     * },
+                     * // Additional user objects...
+                     * ],
+                     * "count": 50,
+                     * "next": "https://api.example.com/api/search/users/example-org/admin/?limit=10&offset=10",
+                     * "previous": null,
+                     * "current_page": 1,
+                     * "total_pages": 5,
+                     * "facets": {
+                         * "role": [
+                             * {"key": "Student", "doc_count": 30},
+                             * {"key": "Instructor", "doc_count": 15},
+                             * {"key": "Admin", "doc_count": 5}
+                             * ],
+                             * "department": [
+                                 * {"key": "Computer Science", "doc_count": 20},
+                                 * {"key": "Data Science", "doc_count": 15},
+                                 * {"key": "Business", "doc_count": 10},
+                                 * {"key": "Engineering", "doc_count": 5}
+                                 * ],
+                                 * "status": [
+                                     * {"key": "active", "doc_count": 45},
+                                     * {"key": "inactive", "doc_count": 5}
+                                     * ]
+                                     * }
+                                     * }
+                                     * ```
+                                     * Error Responses:
+                                     * 400 Bad Request: If the request parameters are invalid
+                                     * 403 Forbidden: If the user doesn't have department admin privileges (when using department_mode)
+                                     * 404 Not Found: If the user or organization doesn't exist
+                                     * 500 Internal Server Error: If an unexpected error occurs
+                                     *
+                                     * Access Control:
+                                     * - The requesting user must have an active account in the specified organization
+                                     * - When department_mode is enabled, the user must be an admin of at least one department
+                                     * - Department filtering restricts results to users in departments where the requesting user is an admin
+                                     * @param org
+                                     * @param username
+                                     * @returns any No response body
+                                     * @throws ApiError
+                                     */
+                                    public static searchUsersOrgsUsersRetrieve(
+                                        org: string,
+                                        username: string,
+                                    ): CancelablePromise<any> {
+                                        return __request(OpenAPI, {
+                                            method: 'GET',
+                                            url: '/api/search/users/orgs/{org}/users/{username}/',
+                                            path: {
+                                                'org': org,
+                                                'username': username,
+                                            },
+                                        });
+                                    }
+                                }

package/src/services/ServiceService.ts

@@ -0,0 +1,320 @@
+/* generated using openapi-typescript-codegen -- do not edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { StripeCheckoutSessionRequest } from '../models/StripeCheckoutSessionRequest';
+import type { StripeCheckoutSessionResponse } from '../models/StripeCheckoutSessionResponse';
+import type { StripeCustomerPortalRequest } from '../models/StripeCustomerPortalRequest';
+import type { StripeCustomerPortalResponse } from '../models/StripeCustomerPortalResponse';
+import type { StripeLocalProduct } from '../models/StripeLocalProduct';
+import type { StripeSubscriptionRenewalRequest } from '../models/StripeSubscriptionRenewalRequest';
+import type { StripeSubscriptionRenewalResponse } from '../models/StripeSubscriptionRenewalResponse';
+import type { TenantLaunchRequest } from '../models/TenantLaunchRequest';
+import type { TenantLaunchResponse } from '../models/TenantLaunchResponse';
+import type { CancelablePromise } from '../core/CancelablePromise';
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class ServiceService {
+    /**
+     * User/tenant creation API
+     *
+     * To create using any payment provider, ensure you use the StudentToken Authentication Mechanism
+     * and also include the correct `provider_key` in the request body:
+     *
+     * ```
+     * apple_transaction_id: str
+     * stripe_checkout_id: str
+     * x_gcp_marketplace_token: str
+     * aws_transaction_id: str
+     * google_pay_transaction_id: str
+     * ```
+     *
+     * To create a tenant without a payment provider, call the API without ny of the above provider keys in the request body
+     * @param requestBody
+     * @returns TenantLaunchResponse
+     * @throws ApiError
+     */
+    public static serviceLaunchTenantCreate(
+        requestBody: TenantLaunchRequest,
+    ): CancelablePromise<TenantLaunchResponse> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/service/launch/tenant/',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * User creation flow
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static serviceManageUserCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/service/manage/user/',
+        });
+    }
+    /**
+     * Make user tenant admin
+     * @returns any No response body
+     * @throws ApiError
+     */
+    public static serviceManageUserRoleCreate(): CancelablePromise<any> {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/api/service/manage/user/role/',
+        });
+    }
+    /**
+     * Stripe checkout session API View for user upgrade
+     *
+     * Request the following fields:
+     *
+     * - tenant
+     * - sku
+     * - mode
+     * - success_url
+     * - cancel_url
+     *
+     * Response:
+     * {
+         * "redirect_to": "https://checkout.stripe.com/xxx/xxxx/xxxx",
+         * }
+         * @param org
+         * @param userId
+         * @param requestBody
+         * @returns StripeCheckoutSessionResponse
+         * @throws ApiError
+         */
+        public static serviceOrgsUsersStripeCheckoutSessionCreate(
+            org: string,
+            userId: string,
+            requestBody: StripeCheckoutSessionRequest,
+        ): CancelablePromise<StripeCheckoutSessionResponse> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/service/orgs/{org}/users/{user_id}/stripe/checkout-session/',
+                path: {
+                    'org': org,
+                    'user_id': userId,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+            });
+        }
+        /**
+         * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+         * @param org
+         * @param userId
+         * @param requestBody
+         * @returns StripeCustomerPortalResponse
+         * @throws ApiError
+         */
+        public static serviceOrgsUsersStripeCustomerPortalCreate(
+            org: string,
+            userId: string,
+            requestBody: StripeCustomerPortalRequest,
+        ): CancelablePromise<StripeCustomerPortalResponse> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/service/orgs/{org}/users/{user_id}/stripe/customer-portal/',
+                path: {
+                    'org': org,
+                    'user_id': userId,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+            });
+        }
+        /**
+         * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+         * @param org
+         * @param userId
+         * @returns StripeLocalProduct
+         * @throws ApiError
+         */
+        public static serviceOrgsUsersStripeProductsRetrieve(
+            org: string,
+            userId: string,
+        ): CancelablePromise<StripeLocalProduct> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/service/orgs/{org}/users/{user_id}/stripe/products/',
+                path: {
+                    'org': org,
+                    'user_id': userId,
+                },
+            });
+        }
+        /**
+         * Mixin that includes the StudentTokenAuthentication and IsPlatformAdmin
+         * @param org
+         * @param userId
+         * @returns any No response body
+         * @throws ApiError
+         */
+        public static serviceOrgsUsersStripeProductsManageCreate(
+            org: string,
+            userId: string,
+        ): CancelablePromise<any> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/service/orgs/{org}/users/{user_id}/stripe/products/manage/',
+                path: {
+                    'org': org,
+                    'user_id': userId,
+                },
+            });
+        }
+        /**
+         * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+         * @param org
+         * @param userId
+         * @param requestBody
+         * @returns StripeSubscriptionRenewalResponse
+         * @throws ApiError
+         */
+        public static serviceOrgsUsersStripeSubscriptionRenewalCreate(
+            org: string,
+            userId: string,
+            requestBody: StripeSubscriptionRenewalRequest,
+        ): CancelablePromise<StripeSubscriptionRenewalResponse> {
+            return __request(OpenAPI, {
+                method: 'POST',
+                url: '/api/service/orgs/{org}/users/{user_id}/stripe/subscription-renewal/',
+                path: {
+                    'org': org,
+                    'user_id': userId,
+                },
+                body: requestBody,
+                mediaType: 'application/json',
+            });
+        }
+        /**
+         * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+         * @param org
+         * @param userId
+         * @returns any No response body
+         * @throws ApiError
+         */
+        public static serviceOrgsUsersStripeSubscriptionsRetrieve(
+            org: string,
+            userId: string,
+        ): CancelablePromise<any> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/service/orgs/{org}/users/{user_id}/stripe/subscriptions/',
+                path: {
+                    'org': org,
+                    'user_id': userId,
+                },
+            });
+        }
+        /**
+         * Handle course payment callback after successful Stripe checkout.
+         * Enrolls the user in the purchased course.
+         *
+         * URL Parameters:
+         * - stripe_checkout_id: The local Checkout Session UUID
+         *
+         * Response:
+         * - Redirect: Successfully processed course enrollment
+         * - 404: Checkout session not found
+         * - 400: Invalid checkout session or product
+         * - 500: Server error during processing
+         * @param platformKey
+         * @returns any No response body
+         * @throws ApiError
+         */
+        public static serviceOrgsStripeCoursePaymentCallbackRetrieve(
+            platformKey: string,
+        ): CancelablePromise<any> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/service/orgs/{platform_key}/stripe/course-payment-callback/',
+                path: {
+                    'platform_key': platformKey,
+                },
+            });
+        }
+        /**
+         * @param checkoutUuid
+         * @returns any No response body
+         * @throws ApiError
+         */
+        public static serviceStripeCheckoutRetrieve(
+            checkoutUuid: string,
+        ): CancelablePromise<any> {
+            return __request(OpenAPI, {
+                method: 'GET',
+                url: '/api/service/stripe/checkout/{checkout_uuid}/',
+                path: {
+                    'checkout_uuid': checkoutUuid,
+                },
+            });
+        }
+        /**
+         * Stripe free trial checkout session. No user auth
+         *
+         * Request the following fields:
+         *
+         * - success_url
+         * - cancel_url
+         * - product
+         *
+         * Response:
+         * {
+             * "redirect_to": "https://checkout.stripe.com/xxx/xxxx/xxxx",
+             * }
+             * @param requestBody
+             * @returns StripeCheckoutSessionResponse
+             * @throws ApiError
+             */
+            public static serviceStripeCheckoutFreeTrialCreate(
+                requestBody: StripeCheckoutSessionResponse,
+            ): CancelablePromise<StripeCheckoutSessionResponse> {
+                return __request(OpenAPI, {
+                    method: 'POST',
+                    url: '/api/service/stripe/checkout/free-trial/',
+                    body: requestBody,
+                    mediaType: 'application/json',
+                });
+            }
+            /**
+             * Check if tenant exists or not
+             * @returns any No response body
+             * @throws ApiError
+             */
+            public static serviceTenantValidationCreate(): CancelablePromise<any> {
+                return __request(OpenAPI, {
+                    method: 'POST',
+                    url: '/api/service/tenant/validation/',
+                });
+            }
+            /**
+             * GET
+             * Gets site hash_key from
+             * or
+             * Gets site_id form hash_key
+             * @returns any No response body
+             * @throws ApiError
+             */
+            public static serviceTokenRetrieve(): CancelablePromise<any> {
+                return __request(OpenAPI, {
+                    method: 'GET',
+                    url: '/api/service/token/',
+                });
+            }
+            /**
+             * Check if tenant exists or not
+             * @returns any No response body
+             * @throws ApiError
+             */
+            public static serviceUserValidationCreate(): CancelablePromise<any> {
+                return __request(OpenAPI, {
+                    method: 'POST',
+                    url: '/api/service/user/validation/',
+                });
+            }
+        }