@openfilz-sdk/typescript-ee 1.12.10 → 1.12.11

package/.openapi-generator/FILES

@@ -176,6 +176,8 @@ docs/FilterInput.md
 docs/FolderControllerApi.md
 docs/FolderElementInfo.md
 docs/FolderResponse.md
+docs/FolderSelectionByKindRequest.md
+docs/FolderSelectionByKindResponse.md
 docs/ForeignItem.md
 docs/IngestionStatusDto.md
 docs/InsightBackfillRequest.md
@@ -422,6 +424,8 @@ models/filing.ts
 models/filter-input.ts
 models/folder-element-info.ts
 models/folder-response.ts
+models/folder-selection-by-kind-request.ts
+models/folder-selection-by-kind-response.ts
 models/foreign-item.ts
 models/index.ts
 models/ingestion-status-dto.ts

package/.openapi-generator/openfilz-api-generate-typescript-sdk.sha256

@@ -1 +1 @@
-d984fc602a0319de1edd48de431a42c08a6acf515cfb6947f9bfa308a62ff0ce
+b4878af7154d9ba50f4fe2430decde7d407aace3178d1baa6c8889aecfdaf83e

package/README.md

@@ -1,4 +1,4 @@
-## @openfilz-sdk/typescript-ee@1.12.10
+## @openfilz-sdk/typescript-ee@1.12.11
 
 This generator creates TypeScript/JavaScript client that utilizes [axios](https://github.com/axios/axios). The generated Node module can be used in the following environments:
 
@@ -36,7 +36,7 @@ navigate to the folder of your consuming project and run one of the following co
 _published:_
 
 ```
-npm install @openfilz-sdk/typescript-ee@1.12.10 --save
+npm install @openfilz-sdk/typescript-ee@1.12.11 --save
 ```
 
 _unPublished (not recommended):_
@@ -58,7 +58,8 @@ Class | Method | HTTP request | Description
 *AIChatApi* | [**get9**](docs/AIChatApi.md#get9) | **GET** /api/v1/ai/reorganization/{planId} | Get a reorganisation plan proposed by the AI assistant
 *AIChatApi* | [**getConversationHistory**](docs/AIChatApi.md#getconversationhistory) | **GET** /api/v1/ai/conversations/{conversationId} | Get conversation history
 *AIChatApi* | [**listConversations**](docs/AIChatApi.md#listconversations) | **GET** /api/v1/ai/conversations | List conversations
-*AIChatApi* | [**proposeByKind**](docs/AIChatApi.md#proposebykind) | **POST** /api/v1/ai/reorganization/by-kind | Propose a reorganisation by kind of document — no model involved
+*AIChatApi* | [**proposeByKind**](docs/AIChatApi.md#proposebykind) | **POST** /api/v1/ai/reorganization/folders/by-kind | Organise several folders by kind of document as one plan — no model involved
+*AIChatApi* | [**proposeByKind1**](docs/AIChatApi.md#proposebykind1) | **POST** /api/v1/ai/reorganization/by-kind | Propose a reorganisation by kind of document — no model involved
 *AIDirectoryApi* | [**teams**](docs/AIDirectoryApi.md#teams) | **GET** /api/v1/admin/ai/directory/teams | The teams of the DMS database (the ids the AI features store)
 *AIEmbeddingsApi* | [**backfill1**](docs/AIEmbeddingsApi.md#backfill1) | **POST** /api/v1/ai/embeddings/backfill | Embed existing documents
 *AIEmbeddingsApi* | [**backfillStatus1**](docs/AIEmbeddingsApi.md#backfillstatus1) | **GET** /api/v1/ai/embeddings/backfill/{jobId} | Progress of an embedding backfill job
@@ -397,6 +398,8 @@ Class | Method | HTTP request | Description
  - [FilterInput](docs/FilterInput.md)
  - [FolderElementInfo](docs/FolderElementInfo.md)
  - [FolderResponse](docs/FolderResponse.md)
+ - [FolderSelectionByKindRequest](docs/FolderSelectionByKindRequest.md)
+ - [FolderSelectionByKindResponse](docs/FolderSelectionByKindResponse.md)
  - [ForeignItem](docs/ForeignItem.md)
  - [IngestionStatusDto](docs/IngestionStatusDto.md)
  - [InsightBackfillRequest](docs/InsightBackfillRequest.md)

package/api/aichat-api.ts

@@ -28,6 +28,10 @@ import type { AiChatRequest } from '../models';
 // @ts-ignore
 import type { AiChatResponse } from '../models';
 // @ts-ignore
+import type { FolderSelectionByKindRequest } from '../models';
+// @ts-ignore
+import type { FolderSelectionByKindResponse } from '../models';
+// @ts-ignore
 import type { ReorganizationApplyRequest } from '../models';
 // @ts-ignore
 import type { ReorganizationApplyResult } from '../models';
@@ -305,6 +309,43 @@ export const AIChatApiAxiosParamCreator = function (configuration?: Configuratio
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind: async (folderSelectionByKindRequest?: FolderSelectionByKindRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/api/v1/ai/reorganization/folders/by-kind`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // authentication keycloak_auth required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration)
+
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = 'application/json';
+
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+            localVarRequestOptions.data = serializeDataIfNeeded(folderSelectionByKindRequest, localVarRequestOptions, configuration)
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -312,7 +353,7 @@ export const AIChatApiAxiosParamCreator = function (configuration?: Configuratio
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind: async (reorganizationByKindRequest?: ReorganizationByKindRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+        proposeByKind1: async (reorganizationByKindRequest?: ReorganizationByKindRequest, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
             const localVarPath = `/api/v1/ai/reorganization/by-kind`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -442,6 +483,19 @@ export const AIChatApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['AIChatApi.listConversations']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FolderSelectionByKindResponse>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.proposeByKind(folderSelectionByKindRequest, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AIChatApi.proposeByKind']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -449,10 +503,10 @@ export const AIChatApiFp = function(configuration?: Configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReorganizationPlanView>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.proposeByKind(reorganizationByKindRequest, options);
+        async proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReorganizationPlanView>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.proposeByKind1(reorganizationByKindRequest, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-            const localVarOperationServerBasePath = operationServerMap['AIChatApi.proposeByKind']?.[localVarOperationServerIndex]?.url;
+            const localVarOperationServerBasePath = operationServerMap['AIChatApi.proposeByKind1']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
     }
@@ -534,6 +588,16 @@ export const AIChatApiFactory = function (configuration?: Configuration, basePat
         listConversations(options?: RawAxiosRequestConfig): AxiosPromise<Array<AiChatConversation>> {
             return localVarFp.listConversations(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest] 
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<FolderSelectionByKindResponse> {
+            return localVarFp.proposeByKind(folderSelectionByKindRequest, options).then((request) => request(axios, basePath));
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -541,8 +605,8 @@ export const AIChatApiFactory = function (configuration?: Configuration, basePat
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReorganizationPlanView> {
-            return localVarFp.proposeByKind(reorganizationByKindRequest, options).then((request) => request(axios, basePath));
+        proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReorganizationPlanView> {
+            return localVarFp.proposeByKind1(reorganizationByKindRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -628,6 +692,17 @@ export class AIChatApi extends BaseAPI {
         return AIChatApiFp(this.configuration).listConversations(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest] 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    public proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig) {
+        return AIChatApiFp(this.configuration).proposeByKind(folderSelectionByKindRequest, options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -635,8 +710,8 @@ export class AIChatApi extends BaseAPI {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    public proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig) {
-        return AIChatApiFp(this.configuration).proposeByKind(reorganizationByKindRequest, options).then((request) => request(this.axios, this.basePath));
+    public proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig) {
+        return AIChatApiFp(this.configuration).proposeByKind1(reorganizationByKindRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 

package/dist/api/aichat-api.d.ts

@@ -15,6 +15,8 @@ import { type RequestArgs, BaseAPI } from '../base';
 import type { AiChatConversation } from '../models';
 import type { AiChatRequest } from '../models';
 import type { AiChatResponse } from '../models';
+import type { FolderSelectionByKindRequest } from '../models';
+import type { FolderSelectionByKindResponse } from '../models';
 import type { ReorganizationApplyRequest } from '../models';
 import type { ReorganizationApplyResult } from '../models';
 import type { ReorganizationByKindRequest } from '../models';
@@ -79,6 +81,14 @@ export declare const AIChatApiAxiosParamCreator: (configuration?: Configuration)
      * @throws {RequiredError}
      */
     listConversations: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind: (folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -86,7 +96,7 @@ export declare const AIChatApiAxiosParamCreator: (configuration?: Configuration)
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind: (reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    proposeByKind1: (reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
 };
 /**
  * AIChatApi - functional programming interface
@@ -148,6 +158,14 @@ export declare const AIChatApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     listConversations(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<AiChatConversation>>>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FolderSelectionByKindResponse>>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -155,7 +173,7 @@ export declare const AIChatApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReorganizationPlanView>>;
+    proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReorganizationPlanView>>;
 };
 /**
  * AIChatApi - factory interface
@@ -217,6 +235,14 @@ export declare const AIChatApiFactory: (configuration?: Configuration, basePath?
      * @throws {RequiredError}
      */
     listConversations(options?: RawAxiosRequestConfig): AxiosPromise<Array<AiChatConversation>>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<FolderSelectionByKindResponse>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -224,7 +250,7 @@ export declare const AIChatApiFactory: (configuration?: Configuration, basePath?
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReorganizationPlanView>;
+    proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReorganizationPlanView>;
 };
 /**
  * AIChatApi - object-oriented interface
@@ -286,6 +312,14 @@ export declare class AIChatApi extends BaseAPI {
      * @throws {RequiredError}
      */
     listConversations(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AiChatConversation[], any, {}, any>>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FolderSelectionByKindResponse, any, {}, any>>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -293,5 +327,5 @@ export declare class AIChatApi extends BaseAPI {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReorganizationPlanView, any, {}, any>>;
+    proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReorganizationPlanView, any, {}, any>>;
 }

package/dist/api/aichat-api.js

@@ -264,6 +264,38 @@ const AIChatApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         }),
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind: (folderSelectionByKindRequest_1, ...args_1) => __awaiter(this, [folderSelectionByKindRequest_1, ...args_1], void 0, function* (folderSelectionByKindRequest, options = {}) {
+            const localVarPath = `/api/v1/ai/reorganization/folders/by-kind`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = Object.assign(Object.assign({ method: 'POST' }, baseOptions), options);
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication keycloak_auth required
+            // http bearer authentication required
+            yield (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = 'application/json';
+            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = Object.assign(Object.assign(Object.assign({}, localVarHeaderParameter), headersFromBaseOptions), options.headers);
+            localVarRequestOptions.data = (0, common_1.serializeDataIfNeeded)(folderSelectionByKindRequest, localVarRequestOptions, configuration);
+            return {
+                url: (0, common_1.toPathString)(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        }),
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -271,7 +303,7 @@ const AIChatApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind: (reorganizationByKindRequest_1, ...args_1) => __awaiter(this, [reorganizationByKindRequest_1, ...args_1], void 0, function* (reorganizationByKindRequest, options = {}) {
+        proposeByKind1: (reorganizationByKindRequest_1, ...args_1) => __awaiter(this, [reorganizationByKindRequest_1, ...args_1], void 0, function* (reorganizationByKindRequest, options = {}) {
             const localVarPath = `/api/v1/ai/reorganization/by-kind`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
@@ -417,6 +449,22 @@ const AIChatApiFp = function (configuration) {
                 return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
             });
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind(folderSelectionByKindRequest, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const localVarAxiosArgs = yield localVarAxiosParamCreator.proposeByKind(folderSelectionByKindRequest, options);
+                const localVarOperationServerIndex = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.serverIndex) !== null && _a !== void 0 ? _a : 0;
+                const localVarOperationServerBasePath = (_c = (_b = base_1.operationServerMap['AIChatApi.proposeByKind']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
+                return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+            });
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -424,12 +472,12 @@ const AIChatApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind(reorganizationByKindRequest, options) {
+        proposeByKind1(reorganizationByKindRequest, options) {
             return __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
-                const localVarAxiosArgs = yield localVarAxiosParamCreator.proposeByKind(reorganizationByKindRequest, options);
+                const localVarAxiosArgs = yield localVarAxiosParamCreator.proposeByKind1(reorganizationByKindRequest, options);
                 const localVarOperationServerIndex = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.serverIndex) !== null && _a !== void 0 ? _a : 0;
-                const localVarOperationServerBasePath = (_c = (_b = base_1.operationServerMap['AIChatApi.proposeByKind']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
+                const localVarOperationServerBasePath = (_c = (_b = base_1.operationServerMap['AIChatApi.proposeByKind1']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
                 return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
             });
         },
@@ -512,6 +560,16 @@ const AIChatApiFactory = function (configuration, basePath, axios) {
         listConversations(options) {
             return localVarFp.listConversations(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind(folderSelectionByKindRequest, options) {
+            return localVarFp.proposeByKind(folderSelectionByKindRequest, options).then((request) => request(axios, basePath));
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -519,8 +577,8 @@ const AIChatApiFactory = function (configuration, basePath, axios) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind(reorganizationByKindRequest, options) {
-            return localVarFp.proposeByKind(reorganizationByKindRequest, options).then((request) => request(axios, basePath));
+        proposeByKind1(reorganizationByKindRequest, options) {
+            return localVarFp.proposeByKind1(reorganizationByKindRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -599,6 +657,16 @@ class AIChatApi extends base_1.BaseAPI {
     listConversations(options) {
         return (0, exports.AIChatApiFp)(this.configuration).listConversations(options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest, options) {
+        return (0, exports.AIChatApiFp)(this.configuration).proposeByKind(folderSelectionByKindRequest, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -606,8 +674,8 @@ class AIChatApi extends base_1.BaseAPI {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest, options) {
-        return (0, exports.AIChatApiFp)(this.configuration).proposeByKind(reorganizationByKindRequest, options).then((request) => request(this.axios, this.basePath));
+    proposeByKind1(reorganizationByKindRequest, options) {
+        return (0, exports.AIChatApiFp)(this.configuration).proposeByKind1(reorganizationByKindRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }
 exports.AIChatApi = AIChatApi;

package/dist/esm/api/aichat-api.d.ts

@@ -15,6 +15,8 @@ import { type RequestArgs, BaseAPI } from '../base';
 import type { AiChatConversation } from '../models';
 import type { AiChatRequest } from '../models';
 import type { AiChatResponse } from '../models';
+import type { FolderSelectionByKindRequest } from '../models';
+import type { FolderSelectionByKindResponse } from '../models';
 import type { ReorganizationApplyRequest } from '../models';
 import type { ReorganizationApplyResult } from '../models';
 import type { ReorganizationByKindRequest } from '../models';
@@ -79,6 +81,14 @@ export declare const AIChatApiAxiosParamCreator: (configuration?: Configuration)
      * @throws {RequiredError}
      */
     listConversations: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind: (folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -86,7 +96,7 @@ export declare const AIChatApiAxiosParamCreator: (configuration?: Configuration)
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind: (reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    proposeByKind1: (reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
 };
 /**
  * AIChatApi - functional programming interface
@@ -148,6 +158,14 @@ export declare const AIChatApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     listConversations(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<AiChatConversation>>>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<FolderSelectionByKindResponse>>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -155,7 +173,7 @@ export declare const AIChatApiFp: (configuration?: Configuration) => {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReorganizationPlanView>>;
+    proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ReorganizationPlanView>>;
 };
 /**
  * AIChatApi - factory interface
@@ -217,6 +235,14 @@ export declare const AIChatApiFactory: (configuration?: Configuration, basePath?
      * @throws {RequiredError}
      */
     listConversations(options?: RawAxiosRequestConfig): AxiosPromise<Array<AiChatConversation>>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<FolderSelectionByKindResponse>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -224,7 +250,7 @@ export declare const AIChatApiFactory: (configuration?: Configuration, basePath?
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReorganizationPlanView>;
+    proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): AxiosPromise<ReorganizationPlanView>;
 };
 /**
  * AIChatApi - object-oriented interface
@@ -286,6 +312,14 @@ export declare class AIChatApi extends BaseAPI {
      * @throws {RequiredError}
      */
     listConversations(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AiChatConversation[], any, {}, any>>;
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest?: FolderSelectionByKindRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<FolderSelectionByKindResponse, any, {}, any>>;
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -293,5 +327,5 @@ export declare class AIChatApi extends BaseAPI {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReorganizationPlanView, any, {}, any>>;
+    proposeByKind1(reorganizationByKindRequest?: ReorganizationByKindRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<ReorganizationPlanView, any, {}, any>>;
 }

package/dist/esm/api/aichat-api.js

@@ -261,6 +261,38 @@ export const AIChatApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         }),
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind: (folderSelectionByKindRequest_1, ...args_1) => __awaiter(this, [folderSelectionByKindRequest_1, ...args_1], void 0, function* (folderSelectionByKindRequest, options = {}) {
+            const localVarPath = `/api/v1/ai/reorganization/folders/by-kind`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = Object.assign(Object.assign({ method: 'POST' }, baseOptions), options);
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication keycloak_auth required
+            // http bearer authentication required
+            yield setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            localVarHeaderParameter['Accept'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = Object.assign(Object.assign(Object.assign({}, localVarHeaderParameter), headersFromBaseOptions), options.headers);
+            localVarRequestOptions.data = serializeDataIfNeeded(folderSelectionByKindRequest, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        }),
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -268,7 +300,7 @@ export const AIChatApiAxiosParamCreator = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind: (reorganizationByKindRequest_1, ...args_1) => __awaiter(this, [reorganizationByKindRequest_1, ...args_1], void 0, function* (reorganizationByKindRequest, options = {}) {
+        proposeByKind1: (reorganizationByKindRequest_1, ...args_1) => __awaiter(this, [reorganizationByKindRequest_1, ...args_1], void 0, function* (reorganizationByKindRequest, options = {}) {
             const localVarPath = `/api/v1/ai/reorganization/by-kind`;
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -413,6 +445,22 @@ export const AIChatApiFp = function (configuration) {
                 return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
             });
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind(folderSelectionByKindRequest, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                var _a, _b, _c;
+                const localVarAxiosArgs = yield localVarAxiosParamCreator.proposeByKind(folderSelectionByKindRequest, options);
+                const localVarOperationServerIndex = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.serverIndex) !== null && _a !== void 0 ? _a : 0;
+                const localVarOperationServerBasePath = (_c = (_b = operationServerMap['AIChatApi.proposeByKind']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
+                return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+            });
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -420,12 +468,12 @@ export const AIChatApiFp = function (configuration) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind(reorganizationByKindRequest, options) {
+        proposeByKind1(reorganizationByKindRequest, options) {
             return __awaiter(this, void 0, void 0, function* () {
                 var _a, _b, _c;
-                const localVarAxiosArgs = yield localVarAxiosParamCreator.proposeByKind(reorganizationByKindRequest, options);
+                const localVarAxiosArgs = yield localVarAxiosParamCreator.proposeByKind1(reorganizationByKindRequest, options);
                 const localVarOperationServerIndex = (_a = configuration === null || configuration === void 0 ? void 0 : configuration.serverIndex) !== null && _a !== void 0 ? _a : 0;
-                const localVarOperationServerBasePath = (_c = (_b = operationServerMap['AIChatApi.proposeByKind']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
+                const localVarOperationServerBasePath = (_c = (_b = operationServerMap['AIChatApi.proposeByKind1']) === null || _b === void 0 ? void 0 : _b[localVarOperationServerIndex]) === null || _c === void 0 ? void 0 : _c.url;
                 return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
             });
         },
@@ -507,6 +555,16 @@ export const AIChatApiFactory = function (configuration, basePath, axios) {
         listConversations(options) {
             return localVarFp.listConversations(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+         * @summary Organise several folders by kind of document as one plan — no model involved
+         * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        proposeByKind(folderSelectionByKindRequest, options) {
+            return localVarFp.proposeByKind(folderSelectionByKindRequest, options).then((request) => request(axios, basePath));
+        },
         /**
          * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
          * @summary Propose a reorganisation by kind of document — no model involved
@@ -514,8 +572,8 @@ export const AIChatApiFactory = function (configuration, basePath, axios) {
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        proposeByKind(reorganizationByKindRequest, options) {
-            return localVarFp.proposeByKind(reorganizationByKindRequest, options).then((request) => request(axios, basePath));
+        proposeByKind1(reorganizationByKindRequest, options) {
+            return localVarFp.proposeByKind1(reorganizationByKindRequest, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -593,6 +651,16 @@ export class AIChatApi extends BaseAPI {
     listConversations(options) {
         return AIChatApiFp(this.configuration).listConversations(options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+     * @summary Organise several folders by kind of document as one plan — no model involved
+     * @param {FolderSelectionByKindRequest} [folderSelectionByKindRequest]
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    proposeByKind(folderSelectionByKindRequest, options) {
+        return AIChatApiFp(this.configuration).proposeByKind(folderSelectionByKindRequest, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
      * @summary Propose a reorganisation by kind of document — no model involved
@@ -600,7 +668,7 @@ export class AIChatApi extends BaseAPI {
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      */
-    proposeByKind(reorganizationByKindRequest, options) {
-        return AIChatApiFp(this.configuration).proposeByKind(reorganizationByKindRequest, options).then((request) => request(this.axios, this.basePath));
+    proposeByKind1(reorganizationByKindRequest, options) {
+        return AIChatApiFp(this.configuration).proposeByKind1(reorganizationByKindRequest, options).then((request) => request(this.axios, this.basePath));
     }
 }

package/dist/esm/models/folder-selection-by-kind-request.d.ts

@@ -0,0 +1,14 @@
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export interface FolderSelectionByKindRequest {
+    'folderIds'?: Array<string>;
+}

package/dist/esm/models/folder-selection-by-kind-request.js

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};

package/dist/esm/models/folder-selection-by-kind-response.d.ts

@@ -0,0 +1,18 @@
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ReorganizationPlanView } from './reorganization-plan-view';
+export interface FolderSelectionByKindResponse {
+    'plan'?: ReorganizationPlanView;
+    'classifiedNow'?: number;
+    'unclassified'?: number;
+    'classifier'?: string;
+}

package/dist/esm/models/folder-selection-by-kind-response.js

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export {};

package/dist/esm/models/index.d.ts

@@ -84,6 +84,8 @@ export * from './filing-rule-view';
 export * from './filter-input';
 export * from './folder-element-info';
 export * from './folder-response';
+export * from './folder-selection-by-kind-request';
+export * from './folder-selection-by-kind-response';
 export * from './foreign-item';
 export * from './ingestion-status-dto';
 export * from './insight-backfill-request';

package/dist/esm/models/index.js

@@ -84,6 +84,8 @@ export * from './filing-rule-view';
 export * from './filter-input';
 export * from './folder-element-info';
 export * from './folder-response';
+export * from './folder-selection-by-kind-request';
+export * from './folder-selection-by-kind-response';
 export * from './foreign-item';
 export * from './ingestion-status-dto';
 export * from './insight-backfill-request';

package/dist/models/folder-selection-by-kind-request.d.ts

@@ -0,0 +1,14 @@
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export interface FolderSelectionByKindRequest {
+    'folderIds'?: Array<string>;
+}

package/dist/models/folder-selection-by-kind-request.js

@@ -0,0 +1,15 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/folder-selection-by-kind-response.d.ts

@@ -0,0 +1,18 @@
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ReorganizationPlanView } from './reorganization-plan-view';
+export interface FolderSelectionByKindResponse {
+    'plan'?: ReorganizationPlanView;
+    'classifiedNow'?: number;
+    'unclassified'?: number;
+    'classifier'?: string;
+}

package/dist/models/folder-selection-by-kind-response.js

@@ -0,0 +1,15 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/index.d.ts

@@ -84,6 +84,8 @@ export * from './filing-rule-view';
 export * from './filter-input';
 export * from './folder-element-info';
 export * from './folder-response';
+export * from './folder-selection-by-kind-request';
+export * from './folder-selection-by-kind-response';
 export * from './foreign-item';
 export * from './ingestion-status-dto';
 export * from './insight-backfill-request';

package/dist/models/index.js

@@ -100,6 +100,8 @@ __exportStar(require("./filing-rule-view"), exports);
 __exportStar(require("./filter-input"), exports);
 __exportStar(require("./folder-element-info"), exports);
 __exportStar(require("./folder-response"), exports);
+__exportStar(require("./folder-selection-by-kind-request"), exports);
+__exportStar(require("./folder-selection-by-kind-response"), exports);
 __exportStar(require("./foreign-item"), exports);
 __exportStar(require("./ingestion-status-dto"), exports);
 __exportStar(require("./insight-backfill-request"), exports);

package/docs/AIChatApi.md

@@ -11,7 +11,8 @@ All URIs are relative to *http://localhost:8081*
 |[**get9**](#get9) | **GET** /api/v1/ai/reorganization/{planId} | Get a reorganisation plan proposed by the AI assistant|
 |[**getConversationHistory**](#getconversationhistory) | **GET** /api/v1/ai/conversations/{conversationId} | Get conversation history|
 |[**listConversations**](#listconversations) | **GET** /api/v1/ai/conversations | List conversations|
-|[**proposeByKind**](#proposebykind) | **POST** /api/v1/ai/reorganization/by-kind | Propose a reorganisation by kind of document — no model involved|
+|[**proposeByKind**](#proposebykind) | **POST** /api/v1/ai/reorganization/folders/by-kind | Organise several folders by kind of document as one plan — no model involved|
+|[**proposeByKind1**](#proposebykind1) | **POST** /api/v1/ai/reorganization/by-kind | Propose a reorganisation by kind of document — no model involved|
 
 # **apply**
 > ReorganizationApplyResult apply()
@@ -368,7 +369,59 @@ This endpoint does not have any parameters.
 [[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
 
 # **proposeByKind**
-> ReorganizationPlanView proposeByKind()
+> FolderSelectionByKindResponse proposeByKind()
+
+Files of the selected folders that have no kind yet are first classified by the local classifier (at most 200 per request; never a chat model), then every folder of the selection holding documents of several kinds gets one sub-folder per kind. The answer carries ONE stored plan rooted at the selection\'s common parent (a plan without an id means nothing needs splitting) and the classification counts. folderIds absent or empty = the root level; at most 20; a folder nested in another selected one is covered by it. 404 for a folder you cannot open, 403 without the CONTRIBUTOR role.
+
+### Example
+
+```typescript
+import {
+    AIChatApi,
+    Configuration,
+    FolderSelectionByKindRequest
+} from '@openfilz-sdk/typescript-ee';
+
+const configuration = new Configuration();
+const apiInstance = new AIChatApi(configuration);
+
+let folderSelectionByKindRequest: FolderSelectionByKindRequest; // (optional)
+
+const { status, data } = await apiInstance.proposeByKind(
+    folderSelectionByKindRequest
+);
+```
+
+### Parameters
+
+|Name | Type | Description  | Notes|
+|------------- | ------------- | ------------- | -------------|
+| **folderSelectionByKindRequest** | **FolderSelectionByKindRequest**|  | |
+
+
+### Return type
+
+**FolderSelectionByKindResponse**
+
+### Authorization
+
+[keycloak_auth](../README.md#keycloak_auth)
+
+### HTTP request headers
+
+ - **Content-Type**: application/json
+ - **Accept**: application/json
+
+
+### HTTP response details
+| Status code | Description | Response headers |
+|-------------|-------------|------------------|
+|**200** | OK |  -  |
+
+[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md)
+
+# **proposeByKind1**
+> ReorganizationPlanView proposeByKind1()
 
 Every folder of the scope holding documents of several kinds (their insight category) gets one sub-folder per kind, named like the existing folders (Invoices / Factures…), and the files move there. The answer is a stored plan to review and apply; a plan without an id means nothing needs splitting.
 
@@ -386,7 +439,7 @@ const apiInstance = new AIChatApi(configuration);
 
 let reorganizationByKindRequest: ReorganizationByKindRequest; // (optional)
 
-const { status, data } = await apiInstance.proposeByKind(
+const { status, data } = await apiInstance.proposeByKind1(
     reorganizationByKindRequest
 );
 ```

package/docs/FolderSelectionByKindRequest.md

@@ -0,0 +1,20 @@
+# FolderSelectionByKindRequest
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**folderIds** | **Array<string>** |  | [optional] [default to undefined]
+
+## Example
+
+```typescript
+import { FolderSelectionByKindRequest } from '@openfilz-sdk/typescript-ee';
+
+const instance: FolderSelectionByKindRequest = {
+    folderIds,
+};
+```
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

package/docs/FolderSelectionByKindResponse.md

@@ -0,0 +1,26 @@
+# FolderSelectionByKindResponse
+
+
+## Properties
+
+Name | Type | Description | Notes
+------------ | ------------- | ------------- | -------------
+**plan** | [**ReorganizationPlanView**](ReorganizationPlanView.md) |  | [optional] [default to undefined]
+**classifiedNow** | **number** |  | [optional] [default to undefined]
+**unclassified** | **number** |  | [optional] [default to undefined]
+**classifier** | **string** |  | [optional] [default to undefined]
+
+## Example
+
+```typescript
+import { FolderSelectionByKindResponse } from '@openfilz-sdk/typescript-ee';
+
+const instance: FolderSelectionByKindResponse = {
+    plan,
+    classifiedNow,
+    unclassified,
+    classifier,
+};
+```
+
+[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md)

package/models/folder-selection-by-kind-request.ts

@@ -0,0 +1,20 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+
+export interface FolderSelectionByKindRequest {
+    'folderIds'?: Array<string>;
+}
+

package/models/folder-selection-by-kind-response.ts

@@ -0,0 +1,26 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * openfilz-api
+ * API for Document Management System
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+
+// May contain unused imports in some cases
+// @ts-ignore
+import type { ReorganizationPlanView } from './reorganization-plan-view';
+
+export interface FolderSelectionByKindResponse {
+    'plan'?: ReorganizationPlanView;
+    'classifiedNow'?: number;
+    'unclassified'?: number;
+    'classifier'?: string;
+}
+

package/models/index.ts

@@ -84,6 +84,8 @@ export * from './filing-rule-view';
 export * from './filter-input';
 export * from './folder-element-info';
 export * from './folder-response';
+export * from './folder-selection-by-kind-request';
+export * from './folder-selection-by-kind-response';
 export * from './foreign-item';
 export * from './ingestion-status-dto';
 export * from './insight-backfill-request';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openfilz-sdk/typescript-ee",
-  "version": "1.12.10",
+  "version": "1.12.11",
   "description": "OpenAPI client for @openfilz-sdk/typescript-ee",
   "author": "OpenAPI-Generator Contributors",
   "repository": {