@tstdl/base 0.92.142 → 0.92.143

package/document-management/server/services/document-management-ai.service.js

@@ -68,19 +68,21 @@ import { arrayAgg } from '../../../orm/index.js';
 import { injectRepository } from '../../../orm/server/index.js';
 import { array, boolean, enumeration, integer, nullable, number, object, string } from '../../../schema/index.js';
 import { distinct } from '../../../utils/array/index.js';
-import { dateObjectToNumericDate, numericDateToDateObject } from '../../../utils/date-time.js';
+import { numericDateToDateObject, tryDateObjectToNumericDate } from '../../../utils/date-time.js';
 import { fromEntries, objectEntries } from '../../../utils/object/object.js';
 import { assertDefined, assertDefinedPass, assertNotNull, isNotNull, isNull, isUndefined } from '../../../utils/type-guards.js';
 import { Document, DocumentProperty, DocumentRequestState, DocumentTypeProperty } from '../../models/index.js';
 import { documentCategory, documentRequest, documentRequestCollectionAssignment, documentType } from '../schemas.js';
 import { DocumentCategoryTypeService } from './document-category-type.service.js';
+import { DocumentCollectionService } from './document-collection.service.js';
 import { DocumentFileService } from './document-file.service.js';
-import { DocumentManagementAncillaryService } from './document-management-ancillary.service.js';
 import { DocumentPropertyService } from './document-property.service.js';
+import { DocumentTagService } from './document-tag.service.js';
 import { DocumentManagementSingleton } from './singleton.js';
 const MODEL = 'gemini-2.5-flash-preview-05-20';
 let DocumentManagementAiService = DocumentManagementAiService_1 = class DocumentManagementAiService {
-    #documentManagementAncillaryService = inject(DocumentManagementAncillaryService);
+    #documentCollectionService = inject(DocumentCollectionService);
+    #documentTagService = inject(DocumentTagService);
     #documentCategoryTypeService = inject(DocumentCategoryTypeService);
     #documentFileService = inject(DocumentFileService);
     #documentPropertyService = inject(DocumentPropertyService);
@@ -89,14 +91,14 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
     #documentRepository = injectRepository(Document);
     #documentTypePropertyRepository = injectRepository(DocumentTypeProperty);
     #logger = inject(Logger, DocumentManagementAiService_1.name);
-    async classifyDocumentType(documentId) {
+    async classifyDocumentType(tenantId, documentId) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const document = await this.#documentRepository.load(documentId);
-            const fileContentStream = this.#documentFileService.getContentStream(document.id);
+            const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+            const fileContentStream = this.#documentFileService.getContentStream(document);
             const tmpFile = __addDisposableResource(env_1, await TemporaryFile.from(fileContentStream), true);
             const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
-            const categories = await this.#documentCategoryTypeService.loadCategoryViews();
+            const categories = await this.#documentCategoryTypeService.loadCategoryViews(tenantId);
             const typeLabelEntries = getDescriptiveTypeLabels(categories);
             const typeLabels = typeLabelEntries.map(({ label }) => label);
             this.#logger.trace(`Classifying document ${document.id}`);
@@ -136,19 +138,20 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
                 await result_1;
         }
     }
-    async extractDocumentInformation(documentId) {
+    async extractDocumentInformation(tenantId, documentId) {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
-            const document = await this.#documentRepository.load(documentId);
-            const fileContentStream = this.#documentFileService.getContentStream(document.id);
+            const document = await this.#documentRepository.loadByQuery({ tenantId, id: documentId });
+            const existingTags = await this.#documentTagService.loadTags(tenantId);
+            const fileContentStream = this.#documentFileService.getContentStream(document);
             const tmpFile = __addDisposableResource(env_2, await TemporaryFile.from(fileContentStream), true);
             const filePart = await this.#aiService.processFile({ path: tmpFile.path, mimeType: document.mimeType });
             if (isNull(document.typeId)) {
                 throw new Error(`Document ${document.id} has no type`);
             }
-            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ typeId: document.typeId });
+            const typeProperties = await this.#documentTypePropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, typeId: document.typeId });
             const propertyIds = typeProperties.map((property) => property.propertyId);
-            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ id: { $in: propertyIds } }) : undefined;
+            const properties = (propertyIds.length > 0) ? await this.#documentPropertyRepository.loadManyByQuery({ tenantId: { $or: [null, tenantId] }, id: { $in: propertyIds } }) : undefined;
             const propertiesSchemaEntries = properties?.map((property) => {
                 const schema = match(property.dataType)
                     .with('text', () => nullable(string()))
@@ -169,6 +172,7 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
                     ? {}
                     : { documentProperties: object(fromEntries(propertiesSchemaEntries)) }),
             });
+            const context = { existingTags };
             this.#logger.trace(`Extracting document ${document.id}`);
             const { json: extraction } = await this.#aiService.generate({
                 model: MODEL,
@@ -186,11 +190,15 @@ let DocumentManagementAiService = DocumentManagementAiService_1 = class Document
                         parts: [
                             { file: filePart.file },
                             {
-                                text: `Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
+                                text: `<context>
+${JSON.stringify(context, null, 2)}
+</context>
+              Extrahiere den Inhalt des Dokuments in das angegebenen JSON Schema.
 
 Vermeide es, den Titel im Untertitel zu wiederholen.
 Gib in der summary ausführlich an, welche Informationen in dem Dokument vorkommen (ohne konkrete Werte).
-Erstelle bis zu 7 möglichst spezifische Tags.
+Erstelle bis zu 5 Tags. Verwende vorhandene Tags, wenn sie passen. Erstelle neue Tags, wenn es keine passenden gibt.
+Vermeide es, den Titel oder Untertitel als Tag zu verwenden.
 Antworte auf deutsch.`,
                             },
                         ],
@@ -198,7 +206,7 @@ Antworte auf deutsch.`,
                 ],
             });
             const filteredDocumentTags = extraction.documentTags.filter((tag) => (tag != extraction.documentTitle) && (tag != extraction.documentSubtitle));
-            const date = isNotNull(extraction.documentDate) ? dateObjectToNumericDate(extraction.documentDate) : null;
+            const date = isNotNull(extraction.documentDate) ? tryAiOutputDateObjectToNumericDate(extraction.documentDate) : null;
             const parsedProperties = isUndefined(extraction.documentProperties)
                 ? []
                 : objectEntries(extraction.documentProperties)
@@ -208,8 +216,11 @@ Antworte auf deutsch.`,
                     }
                     const property = assertDefinedPass(properties?.find((property) => property.label == propertyLabel));
                     const value = match(rawValue)
-                        .with({ year: P.number }, (val) => dateObjectToNumericDate(val))
-                        .otherwise((val) => val);
+                        .with({ year: P.number }, (value) => tryAiOutputDateObjectToNumericDate(value))
+                        .otherwise((value) => value);
+                    if (isNull(value)) {
+                        return null;
+                    }
                     return { propertyId: property.id, dataType: property.dataType, value };
                 })
                     .filter(isNotNull);
@@ -232,15 +243,18 @@ Antworte auf deutsch.`,
                 await result_2;
         }
     }
-    async findSuitableCollectionsForDocument(documentId, collectionIds) {
-        const document = await this.#documentRepository.load(documentId);
+    async findSuitableCollectionsForDocument(document, collectionIds) {
         assertNotNull(document.typeId, 'Document has no type');
-        const documentProperties = await this.#documentPropertyService.loadDocumentProperties(documentId);
-        const collectionNamesMap = await this.#documentManagementAncillaryService.resolveMetadata(...collectionIds);
+        const [documentTags, documentProperties, collectionNamesMap] = await Promise.all([
+            this.#documentTagService.loadDocumentTags(document.tenantId, document.id),
+            this.#documentPropertyService.loadDocumentPropertyValues(document.tenantId, document.id),
+            this.#documentCollectionService.resolveMetadata(document.tenantId, collectionIds),
+        ]);
         const collections = collectionIds.map((collectionId, index) => ({
             id: collectionId,
             ...assertDefinedPass(collectionNamesMap[index]),
         }));
+        const documentTagLabels = documentTags.map((tag) => tag.label);
         const propertyEntries = documentProperties.map((property) => [property.label, property.value]);
         const context = {
             document: {
@@ -248,7 +262,7 @@ Antworte auf deutsch.`,
                 subtitle: document.subtitle ?? undefined,
                 date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
                 summary: document.summary ?? undefined,
-                tags: ((document.tags?.length ?? 0) > 0) ? document.tags : undefined,
+                tags: (documentTagLabels.length > 0) ? documentTagLabels : undefined,
                 properties: fromEntries(propertyEntries),
             },
             collections,
@@ -278,11 +292,11 @@ Ordne das Dokument unter "document" einer oder mehreren passenden Collection unt
         });
         return result.json.collectionIds;
     }
-    async findSuitableRequestForDocument(documentId, collectionIds) {
+    async findSuitableRequestForDocument(document, collectionIds) {
         const session = this.#documentPropertyRepository.session;
-        const document = await this.#documentRepository.load(documentId);
         assertNotNull(document.typeId, 'Document has no type');
-        const documentProperties = await this.#documentPropertyService.loadDocumentProperties(documentId);
+        const documentTags = await this.#documentTagService.loadDocumentTags(document.tenantId, document.id);
+        const documentProperties = await this.#documentPropertyService.loadDocumentPropertyValues(document.tenantId, document.id);
         const openRequestsWithoutDocument = await session
             .select({
             id: documentRequest.id,
@@ -295,10 +309,11 @@ Ordne das Dokument unter "document" einer oder mehreren passenden Collection unt
             .innerJoin(documentRequestCollectionAssignment, eq(documentRequestCollectionAssignment.requestId, documentRequest.id))
             .innerJoin(documentType, eq(documentType.id, documentRequest.typeId))
             .innerJoin(documentCategory, eq(documentCategory.id, documentType.categoryId))
-            .where(and(inArray(documentRequestCollectionAssignment.collectionId, collectionIds), eq(documentRequest.typeId, document.typeId), eq(documentRequest.state, DocumentRequestState.Open), drizzleIsNull(documentRequest.documentId)))
+            .where(and(eq(documentRequest.tenantId, document.tenantId), inArray(documentRequestCollectionAssignment.collectionId, collectionIds), eq(documentRequest.typeId, document.typeId), eq(documentRequest.state, DocumentRequestState.Open), drizzleIsNull(documentRequest.documentId)))
             .groupBy(documentRequest.id, documentCategory.label, documentType.label, documentRequest.comment);
+        const documentTagLabels = documentTags.map((tag) => tag.label);
         const requestsCollectionIds = distinct(openRequestsWithoutDocument.flatMap((request) => request.collectionIds));
-        const collectionNamesMap = await this.#documentManagementAncillaryService.resolveMetadataMap(...requestsCollectionIds);
+        const collectionNamesMap = await this.#documentCollectionService.resolveMetadataMap(document.tenantId, requestsCollectionIds);
         const requests = openRequestsWithoutDocument.map((request) => ({
             id: request.id,
             collections: request.collectionIds.map((collectionId) => assertDefinedPass(collectionNamesMap[collectionId]).name),
@@ -311,7 +326,7 @@ Ordne das Dokument unter "document" einer oder mehreren passenden Collection unt
                 subtitle: document.subtitle ?? undefined,
                 date: isNotNull(document.date) ? numericDateToDateObject(document.date) : undefined,
                 summary: document.summary ?? undefined,
-                tags: ((document.tags?.length ?? 0) > 0) ? document.tags : undefined,
+                tags: (documentTagLabels.length > 0) ? documentTagLabels : undefined,
                 properties: fromEntries(propertyEntries),
             },
             requests,
@@ -352,3 +367,11 @@ function getDescriptiveTypeLabels(categories, prefix = 'Category: ') {
         ...getDescriptiveTypeLabels(category.children, `${prefix}${category.label} -> `),
     ]);
 }
+function tryAiOutputDateObjectToNumericDate(dateObject) {
+    const date = tryDateObjectToNumericDate(dateObject);
+    if (isNull(date)) {
+        // try to interpret the date with swapped month and day
+        return tryDateObjectToNumericDate({ ...dateObject, month: dateObject.day, day: dateObject.month });
+    }
+    return date;
+}

package/document-management/server/services/document-management-ancillary.service.d.ts

@@ -1,28 +1,10 @@
-import { DocumentCollection } from '../../models/index.js';
-export type DocumentCollectionMetadata = {
-    /**
-     * User-friendly name of the collection
-     * @example <name of person>
-     * @example <address of real estate>
-     */
-    name: string;
-    /**
-     * Group of the collection, used to group multiple collections to the same "type"
-     * @example 'Applicants'
-     * @example 'Real estates'
-     */
-    group: string | null;
-};
+import type { DocumentCollectionMetadata } from '../../../document-management/service-models/index.js';
+import type { DocumentCollection } from '../../models/index.js';
 export declare abstract class DocumentManagementAncillaryService {
-    #private;
-    resolveMetadata<const T extends (DocumentCollection | string)[]>(...collectionsOrIds: T): Promise<{
-        [K in keyof T]: DocumentCollectionMetadata;
-    }>;
-    resolveMetadataMap(...collectionsOrIds: (DocumentCollection | string)[]): Promise<Record<string, DocumentCollectionMetadata>>;
     /**
      * Resolves application-specific metadata for a list of document collections.
      * @param collections An array of DocumentCollection entities.
      * @returns A promise that resolves to an array of DocumentCollectionMetadata, corresponding to the input collections.
      */
-    abstract _resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
+    abstract resolveMetadata(collections: DocumentCollection[]): DocumentCollectionMetadata[] | Promise<DocumentCollectionMetadata[]>;
 }

package/document-management/server/services/document-management-ancillary.service.js

@@ -1,26 +1,2 @@
-import { injectRepository } from '../../../orm/server/index.js';
-import { fromEntries } from '../../../utils/object/index.js';
-import { assertDefinedPass, isString } from '../../../utils/type-guards.js';
-import { DocumentCollection } from '../../models/index.js';
 export class DocumentManagementAncillaryService {
-    #documentCollectionRepository = injectRepository(DocumentCollection);
-    async resolveMetadata(...collectionsOrIds) {
-        if (collectionsOrIds.length == 0) {
-            return [];
-        }
-        const loadIds = collectionsOrIds.filter((collection) => isString(collection));
-        if (loadIds.length == 0) {
-            return this._resolveMetadata(collectionsOrIds);
-        }
-        const loadedCollections = await this.#documentCollectionRepository.loadManyByQuery({ id: { $in: loadIds } });
-        const collections = collectionsOrIds.map((collectionOrId) => isString(collectionOrId)
-            ? assertDefinedPass(loadedCollections.find((collection) => collection.id == collectionOrId), `Could not load collection "${collectionOrId}".`)
-            : collectionOrId);
-        return this._resolveMetadata(collections);
-    }
-    async resolveMetadataMap(...collectionsOrIds) {
-        const names = await this.resolveMetadata(...collectionsOrIds);
-        const entries = collectionsOrIds.map((collectionOrId, index) => [isString(collectionOrId) ? collectionOrId : collectionOrId.id, names[index]]);
-        return fromEntries(entries);
-    }
 }

package/document-management/server/services/document-management-observation.service.d.ts

@@ -0,0 +1,15 @@
+import { afterResolve } from '../../../injector/interfaces.js';
+import { MessageBus } from '../../../message-bus/message-bus.js';
+import { Database, type PgTransaction, type Transaction } from '../../../orm/server/index.js';
+import type { OneOrMany } from '../../../types.js';
+export declare class DocumentManagementObservationService {
+    #private;
+    readonly collectionsChangedMessageBus: MessageBus<string[]>;
+    [afterResolve](): void;
+    collectionChange(ids: OneOrMany<string>, transactionOrSession?: Transaction | Database | PgTransaction): void;
+    documentChange(ids: OneOrMany<string>, transactionOrSession?: Transaction | Database | PgTransaction): void;
+    workflowChange(ids: OneOrMany<string>, transactionOrSession?: Transaction | Database | PgTransaction): void;
+    requestChange(ids: OneOrMany<string>, transactionOrSession?: Transaction | Database | PgTransaction): void;
+    private notifyLoop;
+    private notify;
+}

package/document-management/server/services/document-management-observation.service.js

@@ -0,0 +1,160 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var _a;
+var DocumentManagementObservationService_1;
+import { eq, inArray } from 'drizzle-orm';
+import { union } from 'drizzle-orm/pg-core';
+import { CancellationSignal } from '../../../cancellation/token.js';
+import { inject } from '../../../injector/inject.js';
+import { afterResolve } from '../../../injector/interfaces.js';
+import { Logger } from '../../../logger/logger.js';
+import { MessageBus } from '../../../message-bus/message-bus.js';
+import { Database, tryGetTstdlTransaction } from '../../../orm/server/index.js';
+import { toArray } from '../../../utils/array/index.js';
+import { cancelableTimeout } from '../../../utils/timing.js';
+import { isDefined } from '../../../utils/type-guards.js';
+import { documentAssignmentScope, documentAssignmentTask, documentCollectionAssignment, documentRequestCollectionAssignment, documentWorkflow } from '../schemas.js';
+import { DocumentManagementSingleton } from './singleton.js';
+let DocumentManagementObservationService = DocumentManagementObservationService_1 = class DocumentManagementObservationService {
+    #database = inject(Database);
+    #cancellationSignal = inject(CancellationSignal);
+    #logger = inject(Logger, DocumentManagementObservationService_1.name);
+    #collectionIds = new Set();
+    #documentIds = new Set();
+    #workflowIds = new Set();
+    #requestIds = new Set();
+    collectionsChangedMessageBus = inject((MessageBus), 'DocumentManagementObservation:collectionsChanged');
+    [afterResolve]() {
+        this.notifyLoop();
+    }
+    collectionChange(ids, transactionOrSession) {
+        const transaction = tryGetTstdlTransaction(transactionOrSession);
+        if (isDefined(transaction)) {
+            transaction.afterCommit$.subscribe(() => this.collectionChange(ids));
+        }
+        else {
+            for (const id of toArray(ids)) {
+                this.#collectionIds.add(id);
+            }
+        }
+    }
+    documentChange(ids, transactionOrSession) {
+        const transaction = tryGetTstdlTransaction(transactionOrSession);
+        if (isDefined(transaction)) {
+            transaction.afterCommit$.subscribe(() => this.documentChange(ids));
+        }
+        else {
+            for (const id of toArray(ids)) {
+                this.#documentIds.add(id);
+            }
+        }
+    }
+    workflowChange(ids, transactionOrSession) {
+        const transaction = tryGetTstdlTransaction(transactionOrSession);
+        if (isDefined(transaction)) {
+            transaction.afterCommit$.subscribe(() => this.workflowChange(ids));
+        }
+        else {
+            for (const id of toArray(ids)) {
+                this.#workflowIds.add(id);
+            }
+        }
+    }
+    requestChange(ids, transactionOrSession) {
+        const transaction = tryGetTstdlTransaction(transactionOrSession);
+        if (isDefined(transaction)) {
+            transaction.afterCommit$.subscribe(() => this.requestChange(ids));
+        }
+        else {
+            for (const id of toArray(ids)) {
+                this.#requestIds.add(id);
+            }
+        }
+    }
+    notifyLoop() {
+        void (async () => {
+            while (this.#cancellationSignal.isUnset) {
+                try {
+                    if ((this.#collectionIds.size + this.#documentIds.size + this.#workflowIds.size + this.#requestIds.size) > 0) {
+                        const timeoutResult = await cancelableTimeout(50, this.#cancellationSignal);
+                        if (timeoutResult == 'canceled') {
+                            break;
+                        }
+                        await this.notify();
+                    }
+                }
+                catch (error) {
+                    this.#logger.error(error);
+                    await cancelableTimeout(2500, this.#cancellationSignal);
+                }
+                finally {
+                    await cancelableTimeout(100, this.#cancellationSignal);
+                }
+            }
+        })();
+    }
+    async notify() {
+        const collectionIds = Array.from(this.#collectionIds);
+        const documentIds = Array.from(this.#documentIds);
+        const workflowIds = Array.from(this.#workflowIds);
+        const requestIds = Array.from(this.#requestIds);
+        this.#collectionIds.clear();
+        this.#documentIds.clear();
+        this.#workflowIds.clear();
+        this.#requestIds.clear();
+        try {
+            const documentCollectionIds = this.#database
+                .selectDistinct({ collectionId: documentCollectionAssignment.collectionId })
+                .from(documentCollectionAssignment)
+                .where(inArray(documentCollectionAssignment.documentId, documentIds));
+            const documentAssignmentTaskCollectionIds = this.#database
+                .selectDistinct({ collectionId: documentAssignmentScope.collectionId })
+                .from(documentAssignmentTask)
+                .innerJoin(documentAssignmentScope, eq(documentAssignmentScope.taskId, documentAssignmentTask.id))
+                .where(inArray(documentAssignmentTask.documentId, documentIds));
+            const workflowDocumentCollectionIds = this.#database
+                .selectDistinct({ collectionId: documentCollectionAssignment.collectionId })
+                .from(documentWorkflow)
+                .innerJoin(documentCollectionAssignment, eq(documentCollectionAssignment.documentId, documentWorkflow.documentId))
+                .where(inArray(documentWorkflow.id, workflowIds));
+            const workflowDocumentAssignmentTaskCollectionIds = this.#database
+                .selectDistinct({ collectionId: documentAssignmentScope.collectionId })
+                .from(documentWorkflow)
+                .innerJoin(documentAssignmentTask, eq(documentAssignmentTask.documentId, documentWorkflow.documentId))
+                .innerJoin(documentAssignmentScope, eq(documentAssignmentScope.taskId, documentAssignmentTask.id))
+                .where(inArray(documentWorkflow.id, workflowIds));
+            const requestCollectionIds = this.#database
+                .selectDistinct({ collectionId: documentRequestCollectionAssignment.collectionId })
+                .from(documentRequestCollectionAssignment)
+                .where(inArray(documentRequestCollectionAssignment.requestId, requestIds));
+            const result = await union(documentCollectionIds, documentAssignmentTaskCollectionIds, workflowDocumentCollectionIds, workflowDocumentAssignmentTaskCollectionIds, requestCollectionIds);
+            const allCollectionIds = result.map((row) => row.collectionId);
+            if (allCollectionIds.length > 0) {
+                await this.collectionsChangedMessageBus.publish(allCollectionIds);
+            }
+        }
+        catch (error) {
+            for (const collectionId of collectionIds) {
+                this.#collectionIds.add(collectionId);
+            }
+            for (const documentId of documentIds) {
+                this.#documentIds.add(documentId);
+            }
+            for (const workflowId of workflowIds) {
+                this.#workflowIds.add(workflowId);
+            }
+            for (const requestId of requestIds) {
+                this.#requestIds.add(requestId);
+            }
+            throw error;
+        }
+    }
+};
+DocumentManagementObservationService = DocumentManagementObservationService_1 = __decorate([
+    DocumentManagementSingleton()
+], DocumentManagementObservationService);
+export { DocumentManagementObservationService };

package/document-management/server/services/document-management.service.d.ts

@@ -1,3 +1,4 @@
+import type { CancellationSignal } from '../../../cancellation/token.js';
 import { Transactional } from '../../../orm/server/index.js';
 import type { Record } from '../../../types.js';
 import { DocumentCategory, DocumentType, type DocumentProperty, type DocumentPropertyDataType } from '../../models/index.js';
@@ -9,11 +10,11 @@ export declare class DocumentManagementService extends Transactional {
      * This method is used to determine which collections a document is associated with, either directly or through requests and assignments.
      * @param documentId The ID of the document to retrieve collection IDs for.
      */
-    getRelevantDocumentCollectionIds(documentId: string): Promise<string[]>;
-    loadDataStream(collectionIds: string[]): ReadableStream<DocumentManagementData>;
-    loadData(collectionIds: string[]): Promise<DocumentManagementData>;
-    loadDocumentRequestsTemplateData(): Promise<DocumentRequestsTemplateData>;
-    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(categoryLabels: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeLabels: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>, propertyKeys: Record<DocumentPropertyKey, [DocumentPropertyDataType, string]>, typeProperties: Record<TypeKey, DocumentPropertyKey[]>): Promise<{
+    getRelevantDocumentCollectionIds(tenantId: string, documentId: string): Promise<string[]>;
+    loadDataStream(tenantId: string, collectionIds: string[], cancellationSignal: CancellationSignal): AsyncIterableIterator<DocumentManagementData>;
+    loadData(tenantId: string, collectionIds: string[]): Promise<DocumentManagementData>;
+    loadDocumentRequestsTemplateData(tenantId: string | null): Promise<DocumentRequestsTemplateData>;
+    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(tenantId: string | null, categoryLabels: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeLabels: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>, propertyKeys: Record<DocumentPropertyKey, [DocumentPropertyDataType, string]>, typeProperties: Record<TypeKey, DocumentPropertyKey[]>): Promise<{
         categories: Record<CategoryKey, DocumentCategory>;
         types: Record<TypeKey, DocumentType>;
         properties: Record<DocumentPropertyKey, DocumentProperty>;