@iblai/iblai-api 3.35.3-ai-plus → 3.35.4-core

package/dist/types/services/SearchService.d.ts

@@ -1,27 +1,5 @@
 import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class SearchService {
-    /**
-     * Legacy endpoint for backward compatible mentor search
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param filterFacet If present, return only facets without results
-     * @param id Retrieve a specific mentor by ID
-     * @param limit Number of results per page
-     * @param llm Filter by language model type
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param page Page number (1-based, used with page_size)
-     * @param pageSize Number of results per page
-     * @param query Search term to filter mentors by name or description
-     * @param tags Filter by tags
-     * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
-     * @returns any
-     * @throws ApiError
-     */
-    static searchAiSearchRetrieve(audience?: Array<string>, category?: Array<string>, createdBy?: string, filterFacet?: boolean, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, page?: number, pageSize?: number, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<Record<string, any>>;
     /**
      * Search and filter content across the learning catalog
      * @param allowSkillSearch Enable skill-based search
@@ -57,169 +35,6 @@ export declare class SearchService {
      * @throws ApiError
      */
     static searchCatalogRetrieve(allowSkillSearch?: boolean, alphabetical?: boolean, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, orderAscending?: boolean, orderBy?: string, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, promotion?: Array<string>, query?: string, resourceType?: Array<string>, returnFacet?: boolean, returnItems?: boolean, 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>>;
-    /**
-     * Get AI mentors based on search criteria
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param id Retrieve a specific mentor by ID
-     * @param limit Number of results per page
-     * @param llm Filter by language model type
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param query Search term to filter mentors by name or description
-     * @param tags Filter by tags
-     * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
-     * @returns any
-     * @throws ApiError
-     */
-    static searchMentorsRetrieve(audience?: Array<string>, category?: Array<string>, createdBy?: string, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<Record<string, any>>;
-    /**
-     * Search and filter documents associated with a specific mentor.
-     *
-     * This endpoint allows searching and filtering documents that are linked to a
-     * particular mentor, with support for pagination, sorting, and faceted filtering.
-     *
-     * Path Parameters:
-     * mentor_unique_id (uuid): The unique identifier of the mentor
-     *
-     * Query Parameters:
-     * query (str, optional): Search term to filter documents by name or content
-     * document_type (str, optional): Filter by document type (e.g., 'pdf', 'text')
-     * access (str, optional): Filter by access level (e.g., 'public', 'private')
-     * training_status (str, optional): Filter by training status (e.g., 'trained', 'pending')
-     * platform_key (str, optional): Filter by platform key
-     * order_by (str, optional): Field to sort results by ('date_created', 'last_modified', 'document_name')
-     * order_direction (str, optional): Sort direction ('asc' or 'desc', default: 'desc')
-     * limit (int, optional): Number of results per page (default: 12, max: 100)
-     * offset (int, optional): Starting position for pagination
-     *
-     * Returns:
-     * A JSON response containing:
-     * {
-         * "results": [
-             * {
-                 * "id": 789,
-                 * "document_name": "Introduction to Algorithms.pdf",
-                 * "document_type": "pdf",
-                 * "access": "public",
-                 * "training_status": "trained",
-                 * "date_created": "2023-03-15T10:30:00Z",
-                 * "last_modified": "2023-04-20T14:45:00Z",
-                 * "url": "https://example.com/documents/intro-algorithms.pdf",
-                 * "metadata": {
-                     * "page_count": 45,
-                     * "author": "John Smith",
-                     * "keywords": ["algorithms", "computer science", "data structures"],
-                     * "description": "Comprehensive introduction to fundamental algorithms"
-                     * }
-                     * },
-                     * // Additional document objects...
-                     * ],
-                     * "count": 25,
-                     * "next": "https://api.example.com/api/search/mentors/550e8400-e29b-41d4-a716-446655440000/documents/?limit=12&offset=12",
-                     * "previous": null,
-                     * "current_page": 1,
-                     * "total_pages": 3,
-                     * "facets": {
-                         * "document_type": [
-                             * {"key": "pdf", "doc_count": 15},
-                             * {"key": "text", "doc_count": 5},
-                             * {"key": "docx", "doc_count": 5}
-                             * ],
-                             * "access": [
-                                 * {"key": "public", "doc_count": 20},
-                                 * {"key": "private", "doc_count": 5}
-                                 * ],
-                                 * "training_status": [
-                                     * {"key": "trained", "doc_count": 18},
-                                     * {"key": "pending", "doc_count": 5},
-                                     * {"key": "failed", "doc_count": 2}
-                                     * ]
-                                     * }
-                                     * }
-                                     *
-                                     * Error Responses:
-                                     * 400 Bad Request: If the request parameters are invalid
-                                     * 404 Not Found: If the mentor doesn't exist
-                                     * 500 Internal Server Error: If an unexpected error occurs during processing
-                                     *
-                                     * Access Control:
-                                     * - Requires platform membership
-                                     * - Only documents associated with the specified mentor are returned
-                                     * - Access level filtering respects user permissions
-                                     * @param mentorUniqueId
-                                     * @returns any No response body
-                                     * @throws ApiError
-                                     */
-    static searchMentorsDocumentsRetrieve(mentorUniqueId: string): CancelablePromise<any>;
-    /**
-     * Get AI mentors for a specific tenant and user
-     * @param org
-     * @param username
-     * @param audience Filter by target audience
-     * @param category Filter by mentor category
-     * @param createdBy Filter mentors created by specific user
-     * @param id Retrieve a specific mentor by ID
-     * @param limit Number of results per page
-     * @param llm Filter by language model type
-     * @param offset Starting position for pagination
-     * @param orderBy Field to sort results by ('created_at', 'recently_accessed_at')
-     * @param orderDirection Sort direction ('asc' or 'desc')
-     * @param query Search term to filter mentors by name or description
-     * @param tags Filter by tags
-     * @param tenant Filter by tenant/organization
-     * @param uniqueId Retrieve a specific mentor by UUID
-     * @returns any
-     * @throws ApiError
-     */
-    static searchOrgsUsersMentorsRetrieve(org: string, username: string, audience?: Array<string>, category?: Array<string>, createdBy?: string, id?: number, limit?: number, llm?: Array<string>, offset?: number, orderBy?: string, orderDirection?: string, query?: string, tags?: Array<string>, tenant?: string, uniqueId?: string): CancelablePromise<Record<string, any>>;
-    /**
-     * Search and filter AI prompts for a specific user within a tenant.
-     *
-     * This endpoint extends the base prompt search functionality but filters results
-     * to only show prompts that are available to a specific user within a specific
-     * organization/tenant.
-     *
-     * Path Parameters:
-     * org (str): The organization/tenant identifier
-     * username (str): The username to filter prompts for
-     *
-     * Query Parameters:
-     * Same as PromptSearchView, plus:
-     *
-     * # Identification parameters (for detail view)
-     * id (int, optional): Retrieve a specific prompt by ID
-     *
-     * Returns:
-     * Same format as PromptSearchView, but filtered to only include prompts
-     * that the specified user has access to within the specified organization.
-     *
-     * Error Responses:
-     * 400 Bad Request: If the request parameters are invalid
-     * 403 Forbidden: If the requested prompt exists but the user doesn't have access
-     * 404 Not Found: If the requested prompt doesn't exist
-     * 500 Internal Server Error: If an unexpected error occurs
-     *
-     * Access Control:
-     * - Results are filtered based on user's permissions within the organization
-     * - Private prompts are only visible to authorized users
-     * @param org
-     * @param username
-     * @returns any No response body
-     * @throws ApiError
-     */
-    static searchOrgsUsersPromptsRetrieve(org: string, username: string): CancelablePromise<any>;
-    /**
-     * Determine whether to serve a detail view or a list view.
-     * @param org
-     * @param username
-     * @returns any No response body
-     * @throws ApiError
-     */
-    static searchOrgsUsersRecommendedRetrieve(org: string, username: string): CancelablePromise<any>;
     /**
      * Get personalized content for a specific user
      * @param username
@@ -259,120 +74,6 @@ export declare class SearchService {
      * @throws ApiError
      */
     static searchPersonalizedCatalogRetrieve(username: string, allowSkillSearch?: boolean, alphabetical?: boolean, certificate?: Array<string>, content?: Array<string>, courseId?: string, duration?: Array<string>, language?: Array<string>, level?: Array<string>, limit?: number, offset?: number, orderAscending?: boolean, orderBy?: string, pathwayId?: string, price?: string, programId?: string, programType?: Array<string>, promotion?: Array<string>, query?: string, recommended?: boolean, resourceId?: string, resourceType?: Array<string>, returnFacet?: boolean, returnItems?: boolean, 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>>;
-    /**
-     * Search and filter AI prompts across the platform.
-     *
-     * This endpoint provides a search interface for discovering AI prompts
-     * with support for filtering, pagination, and detailed prompt information.
-     *
-     * Query Parameters:
-     * # Identification parameters (for detail view)
-     * id (int, optional): Retrieve a specific prompt by ID
-     *
-     * # Search and filtering parameters
-     * query (str, optional): Search term to filter prompts by name or content
-     * category (str, optional): Filter by prompt category
-     * language (str, optional): Filter by prompt language
-     * style (str, optional): Filter by writing style
-     * tone (str, optional): Filter by tone
-     * tenant (str, optional): Filter by tenant/organization
-     * mentor (str, optional): Filter by associated mentor (UUID)
-     *
-     * # Sorting and pagination
-     * sort_by (str, optional): Field to sort results by
-     * order_direction (str, optional): Sort direction ('asc' or 'desc', default: 'desc')
-     * alphabetical (bool, optional): Sort alphabetically by name (default: false)
-     * limit (int, optional): Number of results per page (default: 10)
-     * offset (int, optional): Starting position for pagination
-     *
-     * # Special parameters
-     * filter_facet (any, optional): If present, return only facets without results
-     *
-     * Returns:
-     * For detail view (when id is provided):
-     * A JSON response containing a single prompt's details:
-     * {
-         * "id": 456,
-         * "name": "Essay Writing Guide",
-         * "content": "Write a well-structured essay on the following topic: {{topic}}...",
-         * "category": "Academic Writing",
-         * "language": "English",
-         * "style": "Formal",
-         * "tone": "Professional",
-         * "mentor": {
-             * "id": 123,
-             * "unique_id": "550e8400-e29b-41d4-a716-446655440000",
-             * "name": "Professor Smith"
-             * },
-             * "platform": {
-                 * "id": 1,
-                 * "name": "Example University",
-                 * "key": "example-university"
-                 * },
-                 * "created_at": "2023-02-10T09:15:00Z",
-                 * "updated_at": "2023-05-05T14:20:00Z",
-                 * "visibility": "public",
-                 * "variables": ["topic", "length", "style"]
-                 * }
-                 *
-                 * For list view:
-                 * A JSON response containing:
-                 * {
-                     * "results": [
-                         * {
-                             * "id": 456,
-                             * "name": "Essay Writing Guide",
-                             * "content": "Write a well-structured essay on the following topic: {{topic}}...",
-                             * "category": "Academic Writing",
-                             * "language": "English",
-                             * "style": "Formal",
-                             * "tone": "Professional",
-                             * "mentor": {"id": 123, "name": "Professor Smith"},
-                             * "created_at": "2023-02-10T09:15:00Z",
-                             * "updated_at": "2023-05-05T14:20:00Z"
-                             * },
-                             * // Additional prompt objects...
-                             * ],
-                             * "count": 30,
-                             * "next": "?limit=10&offset=10",
-                             * "previous": null,
-                             * "current_page": 1,
-                             * "num_pages": 3,
-                             * "facets": {
-                                 * "category": [
-                                     * {"key": "Academic Writing", "doc_count": 15},
-                                     * {"key": "Creative Writing", "doc_count": 10},
-                                     * {"key": "Technical Documentation", "doc_count": 5}
-                                     * ],
-                                     * "language": [
-                                         * {"key": "English", "doc_count": 25},
-                                         * {"key": "Spanish", "doc_count": 5}
-                                         * ],
-                                         * "style": [
-                                             * {"key": "Formal", "doc_count": 20},
-                                             * {"key": "Casual", "doc_count": 10}
-                                             * ],
-                                             * "tone": [
-                                                 * {"key": "Professional", "doc_count": 15},
-                                                 * {"key": "Friendly", "doc_count": 10},
-                                                 * {"key": "Technical", "doc_count": 5}
-                                                 * ]
-                                                 * }
-                                                 * }
-                                                 *
-                                                 * Error Responses:
-                                                 * 400 Bad Request: If the request parameters are invalid
-                                                 * 403 Forbidden: If the requested prompt exists but is not publicly available
-                                                 * 404 Not Found: If the requested prompt doesn't exist
-                                                 * 500 Internal Server Error: If an unexpected error occurs
-                                                 *
-                                                 * Notes:
-                                                 * - Only publicly available prompts are returned by default
-                                                 * - When filtering by mentor, the mentor ID must be a valid UUID
-                                                 * @returns any No response body
-                                                 * @throws ApiError
-                                                 */
-    static searchPromptsRetrieve(): CancelablePromise<any>;
     /**
      * Search and filter users within a specific organization/tenant.
      *

package/dist/types/services/ServiceService.d.ts

@@ -0,0 +1,170 @@
+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';
+export declare 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
+     */
+    static serviceLaunchTenantCreate(requestBody: TenantLaunchRequest): CancelablePromise<TenantLaunchResponse>;
+    /**
+     * User creation flow
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceManageUserCreate(): CancelablePromise<any>;
+    /**
+     * Make user tenant admin
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceManageUserRoleCreate(): CancelablePromise<any>;
+    /**
+     * 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
+         */
+    static serviceOrgsUsersStripeCheckoutSessionCreate(org: string, userId: string, requestBody: StripeCheckoutSessionRequest): CancelablePromise<StripeCheckoutSessionResponse>;
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param userId
+     * @param requestBody
+     * @returns StripeCustomerPortalResponse
+     * @throws ApiError
+     */
+    static serviceOrgsUsersStripeCustomerPortalCreate(org: string, userId: string, requestBody: StripeCustomerPortalRequest): CancelablePromise<StripeCustomerPortalResponse>;
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param userId
+     * @returns StripeLocalProduct
+     * @throws ApiError
+     */
+    static serviceOrgsUsersStripeProductsRetrieve(org: string, userId: string): CancelablePromise<StripeLocalProduct>;
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsPlatformAdmin
+     * @param org
+     * @param userId
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceOrgsUsersStripeProductsManageCreate(org: string, userId: string): CancelablePromise<any>;
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param userId
+     * @param requestBody
+     * @returns StripeSubscriptionRenewalResponse
+     * @throws ApiError
+     */
+    static serviceOrgsUsersStripeSubscriptionRenewalCreate(org: string, userId: string, requestBody: StripeSubscriptionRenewalRequest): CancelablePromise<StripeSubscriptionRenewalResponse>;
+    /**
+     * Mixin that includes the StudentTokenAuthentication and IsAdminUserOrStudent
+     * @param org
+     * @param userId
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceOrgsUsersStripeSubscriptionsRetrieve(org: string, userId: string): CancelablePromise<any>;
+    /**
+     * 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
+     */
+    static serviceOrgsStripeCoursePaymentCallbackRetrieve(platformKey: string): CancelablePromise<any>;
+    /**
+     * @param checkoutUuid
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceStripeCheckoutRetrieve(checkoutUuid: string): CancelablePromise<any>;
+    /**
+     * 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
+         */
+    static serviceStripeCheckoutFreeTrialCreate(requestBody: StripeCheckoutSessionResponse): CancelablePromise<StripeCheckoutSessionResponse>;
+    /**
+     * Check if tenant exists or not
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceTenantValidationCreate(): CancelablePromise<any>;
+    /**
+     * GET
+     * Gets site hash_key from
+     * or
+     * Gets site_id form hash_key
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceTokenRetrieve(): CancelablePromise<any>;
+    /**
+     * Check if tenant exists or not
+     * @returns any No response body
+     * @throws ApiError
+     */
+    static serviceUserValidationCreate(): CancelablePromise<any>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iblai/iblai-api",
-  "version": "3.35.3-ai-plus",
+  "version": "3.35.4-core",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
   "type": "module",

package/src/core/OpenAPI.ts

@@ -21,7 +21,7 @@ export type OpenAPIConfig = {
 
 export const OpenAPI: OpenAPIConfig = {
     BASE: 'https://base.manager.iblai.app',
-    VERSION: '3.35.3-ai-plus',
+    VERSION: '3.35.4-core',
     WITH_CREDENTIALS: false,
     CREDENTIALS: 'include',
     TOKEN: undefined,