@tstdl/base 0.93.61 → 0.93.64

package/ai/genkit/helpers.d.ts

@@ -0,0 +1,10 @@
+import type { GenerateOptions, z } from 'genkit';
+import type { SchemaTestable } from '../../schema/index.js';
+import type { TypedOmit } from '../../types/types.js';
+export type TstdlGenkitGenerationOptions<T, O extends z.ZodTypeAny> = TypedOmit<GenerateOptions<z.ZodType<NoInfer<T>>, O>, 'output'> & {
+    output?: TypedOmit<NonNullable<GenerateOptions['output']>, 'schema'> & {
+        schema?: SchemaTestable<T>;
+    };
+};
+export declare function convertToGenkitSchema<T>(schema: SchemaTestable<T>): z.ZodType<T>;
+export declare function genkitGenerationOptions<T, O extends z.ZodTypeAny>(options: TstdlGenkitGenerationOptions<T, O>): GenerateOptions<z.ZodType<T>, z.ZodType<O>>;

package/ai/genkit/helpers.js

@@ -0,0 +1,14 @@
+import { convertToZodV3Schema } from '../../schema/converters/zod-v3-converter.js';
+import { isDefined } from '../../utils/type-guards.js';
+export function convertToGenkitSchema(schema) {
+    return convertToZodV3Schema(schema); // eslint-disable-line @typescript-eslint/no-unsafe-return
+}
+export function genkitGenerationOptions(options) {
+    return {
+        ...options,
+        output: {
+            ...options.output,
+            schema: isDefined(options.output?.schema) ? convertToGenkitSchema(options.output.schema) : undefined,
+        },
+    };
+}

package/ai/genkit/index.d.ts

@@ -0,0 +1,2 @@
+export * from './helpers.js';
+export * from './module.js';

package/ai/genkit/index.js

@@ -0,0 +1,2 @@
+export * from './helpers.js';
+export * from './module.js';

package/ai/genkit/module.d.ts

@@ -0,0 +1,35 @@
+import { vertexAI } from '@genkit-ai/google-genai';
+import { type Genkit, type GenkitOptions } from 'genkit';
+/**
+ * Options for configuring the AI Module.
+ */
+export declare class GenkitModuleOptions {
+    /** Gemini API specific options. */
+    gemini?: {
+        /** Gemini API key */
+        apiKey?: string;
+    };
+    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
+    vertex?: {
+        /** Google Cloud API key */
+        apiKey?: string;
+        /** Google Cloud projectId */
+        projectId: string;
+        /** Google Cloud region  */
+        location: string;
+        /** Path to the Google Cloud credentials file */
+        keyFile?: string;
+    };
+    /** Plugins to register automatically */
+    plugins?: GenkitOptions['plugins'];
+    /** Default Genkit options */
+    options?: Omit<GenkitOptions, 'plugins'>;
+}
+/**
+ * Configures the {@link AiService}.
+ * @param options The configuration options for the AI services.
+ */
+export declare function configureGenkit(options: GenkitModuleOptions): void;
+export declare function injectGenkit(options?: GenkitOptions): Genkit;
+declare const _injectModel: typeof vertexAI.model;
+export { _injectModel as injectModel };

package/ai/genkit/module.js

@@ -0,0 +1,56 @@
+import { googleAI, vertexAI } from '@genkit-ai/google-genai';
+import { genkit } from 'genkit';
+import { inject } from '../../injector/inject.js';
+import { Injector } from '../../injector/injector.js';
+import { isDefined, isNotNull } from '../../utils/type-guards.js';
+/**
+ * Options for configuring the AI Module.
+ */
+export class GenkitModuleOptions {
+    /** Gemini API specific options. */
+    gemini;
+    /** Vertex AI specific options. If provided, the service will use Vertex AI endpoints. */
+    vertex;
+    /** Plugins to register automatically */
+    plugins;
+    /** Default Genkit options */
+    options;
+}
+/**
+ * Configures the {@link AiService}.
+ * @param options The configuration options for the AI services.
+ */
+export function configureGenkit(options) {
+    Injector.register(GenkitModuleOptions, { useValue: options });
+}
+export function injectGenkit(options) {
+    const { vertex, gemini, ...moduleOptions } = inject(GenkitModuleOptions, undefined, { optional: true }) ?? {};
+    const vertexPlugin = isDefined(vertex)
+        ? vertexAI({
+            apiKey: vertex.apiKey,
+            location: vertex.location,
+            projectId: vertex.projectId,
+            googleAuth: isDefined(vertex.keyFile) ? { keyFile: vertex.keyFile } : undefined,
+        })
+        : null;
+    const geminiPlugin = isDefined(gemini)
+        ? googleAI({ apiKey: gemini.apiKey })
+        : null;
+    return genkit({
+        ...moduleOptions.options,
+        ...options,
+        plugins: [
+            geminiPlugin,
+            vertexPlugin,
+            ...(moduleOptions.plugins ?? []),
+            ...(options?.plugins ?? []),
+        ].filter(isNotNull),
+    });
+}
+function injectModel(...args) {
+    const moduleOptions = inject(GenkitModuleOptions, undefined, { optional: true }) ?? {};
+    const provider = isDefined(moduleOptions.vertex) ? vertexAI : googleAI;
+    return provider.model(...args);
+}
+const _injectModel = injectModel;
+export { _injectModel as injectModel };

package/ai/index.d.ts

@@ -3,4 +3,5 @@ export * from './ai-session.js';
 export * from './ai.service.js';
 export * from './functions.js';
 export * from './module.js';
+export * from './prompts/index.js';
 export * from './types.js';

package/ai/index.js

@@ -3,4 +3,5 @@ export * from './ai-session.js';
 export * from './ai.service.js';
 export * from './functions.js';
 export * from './module.js';
+export * from './prompts/index.js';
 export * from './types.js';

package/ai/prompts/format.d.ts

@@ -0,0 +1,15 @@
+import type { Json } from '../../types/types.js';
+/**
+ * Formats objects and arrays for AI context. Requires values to be primitive types (or arrays of primitive types).
+ * Nesting of arrays is only supported one level deep and only recommended for a short list of items.
+ * If keys are not provided, all supported properties will be included. In case of arrays of objects, the keys of the first object will be used.
+ * @param data data to format
+ * @param dataTypeName name of the data type (e.g., "document", "users")
+ * @param keys keys to include in the output; can be property names or tuples of [property name, value extractor function]
+ * @returns formatted string representation of the data
+ */
+/**
+ * Format data as TOON string for AI context.
+ * @param data data to format
+ */
+export declare function formatData(data: Json): string;

package/ai/prompts/format.js

@@ -0,0 +1,17 @@
+import { encode } from '@toon-format/toon';
+/**
+ * Formats objects and arrays for AI context. Requires values to be primitive types (or arrays of primitive types).
+ * Nesting of arrays is only supported one level deep and only recommended for a short list of items.
+ * If keys are not provided, all supported properties will be included. In case of arrays of objects, the keys of the first object will be used.
+ * @param data data to format
+ * @param dataTypeName name of the data type (e.g., "document", "users")
+ * @param keys keys to include in the output; can be property names or tuples of [property name, value extractor function]
+ * @returns formatted string representation of the data
+ */
+/**
+ * Format data as TOON string for AI context.
+ * @param data data to format
+ */
+export function formatData(data) {
+    return encode(data, { keyFolding: 'safe', indent: 2 });
+}

package/ai/prompts/index.d.ts

@@ -0,0 +1,3 @@
+export * from './format.js';
+export * from './instructions-formatter.js';
+export * from './instructions.js';

package/ai/prompts/index.js

@@ -0,0 +1,3 @@
+export * from './format.js';
+export * from './instructions-formatter.js';
+export * from './instructions.js';

package/ai/prompts/instructions-formatter.d.ts

@@ -0,0 +1,25 @@
+export type ListStyle = 'sections' | 'ordered' | 'unordered';
+type InstructionsListContent = string[] | Instructions;
+export type InstructionsList = {
+    style: ListStyle;
+    instruction?: string;
+    items: InstructionsListContent;
+};
+export type Instructions = {
+    [key: string]: string | string[] | InstructionsList | Instructions;
+};
+export declare function sections(items: InstructionsListContent): InstructionsList;
+export declare function sections(instruction: string, items: InstructionsListContent): InstructionsList;
+export declare function orderedList(items: InstructionsListContent): InstructionsList;
+export declare function orderedList(instruction: string, items: InstructionsListContent): InstructionsList;
+export declare function unorderedList(items: InstructionsListContent): InstructionsList;
+export declare function unorderedList(instruction: string, items: InstructionsListContent): InstructionsList;
+/**
+ * Formats instructions into a string representation suitable for AI prompts.
+ * @param node
+ * @param options
+ */
+export declare function formatInstructions(node: Instructions | InstructionsList | string[], options?: {
+    initialDepth?: number;
+}): string;
+export {};

package/ai/prompts/instructions-formatter.js

@@ -0,0 +1,166 @@
+import { hasOwnProperty, objectEntries } from '../../utils/object/object.js';
+import { assertDefined, isArray, isDefined, isObject, isString } from '../../utils/type-guards.js';
+// --- Factories ---
+function list(style, instructionOrItems, itemsOrNothing) {
+    const instruction = isString(instructionOrItems) ? instructionOrItems : undefined;
+    const items = isString(instructionOrItems) ? itemsOrNothing : instructionOrItems;
+    assertDefined(items, 'Instructions list is empty.');
+    return { style, instruction, items };
+}
+export function sections(instructionOrItems, itemsOrNothing) {
+    return list('sections', instructionOrItems, itemsOrNothing);
+}
+export function orderedList(instructionOrItems, itemsOrNothing) {
+    return list('ordered', instructionOrItems, itemsOrNothing);
+}
+export function unorderedList(instructionOrItems, itemsOrNothing) {
+    return list('unordered', instructionOrItems, itemsOrNothing);
+}
+// --- Type Guards ---
+function isInstructionsList(obj) {
+    return isObject(obj) && hasOwnProperty(obj, 'style') && hasOwnProperty(obj, 'items');
+}
+// --- Formatter Logic ---
+const INDENT_SIZE = 2;
+function getPrefix(style, index, sectionDepth) {
+    switch (style) {
+        case 'ordered':
+            return `${index + 1}. `;
+        case 'unordered':
+            return '- ';
+        case 'sections':
+            return '#'.repeat(Math.max(1, sectionDepth)) + ' ';
+        default:
+            return '';
+    }
+}
+/**
+ * Formats a string that might span multiple lines.
+ * It calculates the hanging indent based on the length of the prefix used on the first line.
+ */
+function formatWithHangingIndent(text, baseIndent, prefix) {
+    const lines = text.split('\n');
+    if (lines.length == 0) {
+        return '';
+    }
+    const firstLine = `${baseIndent}${prefix}${lines[0]}`;
+    if (lines.length == 1) {
+        return firstLine;
+    }
+    // Create a spacer that exactly matches the visual length of "  1. " or "  - "
+    const hangingSpacer = ' '.repeat(baseIndent.length + prefix.length);
+    return [
+        firstLine,
+        ...lines.slice(1).map((line) => `${hangingSpacer}${line}`),
+    ].join('\n');
+}
+/**
+ * Main recursive formatter.
+ */
+function processNode(node, context) {
+    // 1. Unwrap InstructionsList (The Wrapper)
+    // If the node is a wrapper, we adopt its style and instruction, then process its items.
+    if (isInstructionsList(node)) {
+        // Note: We don't print the "instruction" here (e.g., "Use Markdown").
+        // If this Wrapper is a root node, the instruction is usually printed by the caller or ignored.
+        // If this Wrapper is a value of a key, the key printer handles the instruction.
+        // However, if we have a "Root Wrapper" with an instruction (rare in your example), handle it:
+        const header = node.instruction ? `${node.instruction}\n` : '';
+        // Determine next context
+        const nextContext = {
+            indentDepth: context.indentDepth, // Wrappers don't indent themselves, their content does
+            style: node.style,
+            sectionDepth: node.style == 'sections' ? context.sectionDepth : context.sectionDepth, // Section depth increments internally
+        };
+        return header + processNode(node.items, nextContext);
+    }
+    // Common Constants for this level
+    const isSection = context.style == 'sections';
+    const currentBaseIndent = ' '.repeat(isSection ? 0 : context.indentDepth * INDENT_SIZE);
+    const separator = isSection ? '\n\n' : '\n';
+    // 2. Handle Arrays (Simple Lists)
+    if (isArray(node)) {
+        return node.map((item, index) => {
+            const prefix = getPrefix(context.style, index, context.sectionDepth);
+            return formatWithHangingIndent(item, currentBaseIndent, prefix);
+        }).join(separator);
+    }
+    // 3. Handle Objects (Key-Value Maps)
+    return objectEntries(node).map(([key, value], index) => {
+        const prefix = getPrefix(context.style, index, context.sectionDepth);
+        // Detect if the Value is a Wrapper (e.g. `Key: ordered(...)`)
+        // This allows us to pull the wrapper's "instruction" up to the Key line.
+        const isValueWrapper = isInstructionsList(value);
+        const effectiveValue = isValueWrapper ? value.items : value;
+        const instruction = (isValueWrapper && isDefined(value.instruction)) ? ` ${value.instruction}` : '';
+        const childStyle = isValueWrapper ? value.style : (isSection ? 'unordered' : 'unordered');
+        // Formatting the Header Line (The Key)
+        let headerLine = '';
+        if (isSection) {
+            // Header format: "# Key" or "# Key\n\nInstruction"
+            const instructionPart = (instruction.length > 0) ? `\n\n${instruction.trim()}` : '';
+            headerLine = `${currentBaseIndent}${prefix}${key}${instructionPart}`;
+        }
+        else {
+            // List format: "- **Key:**" or "- **Key:** Instruction"
+            const keyPart = `**${key}:**`;
+            headerLine = `${currentBaseIndent}${prefix}${keyPart}${instruction}`;
+        }
+        // Determine context for the children
+        // If we are a Section, children reset indent to 0.
+        // If we are a List, children indent + 1.
+        const nextIndentDepth = isSection ? 0 : context.indentDepth + 1;
+        // If the child acts as a section (Wrapper was `sections(...)`), increment H-level.
+        const nextSectionDepth = (isValueWrapper && value.style == 'sections')
+            ? context.sectionDepth + 1
+            : context.sectionDepth;
+        // Recurse
+        // If the value is a simple string, we print it inline if possible, or block if it's long?
+        // Your requirement: Strings in objects are usually descriptions.
+        if (isString(effectiveValue)) {
+            // If it's a string, we treat it as content on the SAME line for lists (via hanging indent logic),
+            // or a new paragraph for Sections.
+            if (isSection) {
+                // Section: Header \n\n Content
+                return `${headerLine}\n\n${effectiveValue.trim()}`;
+            }
+            else {
+                // List: "- **Key:** Value"
+                // We need to construct the full string to calculate hanging indent correctly.
+                // headerLine already contains indentation + prefix + key.
+                // We strip the indentation to feed it into the formatting helper effectively.
+                const fullLine = `${headerLine} ${effectiveValue}`.trim();
+                return formatWithHangingIndent(fullLine, currentBaseIndent, '');
+            }
+        }
+        // If Value is Object/Array/Wrapper
+        const body = processNode(effectiveValue, {
+            indentDepth: nextIndentDepth,
+            style: childStyle,
+            sectionDepth: nextSectionDepth,
+        });
+        const bodySeparator = isSection ? '\n\n' : '\n';
+        // Edge case: If it's a section, we constructed the header, now append body.
+        // If it's a list, the header line serves as the parent item.
+        return `${headerLine}${bodySeparator}${body}`;
+    }).join(separator);
+}
+/**
+ * Formats instructions into a string representation suitable for AI prompts.
+ * @param node
+ * @param options
+ */
+export function formatInstructions(node, options = {}) {
+    // Heuristic: If passing a raw object, assume it's a Root Section unless specified otherwise.
+    // If passing a Wrapper, the Wrapper dictates the style.
+    const initialStyle = isInstructionsList(node)
+        ? node.style
+        : isArray(node)
+            ? 'unordered'
+            : 'sections';
+    return processNode(node, {
+        indentDepth: options.initialDepth ?? 0,
+        sectionDepth: 1,
+        style: initialStyle,
+    }).trim();
+}

package/ai/prompts/instructions.d.ts

@@ -0,0 +1,3 @@
+export declare const jsonOutputInstructions: {
+    'JSON Output': import("./instructions-formatter.js").InstructionsList;
+};

package/ai/prompts/instructions.js

@@ -0,0 +1,8 @@
+import { unorderedList } from './instructions-formatter.js';
+export const jsonOutputInstructions = {
+    'JSON Output': unorderedList({
+        'Schema Compliance': 'Generate valid JSON that strictly matches the provided schema.',
+        'Nullable fields with missing data': 'Must be set to literal `null`.',
+        'Optional fields with missing data': 'Omit the key entirely (sparse JSON).',
+    }),
+};

package/document-management/api/document-management.api.d.ts

@@ -88,8 +88,8 @@ export declare const documentManagementApiDefinition: {
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                parentId: import("../../orm/types.js").Uuid | null;
                 label: string;
+                parentId: import("../../orm/types.js").Uuid | null;
                 metadata?: Partial<{
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
@@ -127,10 +127,10 @@ export declare const documentManagementApiDefinition: {
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 date?: import("../../orm/types.js").NumericDate | null | undefined;
+                summary?: string | null | undefined;
                 title?: string | null | undefined;
                 typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
-                summary?: string | null | undefined;
                 comment?: string | null | undefined;
                 approval?: import("../models/document.model.js").DocumentApproval | undefined;
                 originalFileName?: string | null | undefined;
@@ -179,7 +179,7 @@ export declare const documentManagementApiDefinition: {
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: import("../../orm/types.js").IsPrimaryKey<import("../../orm/types.js").HasDefault<import("../../orm/types.js").Uuid>>;
                 description?: string | null | undefined;
-                tenantId?: string | null | undefined;
+                tenantId?: import("../../orm/types.js").Uuid | undefined;
                 label?: string | undefined;
                 metadata?: Partial<{
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
@@ -232,7 +232,7 @@ export declare const documentManagementApiDefinition: {
             method: "PATCH";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: import("../../orm/types.js").IsPrimaryKey<import("../../orm/types.js").HasDefault<import("../../orm/types.js").Uuid>>;
-                tenantId?: string | null | undefined;
+                tenantId?: import("../../orm/types.js").Uuid | undefined;
                 typeId?: import("../../orm/types.js").Uuid | undefined;
                 comment?: string | null | undefined;
                 metadata?: Partial<{
@@ -488,8 +488,8 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             resource: string;
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
-                parentId: import("../../orm/types.js").Uuid | null;
                 label: string;
+                parentId: import("../../orm/types.js").Uuid | null;
                 metadata?: Partial<{
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
                 }> | undefined;
@@ -527,10 +527,10 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 date?: import("../../orm/types.js").NumericDate | null | undefined;
+                summary?: string | null | undefined;
                 title?: string | null | undefined;
                 typeId?: import("../../orm/types.js").Uuid | null | undefined;
                 subtitle?: string | null | undefined;
-                summary?: string | null | undefined;
                 comment?: string | null | undefined;
                 approval?: import("../models/document.model.js").DocumentApproval | undefined;
                 originalFileName?: string | null | undefined;
@@ -579,7 +579,7 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: import("../../orm/types.js").IsPrimaryKey<import("../../orm/types.js").HasDefault<import("../../orm/types.js").Uuid>>;
                 description?: string | null | undefined;
-                tenantId?: string | null | undefined;
+                tenantId?: import("../../orm/types.js").Uuid | undefined;
                 label?: string | undefined;
                 metadata?: Partial<{
                     attributes: import("../../orm/types.js").HasDefault<import("../../orm/types.js").Json<import("../../orm/entity.js").EntityMetadataAttributes>>;
@@ -632,7 +632,7 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             method: "PATCH";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: import("../../orm/types.js").IsPrimaryKey<import("../../orm/types.js").HasDefault<import("../../orm/types.js").Uuid>>;
-                tenantId?: string | null | undefined;
+                tenantId?: import("../../orm/types.js").Uuid | undefined;
                 typeId?: import("../../orm/types.js").Uuid | undefined;
                 comment?: string | null | undefined;
                 metadata?: Partial<{

package/document-management/models/document-assignment-scope.model.d.ts

@@ -1,11 +1,10 @@
-import { Entity, type Uuid } from '../../orm/index.js';
+import { TenantEntity, type Uuid } from '../../orm/index.js';
 /**
  * Defines which collections or requests in these collections (depends on assignment task) are allowed to be assigned to a document in the assignment workflow.
  * This is used to prevent documents from being assigned to collections/requests that are out of scope/context.
  */
-export declare class DocumentAssignmentScope extends Entity {
-    static readonly entityName: 'DocumentAssignmentScope';
-    tenantId: Uuid;
+export declare class DocumentAssignmentScope extends TenantEntity {
+    static readonly entityName = "DocumentAssignmentScope";
     taskId: Uuid;
     collectionId: Uuid;
 }

package/document-management/models/document-assignment-scope.model.js

@@ -7,7 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Entity, ForeignKey, References, Unique, UuidProperty } from '../../orm/index.js';
+import { ForeignKey, TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
 import { DocumentAssignmentTask } from './document-assignment-task.model.js';
 import { DocumentCollection } from './document-collection.model.js';
 import { DocumentManagementTable } from './document-management-table.js';
@@ -15,23 +15,19 @@ import { DocumentManagementTable } from './document-management-table.js';
  * Defines which collections or requests in these collections (depends on assignment task) are allowed to be assigned to a document in the assignment workflow.
  * This is used to prevent documents from being assigned to collections/requests that are out of scope/context.
  */
-let DocumentAssignmentScope = class DocumentAssignmentScope extends Entity {
-    tenantId;
+let DocumentAssignmentScope = class DocumentAssignmentScope extends TenantEntity {
+    static entityName = 'DocumentAssignmentScope';
     taskId;
     collectionId;
 };
 __decorate([
     UuidProperty(),
-    __metadata("design:type", String)
-], DocumentAssignmentScope.prototype, "tenantId", void 0);
-__decorate([
-    UuidProperty(),
-    References(() => DocumentAssignmentTask),
+    TenantReference(() => DocumentAssignmentTask),
     __metadata("design:type", String)
 ], DocumentAssignmentScope.prototype, "taskId", void 0);
 __decorate([
     UuidProperty(),
-    References(() => DocumentCollection),
+    TenantReference(() => DocumentCollection),
     __metadata("design:type", String)
 ], DocumentAssignmentScope.prototype, "collectionId", void 0);
 DocumentAssignmentScope = __decorate([

package/document-management/models/document-assignment-task.model.d.ts

@@ -1,13 +1,12 @@
 import { type EnumType } from '../../enumeration/enumeration.js';
-import { Entity, type Uuid } from '../../orm/index.js';
+import { TenantEntity, type Uuid } from '../../orm/index.js';
 export declare const DocumentAssignmentTarget: {
     readonly Collection: "collection";
     readonly Request: "request";
 };
 export type DocumentAssignmentTarget = EnumType<typeof DocumentAssignmentTarget>;
-export declare class DocumentAssignmentTask extends Entity {
-    static readonly entityName: 'DocumentAssignmentTask';
-    tenantId: Uuid;
+export declare class DocumentAssignmentTask extends TenantEntity {
+    static readonly entityName = "DocumentAssignmentTask";
     documentId: Uuid;
     target: DocumentAssignmentTarget;
 }

package/document-management/models/document-assignment-task.model.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { defineEnum } from '../../enumeration/enumeration.js';
-import { Entity, ForeignKey, References, Unique, UuidProperty } from '../../orm/index.js';
+import { ForeignKey, TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
 import { Enumeration } from '../../schema/index.js';
 import { DocumentManagementTable } from './document-management-table.js';
 import { Document } from './document.model.js';
@@ -16,18 +16,14 @@ export const DocumentAssignmentTarget = defineEnum('DocumentAssignmentTarget', {
     Collection: 'collection',
     Request: 'request',
 });
-let DocumentAssignmentTask = class DocumentAssignmentTask extends Entity {
-    tenantId;
+let DocumentAssignmentTask = class DocumentAssignmentTask extends TenantEntity {
+    static entityName = 'DocumentAssignmentTask';
     documentId;
     target;
 };
 __decorate([
     UuidProperty(),
-    __metadata("design:type", String)
-], DocumentAssignmentTask.prototype, "tenantId", void 0);
-__decorate([
-    UuidProperty(),
-    References(() => Document),
+    TenantReference(() => Document),
     Unique(),
     __metadata("design:type", String)
 ], DocumentAssignmentTask.prototype, "documentId", void 0);

package/document-management/models/document-category.model.d.ts

@@ -1,7 +1,6 @@
-import { Entity, type Uuid } from '../../orm/index.js';
-export declare class DocumentCategory extends Entity {
-    static readonly entityName: 'DocumentCategory';
-    tenantId: string | null;
+import { TenantEntity, type Uuid } from '../../orm/index.js';
+export declare class DocumentCategory extends TenantEntity {
+    static readonly entityName = "DocumentCategory";
     parentId: Uuid | null;
     label: string;
 }

package/document-management/models/document-category.model.js

@@ -7,21 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Entity, References, Unique, UuidProperty } from '../../orm/index.js';
+import { TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
 import { StringProperty } from '../../schema/index.js';
 import { DocumentManagementTable } from './document-management-table.js';
-let DocumentCategory = class DocumentCategory extends Entity {
-    tenantId;
+let DocumentCategory = class DocumentCategory extends TenantEntity {
+    static entityName = 'DocumentCategory';
     parentId;
     label;
 };
 __decorate([
     UuidProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentCategory.prototype, "tenantId", void 0);
-__decorate([
-    UuidProperty({ nullable: true }),
-    References(() => DocumentCategory),
+    TenantReference(() => DocumentCategory),
     __metadata("design:type", Object)
 ], DocumentCategory.prototype, "parentId", void 0);
 __decorate([

package/document-management/models/document-collection-assignment.model.d.ts

@@ -1,6 +1,5 @@
-import { Entity, type Timestamp, type Uuid } from '../../orm/index.js';
-export declare class DocumentCollectionAssignment extends Entity {
-    tenantId: Uuid;
+import { TenantEntity, type Timestamp, type Uuid } from '../../orm/index.js';
+export declare class DocumentCollectionAssignment extends TenantEntity {
     collectionId: Uuid;
     documentId: Uuid;
     archiveTimestamp: Timestamp | null;