@tstdl/base 0.92.122 → 0.92.124

package/types/document-management/models/service-models/enriched/enriched-document-category.view.d.ts

@@ -0,0 +1,13 @@
+import type { DocumentCategory } from '../../document-category.model.js';
+import { EnrichedDocumentType } from './enriched-document-type.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+export declare class EnrichedDocumentCategory implements Pick<DocumentCategory, 'id' | 'label'> {
+    #private;
+    readonly id: string;
+    readonly label: string;
+    readonly parent: EnrichedDocumentCategory | null;
+    get children(): EnrichedDocumentCategory[];
+    get childrenDeep(): EnrichedDocumentCategory[];
+    get types(): EnrichedDocumentType[];
+    constructor(data: EnrichedDocumentManagementData, category: DocumentCategory, parent: EnrichedDocumentCategory | null);
+}

package/types/document-management/models/service-models/enriched/enriched-document-collection.view.d.ts

@@ -0,0 +1,22 @@
+import type { TypedOmit } from '../../../../../types.js';
+import type { DocumentCollectionView } from '../document-management.view-model.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+import { type RequestsStats } from './enriched.js';
+export declare class EnrichedDocumentCollection implements TypedOmit<DocumentCollectionView, 'parentId' | 'metadata'> {
+    #private;
+    readonly id: string;
+    readonly name: string;
+    readonly group: string | null;
+    readonly parent: EnrichedDocumentCollection | null;
+    get children(): EnrichedDocumentCollection[];
+    get childrenDeep(): EnrichedDocumentCollection[];
+    get documents(): EnrichedDocument[];
+    get documentsDeep(): EnrichedDocument[];
+    get requests(): EnrichedDocumentRequest[];
+    get requestsDeep(): EnrichedDocumentRequest[];
+    get requestsStats(): RequestsStats;
+    get requestsStatsDeep(): RequestsStats;
+    constructor(data: EnrichedDocumentManagementData, collectionView: DocumentCollectionView, parent: EnrichedDocumentCollection | null);
+}

package/types/document-management/models/service-models/enriched/enriched-document-file.view.d.ts

@@ -0,0 +1,12 @@
+import type { TypedOmit } from '../../../../../types.js';
+import type { DocumentFile } from '../../document-file.model.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+export declare class EnrichedDocumentFile implements TypedOmit<DocumentFile, 'metadata'> {
+    readonly id: string;
+    readonly originalFileName: string | null;
+    readonly mimeType: string;
+    readonly hash: string;
+    readonly size: number;
+    readonly document: EnrichedDocument;
+    constructor(file: DocumentFile, document: EnrichedDocument);
+}

package/types/document-management/models/service-models/enriched/enriched-document-management-data.view.d.ts

@@ -0,0 +1,41 @@
+import type { DocumentManagementData } from '../document-management.view-model.js';
+import { EnrichedDocumentCategory } from './enriched-document-category.view.js';
+import { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+import type { EnrichedDocumentType } from './enriched-document-type.view.js';
+import { EnrichedDocument } from './enriched-document.view.js';
+import { type RequestsStats } from './enriched.js';
+export declare class EnrichedCollectionsGroup {
+    readonly group: string | null;
+    readonly collections: EnrichedDocumentCollection[];
+    get requestsStats(): RequestsStats;
+    constructor(group: string | null, collections: EnrichedDocumentCollection[]);
+}
+export declare class EnrichedDocumentManagementData {
+    readonly rawData: DocumentManagementData;
+    readonly rawDataMaps: {
+        collections: Map<string, import("../document-management.view-model.js").DocumentCollectionView>;
+        documents: Map<string, import("../document-management.view-model.js").DocumentView>;
+        requests: Map<string, import("../document-management.view-model.js").DocumentRequestView>;
+        files: Map<string, import("../../document-file.model.js").DocumentFile>;
+        categories: Map<string, import("../../document-category.model.js").DocumentCategory>;
+        types: Map<string, import("../../document-type.model.js").DocumentType>;
+    };
+    readonly maps: {
+        collections: Map<string, EnrichedDocumentCollection>;
+        documents: Map<string, EnrichedDocument>;
+        requests: Map<string, EnrichedDocumentRequest>;
+        categories: Map<string, EnrichedDocumentCategory>;
+        types: Map<string, EnrichedDocumentType>;
+    };
+    get rootCollections(): EnrichedDocumentCollection[];
+    get collections(): EnrichedDocumentCollection[];
+    get groupedCollections(): EnrichedCollectionsGroup[];
+    get documents(): EnrichedDocument[];
+    get requests(): EnrichedDocumentRequest[];
+    get rootCategories(): EnrichedDocumentCategory[];
+    get categories(): EnrichedDocumentCategory[];
+    get types(): EnrichedDocumentType[];
+    get requestsStats(): RequestsStats;
+    constructor(data: DocumentManagementData);
+}

package/types/document-management/models/service-models/enriched/enriched-document-request.view.d.ts

@@ -0,0 +1,17 @@
+import type { TypedOmit } from '../../../../../types.js';
+import type { DocumentRequestState } from '../../document-request.model.js';
+import type { DocumentRequestView } from '../document-management.view-model.js';
+import type { EnrichedDocumentCollection } from './enriched-document-collection.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentType } from './enriched-document-type.view.js';
+import type { EnrichedDocument } from './enriched-document.view.js';
+export declare class EnrichedDocumentRequest implements TypedOmit<DocumentRequestView, 'typeId' | 'documentId' | 'document' | 'collectionIds' | 'metadata'> {
+    #private;
+    readonly id: string;
+    readonly comment: string | null;
+    readonly state: DocumentRequestState;
+    get type(): EnrichedDocumentType;
+    get document(): EnrichedDocument | null;
+    get collections(): EnrichedDocumentCollection[];
+    constructor(data: EnrichedDocumentManagementData, request: DocumentRequestView);
+}

package/types/document-management/models/service-models/enriched/enriched-document-type.view.d.ts

@@ -0,0 +1,9 @@
+import type { TypedOmit } from '../../../../../types.js';
+import type { DocumentType } from '../../document-type.model.js';
+import type { EnrichedDocumentCategory } from './enriched-document-category.view.js';
+export declare class EnrichedDocumentType implements TypedOmit<DocumentType, 'categoryId' | 'metadata'> {
+    readonly id: string;
+    readonly label: string;
+    readonly category: EnrichedDocumentCategory;
+    constructor(type: DocumentType, category: EnrichedDocumentCategory);
+}

package/types/document-management/models/service-models/enriched/enriched-document.view.d.ts

@@ -0,0 +1,28 @@
+import type { TypedOmit } from '../../../../../types.js';
+import type { DocumentValidationExecution } from '../../document-validation-execution.model.js';
+import type { DocumentWorkflow } from '../../document-workflow.model.js';
+import type { DocumentApproval } from '../../document.model.js';
+import type { DocumentPropertyValueView, DocumentView } from '../document-management.view-model.js';
+import { EnrichedDocumentAssignment } from './enriched-document-assignment.view.js';
+import { EnrichedDocumentFile } from './enriched-document-file.view.js';
+import type { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentType } from './enriched-document-type.view.js';
+export declare class EnrichedDocument implements TypedOmit<DocumentView, 'typeId' | 'fileId' | 'collectionAssignments' | 'createUserId' | 'metadata'> {
+    #private;
+    readonly id: string;
+    readonly title: string | null;
+    readonly subtitle: string | null;
+    readonly pages: number | null;
+    readonly date: number | null;
+    readonly summary: string | null;
+    readonly tags: string[] | null;
+    readonly approval: DocumentApproval;
+    readonly comment: string | null;
+    readonly properties: DocumentPropertyValueView[];
+    readonly currentWorkflow: DocumentWorkflow | null;
+    readonly validations: DocumentValidationExecution[] | null;
+    get type(): EnrichedDocumentType | null;
+    get file(): EnrichedDocumentFile;
+    get assignments(): EnrichedDocumentAssignment[];
+    constructor(data: EnrichedDocumentManagementData, document: DocumentView);
+}

package/types/document-management/models/service-models/enriched/enriched.d.ts

@@ -0,0 +1,18 @@
+import type { DocumentManagementData, DocumentRequestView } from '../document-management.view-model.js';
+import { EnrichedDocumentManagementData } from './enriched-document-management-data.view.js';
+import type { EnrichedDocumentRequest } from './enriched-document-request.view.js';
+export type RequestsStats = {
+    /** Open without document */
+    open: number;
+    /** Open with pending approval */
+    pending: number;
+    /** Closed without document */
+    closed: number;
+    /** Closed with rejected document */
+    rejected: number;
+    /** Fulfilled with approved document */
+    fulfilled: number;
+};
+export declare function toEnrichedDocumentManagementData(data: DocumentManagementData): EnrichedDocumentManagementData;
+export declare function calculateRequestsStats(requests: Iterable<DocumentRequestView | EnrichedDocumentRequest>): RequestsStats;
+export declare function mergeRequestsStats(stats: Iterable<RequestsStats>): RequestsStats;

package/types/document-management/models/service-models/enriched/index.d.ts

@@ -0,0 +1,9 @@
+export * from './enriched-document-assignment.view.js';
+export * from './enriched-document-category.view.js';
+export * from './enriched-document-collection.view.js';
+export * from './enriched-document-file.view.js';
+export * from './enriched-document-management-data.view.js';
+export * from './enriched-document-request.view.js';
+export * from './enriched-document-type.view.js';
+export * from './enriched-document.view.js';
+export * from './enriched.js';

package/types/document-management/models/service-models/index.d.ts

@@ -0,0 +1,8 @@
+export * from './categories-and-types.view-model.js';
+export * from './document-folders.view-model.js';
+export * from './document-requests-template.view-model.js';
+export * from './document.service-model.js';
+export * from './document-management.view-model.js';
+export * from './enriched/index.js';
+export * from './normalized-requests-template-data.model.js';
+export * from './stats.view-model.js';

package/types/document-management/models/service-models/normalized-requests-template-data.model.d.ts

@@ -0,0 +1,18 @@
+import type { TypedOmit } from '../../../../types.js';
+import type { DocumentRequestTemplate } from '../document-request-template.js';
+import type { DocumentRequestsTemplateData, DocumentRequestsTemplateView } from './document-requests-template.view-model.js';
+import type { EnrichedDocumentCategory } from './enriched/enriched-document-category.view.js';
+import type { EnrichedDocumentManagementData } from './enriched/enriched-document-management-data.view.js';
+import type { EnrichedDocumentType } from './enriched/enriched-document-type.view.js';
+export type EnrichedDocumentRequestsTemplateData = TypedOmit<DocumentRequestsTemplateData, 'templates'> & {
+    templates: EnrichedDocumentRequestsTemplateView[];
+    categories: EnrichedDocumentCategory[];
+    types: EnrichedDocumentType[];
+};
+export type EnrichedDocumentRequestsTemplateView = TypedOmit<DocumentRequestsTemplateView, 'requestTemplates'> & {
+    requestTemplates: EnrichedDocumentRequestTemplate[];
+};
+export type EnrichedDocumentRequestTemplate = TypedOmit<DocumentRequestTemplate, 'typeId'> & {
+    type: EnrichedDocumentType;
+};
+export declare function toEnrichedDocumentRequestsTemplateData(templateData: DocumentRequestsTemplateData, documentManagementData: EnrichedDocumentManagementData): EnrichedDocumentRequestsTemplateData;

package/types/document-management/models/service-models/stats.view-model.d.ts

@@ -0,0 +1,8 @@
+export declare class RequestStats {
+    total: number;
+    documentPending: number;
+    approvalPending: number;
+    approvals: number;
+    rejections: number;
+    closedWithoutDocument: number;
+}

package/types/document-management/server/module.d.ts

@@ -0,0 +1,12 @@
+import './schemas.js';
+import { type InjectionToken } from '../../../injector/index.js';
+import type { DatabaseConfig } from '../../../orm/server/module.js';
+import { DocumentManagementAncillaryService } from './services/document-management-ancillary.service.js';
+export declare class DocumentManagementConfig {
+    ancillaryService: InjectionToken<DocumentManagementAncillaryService>;
+    fileObjectStorageModule: string;
+    filePreviewObjectStorageModule: string;
+    database?: DatabaseConfig;
+}
+export declare function configureDocumentManagement(config: DocumentManagementConfig): void;
+export declare function migrateDocumentManagementSchema(): Promise<void>;

package/types/document-management/server/schemas.d.ts

@@ -0,0 +1,31 @@
+import { Document, DocumentAssignmentScope, DocumentAssignmentTask, DocumentCategory, DocumentCollection, DocumentCollectionAssignment, DocumentFile, DocumentProperty, DocumentPropertyValue, DocumentRequest, DocumentRequestCollection, DocumentRequestsTemplate, DocumentRequestSubmission, DocumentRequestTemplate, DocumentType, DocumentTypeProperty, DocumentTypeValidation, DocumentValidationDefinition, DocumentValidationExecution, DocumentValidationExecutionRelatedDocument, DocumentWorkflow } from '../models/index.js';
+export declare const documentManagementSchema: import("../../../orm/server/database-schema.js").DatabaseSchema<"document_management">;
+export declare const aocumentApproval: import("drizzle-orm/pg-core").PgEnum<["pending", "approved", "rejected"]>;
+export declare const documentAssignmentCollectionTarget: import("drizzle-orm/pg-core").PgEnum<["request", "collection"]>;
+export declare const documentPropertyDataType: import("drizzle-orm/pg-core").PgEnum<["boolean", "date", "decimal", "text", "integer"]>;
+export declare const documentRequestState: import("drizzle-orm/pg-core").PgEnum<["open", "closed", "fulfilled"]>;
+export declare const documentValidationExecutionState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed"]>;
+export declare const documentValidationResultStatus: import("drizzle-orm/pg-core").PgEnum<["warning", "failed", "passed"]>;
+export declare const documentWorkflowState: import("drizzle-orm/pg-core").PgEnum<["pending", "error", "running", "completed", "failed"]>;
+export declare const documentWorkflowStep: import("drizzle-orm/pg-core").PgEnum<["classification", "extraction", "assignment", "validation"]>;
+export declare const document: import("../../orm/server/types.js").PgTableFromType<typeof Document, "document_management">;
+export declare const documentAssignmentScope: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentScope, "document_management">;
+export declare const documentAssignmentTask: import("../../orm/server/types.js").PgTableFromType<typeof DocumentAssignmentTask, "document_management">;
+export declare const documentCategory: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCategory, "document_management">;
+export declare const documentCollection: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCollection, "document_management">;
+export declare const documentCollectionAssignment: import("../../orm/server/types.js").PgTableFromType<typeof DocumentCollectionAssignment, "document_management">;
+export declare const documentFile: import("../../orm/server/types.js").PgTableFromType<typeof DocumentFile, "document_management">;
+export declare const documentProperty: import("../../orm/server/types.js").PgTableFromType<typeof DocumentProperty, "document_management">;
+export declare const documentPropertyValue: import("../../orm/server/types.js").PgTableFromType<typeof DocumentPropertyValue, "document_management">;
+export declare const documentRequest: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequest, "document_management">;
+export declare const documentRequestCollection: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestCollection, "document_management">;
+export declare const documentRequestsTemplate: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestsTemplate, "document_management">;
+export declare const documentRequestSubmission: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestSubmission, "document_management">;
+export declare const documentRequestTemplate: import("../../orm/server/types.js").PgTableFromType<typeof DocumentRequestTemplate, "document_management">;
+export declare const documentType: import("../../orm/server/types.js").PgTableFromType<typeof DocumentType, "document_management">;
+export declare const documentTypeProperty: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTypeProperty, "document_management">;
+export declare const documentTypeValidation: import("../../orm/server/types.js").PgTableFromType<typeof DocumentTypeValidation, "document_management">;
+export declare const documentValidationDefinition: import("../../orm/server/types.js").PgTableFromType<typeof DocumentValidationDefinition, "document_management">;
+export declare const documentValidationExecution: import("../../orm/server/types.js").PgTableFromType<typeof DocumentValidationExecution, "document_management">;
+export declare const documentValidationExecutionRelatedDocument: import("../../orm/server/types.js").PgTableFromType<typeof DocumentValidationExecutionRelatedDocument, "document_management">;
+export declare const documentWorkflow: import("../../orm/server/types.js").PgTableFromType<typeof DocumentWorkflow, "document_management">;

package/types/document-management/server/services/document-category-type.service.d.ts

@@ -0,0 +1,25 @@
+import { DocumentCategory, DocumentType } from '../../../../document-management/models/index.js';
+import type { DocumentCategoryView } from '../../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../../orm/server/index.js';
+export declare const enumTypeKey = "enum-type";
+export declare class DocumentCategoryTypeService extends Transactional {
+    #private;
+    loadCategory(id: string): Promise<DocumentCategory>;
+    loadType(id: string): Promise<DocumentType>;
+    createCategory(label: string, parentId: string | null, enumKey?: string): Promise<DocumentCategory>;
+    createType(label: string, categoryId: string, enumKey?: string): Promise<DocumentType>;
+    updateCategory(id: string, update: {
+        label?: string;
+        parentId?: string | null;
+    }): Promise<DocumentCategory>;
+    updateType(id: string, update: {
+        label?: string;
+        categoryId?: string;
+    }): Promise<DocumentType>;
+    loadCategoryGraph(categoryId: string): Promise<DocumentCategory[]>;
+    loadCategoriesAndTypes(): Promise<{
+        categories: DocumentCategory[];
+        types: DocumentType[];
+    }>;
+    loadCategoryViews(): Promise<DocumentCategoryView[]>;
+}

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

@@ -0,0 +1,13 @@
+import { type Query } from '../../../../orm/index.js';
+import { Transactional } from '../../../../orm/server/index.js';
+import type { OneOrMany } from '../../../../types.js';
+import { Document, DocumentCollection } from '../../models/index.js';
+export declare class DocumentCollectionService extends Transactional {
+    #private;
+    readonly repository: import("../../../../orm/server/repository.js").EntityRepository<DocumentCollection>;
+    loadCollectionGraph(collectionId: string): Promise<DocumentCollection[]>;
+    createCollection(parentId: string | null): Promise<DocumentCollection>;
+    collectionHasDocumentByFilter(collectionId: string, filter: Query<Document>): Promise<boolean>;
+    assignDocument(documentId: string, collectionIds: OneOrMany<string>): Promise<void>;
+    archiveDocument(documentId: string, collectionIds: OneOrMany<string>): Promise<void>;
+}

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

@@ -0,0 +1,17 @@
+import type { FileContentPart } from '../../../../ai/types.js';
+import { Transactional } from '../../../../orm/server/index.js';
+import { DocumentFile } from '../../models/index.js';
+export declare class DocumentFileService extends Transactional {
+    #private;
+    load(id: string): Promise<DocumentFile>;
+    create(content: Uint8Array | ReadableStream<Uint8Array>, originalFileName: string | null): Promise<DocumentFile>;
+    getContent(fileId: string): Promise<Uint8Array>;
+    getContentStream(fileId: string): ReadableStream<Uint8Array>;
+    getContentUrl(fileId: string, title: string | null, download?: boolean): Promise<string>;
+    getPreview(fileId: string, page?: number): Promise<Uint8Array>;
+    getPreviewStream(fileId: string, page?: number): ReadableStream<Uint8Array>;
+    getPreviewUrl(fileId: string, page?: number): Promise<string>;
+    getAiFileContentPart(documentId: string): Promise<FileContentPart>;
+    private createPreviewIfNotExists;
+    private getDocumentFileContentObjectUrl;
+}

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

@@ -0,0 +1,22 @@
+import type { DocumentPropertyDataType } from '../../../../document-management/models/index.js';
+type DocumentInformationExtractionPropertyResult = {
+    propertyId: string;
+    dataType: DocumentPropertyDataType;
+    value: string | number | boolean;
+};
+export type DocumentInformationExtractionResult = {
+    title: string;
+    subtitle: string | null;
+    date: number | null;
+    summary: string;
+    tags: string[];
+    properties: DocumentInformationExtractionPropertyResult[];
+};
+export declare class DocumentManagementAiService {
+    #private;
+    classifyDocumentType(documentId: string): Promise<string>;
+    extractDocumentInformation(documentId: string): Promise<DocumentInformationExtractionResult>;
+    findSuitableCollectionsForDocument(documentId: string, collectionIds: string[]): Promise<string[]>;
+    findSuitableRequestForDocument(documentId: string, collectionIds: string[]): Promise<string | null>;
+}
+export {};

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

@@ -0,0 +1,128 @@
+import { DocumentCollection, type DocumentWorkflowStep } 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;
+};
+export declare abstract class DocumentManagementAncillaryService<Token = unknown> {
+    #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[]>;
+    /**
+     * Checks if a user can read/view a specific document collection and its documents.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request
+     */
+    abstract canReadCollection(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can write to/modify a specific document collection.
+     * This could include changing collection metadata or managing documents within it,
+     * such as adding documents or creating document requests for this collection.
+     * @param collectionId The ID of the document collection.
+     * @param token The token of the request
+     */
+    abstract canWriteCollection(collectionId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can approve a specific document. This implicitly allows fulfilling document requests by approving their linked document.
+     * This is usually a privileged action for staff members.
+     * @param documentId The ID of the document.
+     * @param token The token of the request
+     * @returns A promise that resolves to true if approval is allowed, false otherwise.
+     */
+    abstract canApproveDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can reject a specific document.
+     * This is usually a privileged action for staff members, often an alternative to approval.
+     * @param documentId The ID of the document.
+     * @param token The token of the request.
+     * @returns A promise that resolves to true if rejection is allowed, false otherwise.
+     */
+    abstract canRejectDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can read/view a specific document request.
+     * @param requestId The ID of the document request.
+     * @param token The token of the request
+     */
+    abstract canReadDocumentRequest(requestId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can assign an existing document to a document request.
+     * This links the document to the request, usually before final fulfillment.
+     * @param requestId The ID of the document request.
+     * @param documentId The ID of the document to be assigned.
+     * @param token The token of the request
+     * @returns A promise that resolves to true if assignment is allowed, false otherwise.
+     */
+    abstract canAssignDocumentToRequest(requestId: string, documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can manage document categories, types and their properties (create, update, delete).
+     * Typically an administrator function.
+     * @param token The token of the request.
+     */
+    abstract canManageCategoriesAndTypes(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can read document request templates.
+     * @param token The token of the request.
+     */
+    abstract canReadDocumentRequestsTemplates(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can manage document request templates (create, update, delete).
+     * Typically an administrator function.
+     * @param token The token of the request.
+     */
+    abstract canManageDocumentRequestsTemplates(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create/upload a new unassigned document (which then requires assigning to request/collection).
+     * @param token The token of the request.
+     */
+    abstract canCreateUnassignedDocument(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create/upload a new document assigned to an request.
+     * @param token The token of the request.
+     */
+    abstract canCreateRequestAssignedDocument(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can delete a document.
+     * This might be restricted (e.g., only for documents not yet approved, or by administrators).
+     * @param documentId The ID of the document.
+     * @param token The token of the request.
+     * @returns A promise that resolves to true if deletion is allowed, false otherwise.
+     */
+    abstract canDeleteDocument(documentId: string, token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can create and close document requests.
+     * @param token The token of the request.
+     */
+    abstract canManageDocumentRequest(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can manage document validation definitions and their assignment to types.
+     * Typically an administrator function.
+     * @param token The token of the request.
+     */
+    abstract canManageValidationDefinitions(token?: Token): boolean | Promise<boolean>;
+    /**
+     * Checks if a user can progress a document through its workflow.
+     * This implies reviewing the current step's output, making corrections if necessary,
+     * and then confirming to proceed to the next phase or finalization.
+     * @param documentId The ID of the document.
+     * @param currentWorkflowStep The current step of the workflow the user is interacting with.
+     * @param token The token of the request.
+     */
+    abstract canProgressDocumentWorkflow(documentId: string, currentWorkflowStep: DocumentWorkflowStep, token?: Token): boolean | Promise<boolean>;
+}

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

@@ -0,0 +1,13 @@
+import type { DocumentManagementData, DocumentRequestsTemplateData } from '../../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../../orm/server/index.js';
+import type { Record } from '../../../../types.js';
+import { DocumentCategory, DocumentType } from '../../models/index.js';
+export declare class DocumentManagementService extends Transactional {
+    #private;
+    loadData(collectionIds: string[]): Promise<DocumentManagementData>;
+    loadDocumentRequestsTemplateData(): Promise<DocumentRequestsTemplateData>;
+    initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string>(categoryNames: Record<CategoryKey, string>, categoryParents: Record<CategoryKey, CategoryKey | null>, typeNames: Record<TypeKey, string>, typeCategories: Record<TypeKey, CategoryKey>): Promise<{
+        categories: Record<CategoryKey, DocumentCategory>;
+        types: Record<TypeKey, DocumentType>;
+    }>;
+}

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

@@ -0,0 +1,84 @@
+import { DocumentPropertyDataType } from '../../../../document-management/models/index.js';
+import type { DocumentPropertyValueView, SetDocumentPropertyParameters } from '../../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../../orm/server/index.js';
+import type { OneOrMany } from '../../../../types.js';
+import { Document, DocumentProperty } from '../../models/index.js';
+export declare class DocumentPropertyService extends Transactional {
+    #private;
+    readonly repository: import("../../../../orm/server/repository.js").EntityRepository<Document>;
+    readonly documentProperties: import("drizzle-orm/pg-core").WithSubqueryWithSelection<{
+        documentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "document";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        propertyId: import("drizzle-orm/pg-core").PgColumn<{
+            name: string;
+            tableName: "document_property";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core").PgColumn<{
+            name: "label";
+            tableName: "document_property";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        dataType: import("drizzle-orm/pg-core").PgColumn<{
+            name: "dataType";
+            tableName: "document_property";
+            dataType: "string";
+            columnType: "PgEnumColumn";
+            data: "boolean" | "date" | "decimal" | "text" | "integer";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["boolean", "date", "decimal", "text", "integer"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        value: import("drizzle-orm").SQL.Aliased<string | number | boolean | null>;
+    }, "documentProperties">;
+    createProperty(label: string, dataType: DocumentPropertyDataType): Promise<DocumentProperty>;
+    assignPropertyToType(typeId: string, propertyId: string): Promise<void>;
+    loadDocumentProperties(documentId: OneOrMany<string>, includeNulls?: boolean): Promise<DocumentPropertyValueView[]>;
+    setPropertyValues(documentId: string, propertyValues: SetDocumentPropertyParameters[]): Promise<void>;
+}

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

@@ -0,0 +1,30 @@
+import type { RequestStats } from '../../../../document-management/models/service-models/index.js';
+import { Transactional } from '../../../../orm/server/index.js';
+import type { OneOrMany } from '../../../../types.js';
+import { DocumentRequest, DocumentRequestTemplate, DocumentRequestsTemplate } from '../../models/index.js';
+export declare class DocumentRequestService extends Transactional {
+    #private;
+    getRequestStats(collectionIds: OneOrMany<string>): Promise<RequestStats>;
+    createRequestsTemplate(parameters: Pick<DocumentRequestsTemplate, 'label' | 'description'>): Promise<DocumentRequestsTemplate>;
+    updateRequestsTemplate(id: string, parameters: Pick<DocumentRequestsTemplate, 'label' | 'description' | 'metadata'>): Promise<DocumentRequestsTemplate>;
+    applyRequestsTemplate(id: string, collectionIds: string[]): Promise<void>;
+    deleteRequestsTemplate(id: string): Promise<DocumentRequestsTemplate>;
+    createRequestTemplate(requestsTemplateId: string, typeId: string, comment: string): Promise<DocumentRequestTemplate>;
+    updateRequestTemplate(id: string, parameters: Pick<DocumentRequestTemplate, 'typeId' | 'comment'>): Promise<DocumentRequestTemplate>;
+    deleteRequestTemplate(id: string): Promise<DocumentRequestTemplate>;
+    createRequest(typeId: string, collectionIds: string[], comment: string | null): Promise<DocumentRequest>;
+    updateRequest(id: string, update: Partial<Pick<DocumentRequest, 'typeId' | 'comment'>>): Promise<void>;
+    deleteRequest(id: string): Promise<void>;
+    assignDocument(requestId: string, documentId: string): Promise<void>;
+    /**
+     * Fulfills a document request.
+     * Marks the request as fulfilled and creates associations between the document
+     * and the target collections defined in the request.
+     *
+     * @param requestId The ID of the DocumentRequest to fulfill.
+     * @param documentId The ID of the Document fulfilling the request.
+     * @param userId The ID of the user performing the action (for audit purposes).
+     * @throws NotFoundError if the DocumentRequest with the given ID does not exist.
+     */
+    fulfillRequest(requestId: string, documentId: string): Promise<void>;
+}