@tstdl/base 0.92.123 → 0.92.125

package/utils/function/class.js

@@ -0,0 +1,9 @@
+import { isUndefined } from '../type-guards.js';
+export function getClassOfName(name, extend) {
+    if (isUndefined(extend)) {
+        return { [name]: class {
+            } }[name];
+    }
+    return { [name]: class extends extend {
+        } }[name];
+}

package/utils/function/index.d.ts

@@ -1,2 +1,3 @@
+export * from './class.js';
 export * from './memoize.js';
 export * from './throttle.js';

package/utils/function/index.js

@@ -1,2 +1,3 @@
+export * from './class.js';
 export * from './memoize.js';
 export * from './throttle.js';

package/utils/function/memoize.d.ts

@@ -16,3 +16,21 @@ export type MemoizeOptions = {
 export declare function memoizeSingle<Fn extends (parameter: any) => any>(fn: Fn, options?: MemoizeOptions): Fn;
 export declare function memoizeClass<T extends Constructor>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
 export declare function memoizeClassSingle<T extends Constructor<any, [any]>>(type: T, options?: MemoizeOptions): (...parameters: ConstructorParameters<T>) => InstanceType<T>;
+/**
+ * Memoizes an accessor (getter)
+ *
+ * @example
+ * ```typescript
+ * class MyClass {
+ *   @Memoize()
+ *   get myValue() {
+ *     // expensive calculation
+ *     return 123;
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * The getter will be called only once for each instance of the class.
+ */
+export declare function Memoize(): MethodDecorator;

package/utils/function/memoize.js

@@ -1,5 +1,7 @@
 import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
+import { createAccessorDecorator } from '../../reflection/index.js';
+import { assertDefinedPass } from '../type-guards.js';
 /**
  * Memoizes a function with an arbitrary number of parameters. If you only need a single parameter, {@link memoizeSingle} is faster
  * @param fn function memoize
@@ -15,7 +17,7 @@ import { MultiKeyMap } from '../../data-structures/multi-key-map.js';
             const result = fn.call(this, ...parameters);
             cache.set(parameters, result);
             return result;
-        }
+        },
     }[name];
 }
 /**
@@ -34,7 +36,7 @@ export function memoizeSingle(fn, options = {}) {
             const result = fn.call(this, parameter);
             cache.set(parameter, result);
             return result;
-        }
+        },
     }[name];
 }
 export function memoizeClass(type, options = {}) {
@@ -43,6 +45,43 @@ export function memoizeClass(type, options = {}) {
 export function memoizeClassSingle(type, options = {}) {
     return memoizeSingle((parameter) => new type(parameter), options);
 }
+/**
+ * Memoizes an accessor (getter)
+ *
+ * @example
+ * ```typescript
+ * class MyClass {
+ *   @Memoize()
+ *   get myValue() {
+ *     // expensive calculation
+ *     return 123;
+ *   }
+ * }
+ * ```
+ *
+ * @remarks
+ * The getter will be called only once for each instance of the class.
+ */
+export function Memoize() {
+    const cache = new WeakMap();
+    return createAccessorDecorator({
+        handler: (data) => {
+            const getter = assertDefinedPass(data.descriptor.get, 'Memoize requires an getter for accessors.'); // eslint-disable-line @typescript-eslint/unbound-method
+            function cachedGetter() {
+                if (cache.has(this)) {
+                    return cache.get(this); // eslint-disable-line @typescript-eslint/no-unsafe-return
+                }
+                const value = getter.call(this);
+                cache.set(this, value);
+                return value; // eslint-disable-line @typescript-eslint/no-unsafe-return
+            }
+            return {
+                writable: false,
+                get: cachedGetter,
+            };
+        },
+    });
+}
 function getMemoizedName(fn) {
     return `memoized${fn.name[0]?.toUpperCase() ?? ''}${fn.name.slice(1)}`;
 }

package/utils/jwt.d.ts

@@ -28,5 +28,5 @@ export type JwtTokenParseResult<T extends JwtToken = JwtToken> = {
     };
 };
 export declare function parseJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string): JwtTokenParseResult<T>;
-export declare function createJwtTokenString<T extends JwtToken = JwtToken>(jwtToken: T, key: Key | string): Promise<string>;
+export declare function createJwtTokenString(jwtToken: JwtToken, key: Key | string): Promise<string>;
 export declare function parseAndValidateJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string, allowedAlgorithms: OneOrMany<JwtTokenAlgorithm>, key: Key | string): Promise<T>;

package/utils/jwt.js

@@ -15,30 +15,30 @@ export function parseJwtTokenString(tokenString) {
     const encoded = {
         header: encodedHeader,
         payload: encodedPayload,
-        signature: encodedSignature
+        signature: encodedSignature,
     };
     const bytes = {
         header: decodeBase64Url(encodedHeader),
         payload: decodeBase64Url(encodedPayload),
-        signature: decodeBase64Url(encodedSignature)
+        signature: decodeBase64Url(encodedSignature),
     };
     const string = {
         header: textDecoder.decode(bytes.header),
-        payload: textDecoder.decode(bytes.payload)
+        payload: textDecoder.decode(bytes.payload),
     };
     try {
         const header = JSON.parse(string.header);
         const payload = JSON.parse(string.payload);
         const token = {
             header,
-            payload
+            payload,
         };
         return {
             raw: tokenString,
             token: token,
             encoded,
             bytes,
-            string
+            string,
         };
     }
     catch {

package/utils/object/forward-ref.d.ts

@@ -1,9 +1,10 @@
+import type { AbstractConstructor } from '../../types.js';
 declare const isForwardRef: unique symbol;
-export type ForwardRefTypeHint = 'object' | 'function';
+export type ForwardRefTypeHint = 'object' | 'function' | AbstractConstructor;
 export type ForwardRefOptions<T extends object = object> = {
     reference?: T;
     initializer?: () => T;
-    /** Due to limitations of Proxy, there can be some issues if proxy is created with a target of the "wrong" type. If possible, you should specify the type is forward ref is going to forward to. */
+    /** Due to limitations of Proxy, there can be some issues if proxy is created with a target of the "wrong" type. If possible, you should specify the type the forward ref is going to forward to. */
     typeHint?: ForwardRefTypeHint;
 };
 export type ForwardRef<T extends object = object> = T & {

package/utils/object/forward-ref.js

@@ -1,9 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { getClassOfName } from '../function/index.js';
 import { propertyReflectMethods, reflectMethods } from '../proxy.js';
-import { assert, isDefined, isUndefined } from '../type-guards.js';
-import { lazyObject } from './lazy-property.js';
+import { assert, isDefined, isFunction, isUndefined } from '../type-guards.js';
+import { lazyObject, lazyObjectValue } from './lazy-property.js';
 const contexts = new WeakMap();
-// eslint-disable-next-line @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention
 export const ForwardRef = {
     create(options) {
         const context = getContext(options);
@@ -30,24 +30,26 @@ export const ForwardRef = {
     setRef(forwardRef, reference) {
         assert(ForwardRef.isForwardRef(forwardRef), 'provided value is not a ForwardRef');
         contexts.get(forwardRef).reference = reference;
-    }
+    },
 };
 function getForwardRefProxy(context) {
-    const target = (context.typeHint == 'function')
-        ? function forwardRef() { }
-        : { forwardRef: true };
+    const target = isFunction(context.typeHint)
+        ? new (getClassOfName(`${context.typeHint.name}ForwardRef`))()
+        : (context.typeHint == 'function')
+            ? function forwardRef() { }
+            : { forwardRef: true };
     const handler = {};
     for (const method of reflectMethods) {
         handler[method] = {
             [method](_originalTarget, ...args) {
                 if (isUndefined(context.reference)) {
                     const message = propertyReflectMethods.has(method)
-                        ? `cannot forward "${method}" to property "${args[0].toString()}" on a ForwardRef which has no reference`
+                        ? `cannot forward "${method}" to property "${String(args[0])}" on a ForwardRef which has no reference`
                         : `cannot forward "${method}" on a ForwardRef which has no reference`;
                     throw new Error(message);
                 }
                 return Reflect[method](context.reference, ...args);
-            }
+            },
         }[method];
     }
     return new Proxy(target, handler);
@@ -58,7 +60,5 @@ function getContext(options) {
         : isDefined(options?.initializer)
             ? { initializer: options.initializer }
             : { value: undefined };
-    return lazyObject({
-        reference
-    });
+    return lazyObject({ reference, typeHint: lazyObjectValue(options?.typeHint) });
 }

package/utils/object/lazy-property.js

@@ -33,7 +33,7 @@ export function lazyProperty(object, propertyKey, initializer, descriptor = {})
             }
             : undefined,
         enumerable,
-        configurable
+        configurable,
     });
 }
 export function lazyObject(initializers) {
@@ -61,7 +61,7 @@ export function lazyObject(initializers) {
         const descriptor = {
             configurable: definition.configurable,
             enumerable: definition.enumerable,
-            writable: definition.writable
+            writable: definition.writable,
         };
         if (hasInitializer) {
             lazyProperty(object, key, definition.initializer, descriptor);

package/utils/proxy.js

@@ -12,7 +12,7 @@ export const reflectMethodsMap = {
     ownKeys: true,
     preventExtensions: true,
     set: true,
-    setPrototypeOf: true
+    setPrototypeOf: true,
 };
 export const reflectMethods = objectKeys(reflectMethodsMap);
 export const propertyReflectMethods = new Set(['defineProperty', 'deleteProperty', 'get', 'getOwnPropertyDescriptor', 'has', 'set']);

package/utils/stream/{readable-stream-from-promise.d.ts → from-promise.d.ts}

@@ -1,2 +1,3 @@
 import { type ValueOrProvider } from '../value-or-provider.js';
 export declare function readableStreamFromPromise<T>(promiseOrProvider: ValueOrProvider<Promise<ReadableStream<T>>>): ReadableStream<T>;
+export declare function transformStreamFromPromise<I, O>(promiseOrProvider: ValueOrProvider<Promise<TransformStream<I, O>>>): TransformStream<I, O>;

package/utils/stream/from-promise.js

@@ -0,0 +1,27 @@
+import { resolveValueOrProvider } from '../value-or-provider.js';
+export function readableStreamFromPromise(promiseOrProvider) {
+    const stream = new TransformStream();
+    resolveValueOrProvider(promiseOrProvider)
+        .then(async (readable) => readable.pipeTo(stream.writable))
+        .catch(async (error) => stream.writable.abort(error).catch(() => { }));
+    return stream.readable;
+}
+export function transformStreamFromPromise(promiseOrProvider) {
+    const incoming = new TransformStream();
+    const outgoing = new TransformStream();
+    void (async () => {
+        try {
+            const sourceTransformer = await resolveValueOrProvider(promiseOrProvider);
+            await incoming.readable.pipeTo(sourceTransformer.writable);
+            await sourceTransformer.readable.pipeTo(outgoing.writable);
+        }
+        catch (e) {
+            await incoming.writable.abort(e).catch(() => { });
+            await outgoing.writable.abort(e).catch(() => { });
+        }
+    })();
+    return {
+        writable: incoming.writable,
+        readable: outgoing.readable,
+    };
+}

package/utils/stream/index.d.ts

@@ -1,6 +1,6 @@
 export * from './finalize-stream.js';
 export * from './readable-stream-adapter.js';
-export * from './readable-stream-from-promise.js';
+export * from './from-promise.js';
 export * from './size-limited-stream.js';
 export * from './slice.js';
 export * from './stream-helper-types.js';

package/utils/stream/index.js

@@ -1,6 +1,6 @@
 export * from './finalize-stream.js';
 export * from './readable-stream-adapter.js';
-export * from './readable-stream-from-promise.js';
+export * from './from-promise.js';
 export * from './size-limited-stream.js';
 export * from './slice.js';
 export * from './stream-helper-types.js';

package/utils/stream/stream-reader.js

@@ -14,51 +14,87 @@ export async function readBinaryStream(iterableOrStream, { length, onLengthExcee
         : getReadableStreamFromIterable(iterableOrStream);
     if (isDefined(length)) {
         const reader = stream.getReader({ mode: 'byob' });
-        let buffer = new ArrayBuffer(length + 1);
+        let buffer = new ArrayBuffer(length + 1); // To read one extra byte for exceed detection
         let bytesRead = 0;
-        while (true) {
-            const result = await reader.read(new Uint8Array(buffer, bytesRead, buffer.byteLength - bytesRead));
-            buffer = result.value.buffer;
-            bytesRead += result.value.byteLength;
-            if (result.done) {
-                break;
+        let shouldCancelReaderAtEnd = true;
+        try {
+            while (true) {
+                const view = new Uint8Array(buffer, bytesRead, buffer.byteLength - bytesRead);
+                const result = await reader.read(view);
+                buffer = result.value.buffer;
+                bytesRead += result.value.byteLength;
+                if (result.done) {
+                    break;
+                }
+                // Check if we have read more data than the specified 'length'.
+                // This implies bytesRead is at least length + 1.
+                if (bytesRead > length) {
+                    switch (onLengthExceed) {
+                        case 'error':
+                            await reader.cancel();
+                            shouldCancelReaderAtEnd = false;
+                            throw new MaxBytesExceededError('Size of stream is greater than provided length.');
+                        case 'close':
+                            await reader.cancel();
+                            shouldCancelReaderAtEnd = false;
+                            break;
+                        case 'leave-open':
+                            reader.releaseLock();
+                            shouldCancelReaderAtEnd = false;
+                            break;
+                        default:
+                            await reader.cancel();
+                            shouldCancelReaderAtEnd = false;
+                            throw new NotSupportedError(`Action ${onLengthExceed} not supported.`);
+                    }
+                    break;
+                }
             }
-            if (bytesRead > length) {
-                switch (onLengthExceed) {
+            if (bytesRead < length) { // Stream ended before specified length was read
+                switch (onLengthSubceed) {
                     case 'error':
-                        await reader.cancel();
-                        throw new MaxBytesExceededError('Size of stream is greater than provided length.');
+                        if (shouldCancelReaderAtEnd) {
+                            await reader.cancel();
+                        }
+                        shouldCancelReaderAtEnd = false;
+                        throw new BadRequestError('Size of stream was less than provided length.');
                     case 'close':
-                        await reader.cancel();
+                        if (shouldCancelReaderAtEnd) {
+                            await reader.cancel();
+                        }
+                        shouldCancelReaderAtEnd = false;
                         break;
                     case 'leave-open':
-                        reader.releaseLock();
+                        if (shouldCancelReaderAtEnd) {
+                            reader.releaseLock();
+                        }
+                        shouldCancelReaderAtEnd = false;
                         break;
                     default:
-                        throw new NotSupportedError(`Action ${onLengthExceed} not supported.`);
+                        if (shouldCancelReaderAtEnd) {
+                            await reader.cancel();
+                        }
+                        shouldCancelReaderAtEnd = false;
+                        throw new NotSupportedError(`Action ${onLengthSubceed} not supported.`);
                 }
             }
-            if (bytesRead == length + 1) {
-                break;
+            if (shouldCancelReaderAtEnd) {
+                await reader.cancel();
             }
+            return new Uint8Array(buffer, 0, Math.min(length, bytesRead));
         }
-        if (bytesRead < length) {
-            switch (onLengthSubceed) {
-                case 'error':
-                    await reader.cancel();
-                    throw new BadRequestError('Size of stream was less than provided length.');
-                case 'close':
-                    await reader.cancel();
-                    break;
-                case 'leave-open':
-                    reader.releaseLock();
-                    break;
-                default:
-                    throw new NotSupportedError(`Action ${onLengthSubceed} not supported.`);
+        catch (error) {
+            // If an error occurred (e.g., network, or thrown by logic above)
+            // and reader hasn't been handled, try to cancel it.
+            // This is a "best effort" cleanup.
+            if (shouldCancelReaderAtEnd && reader) {
+                try {
+                    await reader.cancel(error); // Pass the error reason
+                }
+                catch { /* ignore */ }
             }
+            throw error;
         }
-        await reader.cancel();
-        return new Uint8Array(buffer, 0, Math.min(length, bytesRead));
     }
     let totalLength = 0;
     const reader = stream.getReader();
@@ -66,6 +102,10 @@ export async function readBinaryStream(iterableOrStream, { length, onLengthExcee
     while (true) {
         const result = await reader.read();
         if (result.done) {
+            if (isDefined(result.value)) {
+                views.push(result.value);
+                totalLength += result.value.byteLength;
+            }
             break;
         }
         views.push(result.value);

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

@@ -1,7 +0,0 @@
-import { Entity } from '../../orm/entity.js';
-import { Uuid } from '../../orm/types.js';
-export declare class DocumentRequestAssignmentTaskCollection extends Entity {
-    static readonly entityName: 'DocumentRequestAssignmentTaskCollection';
-    requestAssignmentTaskId: Uuid;
-    collectionId: Uuid;
-}

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

@@ -1,14 +0,0 @@
-import { Entity } from '../../orm/entity.js';
-import { NumericDate, Uuid } from '../../orm/types.js';
-export declare class DocumentRequestAssignmentTask extends Entity {
-    fileId: Uuid;
-    assignedRequestFileId: Uuid | null;
-    typeId: Uuid | null;
-    title: string | null;
-    subtitle: string | null;
-    pages: number | null;
-    date: NumericDate | null;
-    summary: string | null;
-    tags: string[] | null;
-    assignmentTries: number;
-}

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

@@ -1,77 +0,0 @@
-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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { References } from '../../orm/decorators.js';
-import { Entity } from '../../orm/entity.js';
-import { NumericDate, Unique, Uuid } from '../../orm/types.js';
-import { Array, Integer, string, StringProperty } from '../../schema/index.js';
-import { DocumentFile } from './document-file.model.js';
-import { DocumentManagementTable } from './document-management-table.js';
-import { DocumentRequestFile } from './document-request-file.model.js';
-import { DocumentType } from './document-type.model.js';
-let DocumentRequestAssignmentTask = class DocumentRequestAssignmentTask extends Entity {
-    fileId;
-    assignedRequestFileId;
-    typeId;
-    title;
-    subtitle;
-    pages;
-    date;
-    summary;
-    tags;
-    assignmentTries;
-};
-__decorate([
-    Uuid(),
-    References(() => DocumentFile),
-    Unique(undefined, { naming: 'abbreviated-table' }),
-    __metadata("design:type", String)
-], DocumentRequestAssignmentTask.prototype, "fileId", void 0);
-__decorate([
-    Uuid({ nullable: true }),
-    References(() => DocumentRequestFile),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "assignedRequestFileId", void 0);
-__decorate([
-    Uuid({ nullable: true }),
-    References(() => DocumentType),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "typeId", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "title", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "subtitle", void 0);
-__decorate([
-    Integer({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "pages", void 0);
-__decorate([
-    NumericDate({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "date", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "summary", void 0);
-__decorate([
-    Array(string(), { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestAssignmentTask.prototype, "tags", void 0);
-__decorate([
-    Integer(),
-    __metadata("design:type", Number)
-], DocumentRequestAssignmentTask.prototype, "assignmentTries", void 0);
-DocumentRequestAssignmentTask = __decorate([
-    DocumentManagementTable()
-], DocumentRequestAssignmentTask);
-export { DocumentRequestAssignmentTask };

package/document-management/models/document-request-file.model.d.ts

@@ -1,16 +0,0 @@
-import { Entity } from '../../orm/entity.js';
-import { NumericDate, Timestamp, Uuid } from '../../orm/types.js';
-export declare class DocumentRequestFile extends Entity {
-    requestId: Uuid;
-    fileId: Uuid;
-    title: string | null;
-    subtitle: string | null;
-    pages: number | null;
-    date: NumericDate | null;
-    summary: string | null;
-    tags: string[] | null;
-    createdDocumentId: Uuid | null;
-    approval: boolean | null;
-    approvalComment: string | null;
-    approvalTimestamp: Timestamp | null;
-}

package/document-management/models/document-request-file.model.js

@@ -1,86 +0,0 @@
-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 __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { References } from '../../orm/decorators.js';
-import { Entity } from '../../orm/entity.js';
-import { NumericDate, Timestamp, Uuid } from '../../orm/types.js';
-import { Array, BooleanProperty, Integer, string, StringProperty } from '../../schema/index.js';
-import { DocumentFile } from './document-file.model.js';
-import { DocumentManagementTable } from './document-management-table.js';
-import { DocumentRequest } from './document-request.model.js';
-import { Document } from './document.model.js';
-let DocumentRequestFile = class DocumentRequestFile extends Entity {
-    requestId;
-    fileId;
-    title;
-    subtitle;
-    pages;
-    date;
-    summary;
-    tags;
-    createdDocumentId;
-    approval;
-    approvalComment;
-    approvalTimestamp;
-};
-__decorate([
-    Uuid(),
-    References(() => DocumentRequest),
-    __metadata("design:type", String)
-], DocumentRequestFile.prototype, "requestId", void 0);
-__decorate([
-    Uuid(),
-    References(() => DocumentFile),
-    __metadata("design:type", String)
-], DocumentRequestFile.prototype, "fileId", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "title", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "subtitle", void 0);
-__decorate([
-    Integer({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "pages", void 0);
-__decorate([
-    NumericDate({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "date", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "summary", void 0);
-__decorate([
-    Array(string(), { nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "tags", void 0);
-__decorate([
-    Uuid({ nullable: true }),
-    References(() => Document),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "createdDocumentId", void 0);
-__decorate([
-    BooleanProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "approval", void 0);
-__decorate([
-    StringProperty({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "approvalComment", void 0);
-__decorate([
-    Timestamp({ nullable: true }),
-    __metadata("design:type", Object)
-], DocumentRequestFile.prototype, "approvalTimestamp", void 0);
-DocumentRequestFile = __decorate([
-    DocumentManagementTable()
-], DocumentRequestFile);
-export { DocumentRequestFile };