@iblai/iblai-api 4.6.2-dev1-ai-plus → 4.7.0-ai-plus

package/src/services/AiAccountService.ts

@@ -9,6 +9,8 @@ import type { IntegrationCredentialSchema } from '../models/IntegrationCredentia
 import type { LLMCredentialRequest } from '../models/LLMCredentialRequest';
 import type { LLMCredentialResponse } from '../models/LLMCredentialResponse';
 import type { LLMCredentialSchema } from '../models/LLMCredentialSchema';
+import type { MaskedIntegrationCredential } from '../models/MaskedIntegrationCredential';
+import type { MaskedLLMCredential } from '../models/MaskedLLMCredential';
 import type { OAuthStartResponse } from '../models/OAuthStartResponse';
 import type { PatchedCredentialRequest } from '../models/PatchedCredentialRequest';
 import type { PatchedLLMCredentialRequest } from '../models/PatchedLLMCredentialRequest';
@@ -540,6 +542,86 @@ export class AiAccountService {
             },
         });
     }
+    /**
+     * Retrieve masked integration credentials for an organization.
+     *
+     * Query Parameters:
+     * name (optional): Filter results by integration service name
+     *
+     * Args:
+     * request: The HTTP request
+     * org: Organization key identifier
+     *
+     * Returns:
+     * Response: List of integration credentials for the organization
+     *
+     * Raises:
+     * NotFound: When organization is not found or when no credentials match the filters
+     * ValidationError: When query parameters are invalid
+     * @returns MaskedIntegrationCredential
+     * @throws ApiError
+     */
+    public static aiAccountOrgsMaskedIntegrationCredentialList({
+        org,
+        name,
+    }: {
+        org: string,
+        /**
+         * Filter credentials by provider name (e.g., 'openai', 'google')
+         */
+        name?: string,
+    }): CancelablePromise<Array<MaskedIntegrationCredential>> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-account/orgs/{org}/masked-integration-credential/',
+            path: {
+                'org': org,
+            },
+            query: {
+                'name': name,
+            },
+        });
+    }
+    /**
+     * Retrieve LLM credentials for an organization with the value entries masked.
+     *
+     * Query Parameters:
+     * name (optional): Filter results by LLM provider name
+     *
+     * Args:
+     * request: The HTTP request
+     * org: Organization key identifier
+     *
+     * Returns:
+     * Response: List of LLM credentials for the organization
+     *
+     * Raises:
+     * NotFound: When organization is not found or when no credentials match the filters
+     * ValidationError: When query parameters are invalid
+     * @returns MaskedLLMCredential
+     * @throws ApiError
+     */
+    public static aiAccountOrgsMaskedLlmCredentialRetrieve({
+        org,
+        name,
+    }: {
+        org: string,
+        /**
+         * Filter credentials by provider name (e.g., 'openai', 'google')
+         */
+        name?: string,
+    }): CancelablePromise<MaskedLLMCredential> {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/api/ai-account/orgs/{org}/masked-llm-credential/',
+            path: {
+                'org': org,
+            },
+            query: {
+                'name': name,
+            },
+        });
+    }
     /**
      * Enable or disable the use of main LLM credentials for an organization.
      *

package/src/services/AiMentorService.ts

@@ -127,6 +127,7 @@ import type { SubSection } from '../models/SubSection';
 import type { TaskView } from '../models/TaskView';
 import type { TemplateMentor } from '../models/TemplateMentor';
 import type { TicketMessage } from '../models/TicketMessage';
+import type { ToolCategory } from '../models/ToolCategory';
 import type { ToolResponse } from '../models/ToolResponse';
 import type { TriggerRequest } from '../models/TriggerRequest';
 import type { TriggerResponse } from '../models/TriggerResponse';
@@ -5816,10 +5817,20 @@ export class AiMentorService {
                                             mentor,
                                             org,
                                             userId,
+                                            ordering,
+                                            search,
                                         }: {
                                             mentor: string,
                                             org: string,
                                             userId: string,
+                                            /**
+                                             * Which field to use when ordering the results.
+                                             */
+                                            ordering?: string,
+                                            /**
+                                             * A search term.
+                                             */
+                                            search?: string,
                                         }): CancelablePromise<Array<ToolResponse>> {
                                             return __request(OpenAPI, {
                                                 method: 'GET',
@@ -5829,6 +5840,10 @@ export class AiMentorService {
                                                     'org': org,
                                                     'user_id': userId,
                                                 },
+                                                query: {
+                                                    'ordering': ordering,
+                                                    'search': search,
+                                                },
                                             });
                                         }
                                         /**
@@ -9858,6 +9873,27 @@ export class AiMentorService {
                                                                                                 mediaType: 'application/json',
                                                                                             });
                                                                                         }
+                                                                                        /**
+                                                                                         * Retrieve Tool Categories
+                                                                                         * @returns ToolCategory
+                                                                                         * @throws ApiError
+                                                                                         */
+                                                                                        public static aiMentorOrgsUsersToolCategoriesList({
+                                                                                            org,
+                                                                                            userId,
+                                                                                        }: {
+                                                                                            org: string,
+                                                                                            userId: string,
+                                                                                        }): CancelablePromise<Array<ToolCategory>> {
+                                                                                            return __request(OpenAPI, {
+                                                                                                method: 'GET',
+                                                                                                url: '/api/ai-mentor/orgs/{org}/users/{user_id}/tool-categories/',
+                                                                                                path: {
+                                                                                                    'org': org,
+                                                                                                    'user_id': userId,
+                                                                                                },
+                                                                                            });
+                                                                                        }
                                                                                         /**
                                                                                          * Retrieve a list of available voice options.
                                                                                          *