@tstdl/base 0.93.98 → 0.93.100

package/context/context.d.ts

@@ -3,7 +3,7 @@ import type { Function, SimplifyObject } from '../types/index.js';
  * Creates a new context provider
  * @param name name of of the context used for function names
  */
-export declare function createContextProvider<Context, const Name extends string>(name: Name): SimplifyObject<Record<`getCurrent${Name}Context`, {
+export declare function createContextProvider<Context, const Name extends string>(name: Name): SimplifyObject<Record<`tryGetCurrent${Name}Context`, () => Context | null> & Record<`getCurrent${Name}Context`, {
     (required: true, debugFn: Function): Context;
     (required?: false, debugFn?: Function): Context | null;
     (required: boolean, debugFn: Function): Context | null;

package/context/context.js

@@ -5,6 +5,9 @@ import { isNotNull, isString } from '../utils/type-guards.js';
  */
 export function createContextProvider(name) {
     let currentContext = null;
+    function tryGetCurrentContext() {
+        return currentContext;
+    }
     function getCurrentContext(required = false, debugFn) {
         if (required) {
             assertInContext(debugFn);
@@ -57,6 +60,7 @@ export function createContextProvider(name) {
         }
     }
     return {
+        [`tryGetCurrent${name}Context`](...args) { return tryGetCurrentContext(...args); },
         [`getCurrent${name}Context`](...args) { return getCurrentContext(...args); },
         [`setCurrent${name}Context`](...args) { return setCurrentContext(...args); },
         [`runIn${name}Context`](...args) { return runInContext(...args); },

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

@@ -369,7 +369,7 @@ export declare const documentManagementApiDefinition: {
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: string;
-                state: "error" | "pending" | "running" | "completed" | "review" | "failed";
+                state: "error" | "pending" | "running" | "completed" | "failed" | "review";
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;
@@ -785,7 +785,7 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             method: "POST";
             parameters: import("../../schema/index.js").ObjectSchema<{
                 id: string;
-                state: "error" | "pending" | "running" | "completed" | "review" | "failed";
+                state: "error" | "pending" | "running" | "completed" | "failed" | "review";
             }>;
             result: import("../../schema/index.js").LiteralSchema<"ok">;
             credentials: true;

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

@@ -236,7 +236,7 @@ export declare const addOrArchiveDocumentToOrFromCollectionParametersSchema: imp
 }>;
 export declare const proceedDocumentWorkflowParametersSchema: import("../../schema/index.js").ObjectSchema<{
     id: string;
-    state: "error" | "pending" | "running" | "completed" | "review" | "failed";
+    state: "error" | "pending" | "running" | "completed" | "failed" | "review";
 }>;
 export type MetadataParameter = SchemaOutput<typeof metadataParameterObjectSchema>;
 export type LoadDataParameters = SchemaOutput<typeof loadDataParametersSchema>;

package/file/mime-type.d.ts

@@ -1,3 +1,3 @@
-export declare function getMimeType(file: string | Uint8Array | ReadableStream<Uint8Array>): Promise<string | undefined>;
-export declare function getMimeType<F>(file: string | Uint8Array | ReadableStream<Uint8Array>, fallback: F): Promise<string | F>;
+export declare function getMimeType(file: Uint8Array | ReadableStream<Uint8Array>): Promise<string | undefined>;
+export declare function getMimeType<F>(file: Uint8Array | ReadableStream<Uint8Array>, fallback: F): Promise<string | F>;
 export declare function getMimeTypeExtensions(mimeType: string): string[];

package/file/mime-type.js

@@ -1,10 +1,9 @@
-import { fileTypeFromBuffer, fileTypeFromFile, fileTypeFromStream } from 'file-type/node';
-import { isReadableStream, isString, isUint8Array } from '../utils/type-guards.js';
+import { fileTypeFromBuffer, fileTypeFromStream } from 'file-type';
 import { match } from 'ts-pattern';
+import { isReadableStream, isUint8Array } from '../utils/type-guards.js';
 import { mimeTypesMap } from './mime-types.js';
 export async function getMimeType(file, fallback) {
     const result = await match(file)
-        .when(isString, async (f) => await fileTypeFromFile(f))
         .when(isUint8Array, async (f) => await fileTypeFromBuffer(f))
         .when((isReadableStream), async (f) => await fileTypeFromStream(f))
         .exhaustive();

package/file/server/index.d.ts

@@ -1 +1,2 @@
+export * from './mime-type.js';
 export * from './temporary-file.js';

package/file/server/index.js

@@ -1 +1,2 @@
+export * from './mime-type.js';
 export * from './temporary-file.js';

package/file/server/mime-type.d.ts

@@ -0,0 +1,2 @@
+export declare function getMimeTypeFromFile(path: string): Promise<string | undefined>;
+export declare function getMimeTypeFromFile<F>(path: string, fallback: F): Promise<string | F>;

package/file/server/mime-type.js

@@ -0,0 +1,5 @@
+import { fileTypeFromFile } from 'file-type/node';
+export async function getMimeTypeFromFile(path, fallback) {
+    const result = await fileTypeFromFile(path);
+    return result?.mime ?? fallback;
+}

package/notification/api/notification.api.d.ts

@@ -0,0 +1,78 @@
+import { ServerSentEvents } from '../../sse/server-sent-events.js';
+export declare const notificationApiDefinition: {
+    resource: string;
+    endpoints: {
+        stream: {
+            resource: string;
+            method: "GET";
+            result: typeof ServerSentEvents;
+        };
+        listInApp: {
+            resource: string;
+            method: "GET";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                offset?: number | undefined;
+                limit?: number | undefined;
+                includeArchived?: boolean | undefined;
+            }>;
+            result: import("../../schema/index.js").ArraySchema<{
+                type: string;
+                id: string;
+                createdAt: number;
+                priority: string;
+                logId: string;
+                payload?: {} | undefined;
+                readAt?: number | undefined;
+                archivedAt?: number | undefined;
+            }>;
+        };
+        markRead: {
+            resource: string;
+            method: "POST";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                id: string;
+            }>;
+            result: import("../../schema/index.js").LiteralSchema<"ok">;
+        };
+        archive: {
+            resource: string;
+            method: "POST";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                id: string;
+            }>;
+            result: import("../../schema/index.js").LiteralSchema<"ok">;
+        };
+        getPreferences: {
+            resource: string;
+            method: "GET";
+            result: import("../../schema/index.js").ArraySchema<{
+                enabled: boolean;
+                channel: string;
+                categoryId: string;
+            }>;
+        };
+        updatePreference: {
+            resource: string;
+            method: "POST";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                readonly categoryId: string;
+                readonly channel: string;
+                readonly enabled: boolean;
+            }>;
+            result: import("../../schema/index.js").LiteralSchema<"ok">;
+        };
+        registerWebPush: {
+            resource: string;
+            method: "POST";
+            parameters: import("../../schema/index.js").ObjectSchema<{
+                readonly endpoint: string;
+                readonly keys: {
+                    auth: string;
+                    p256dh: string;
+                };
+            }>;
+            result: import("../../schema/index.js").LiteralSchema<"ok">;
+        };
+    };
+};
+export type NotificationApiDefinition = typeof notificationApiDefinition;

package/notification/api/notification.api.js

@@ -0,0 +1,81 @@
+import { defineApi } from '../../api/types.js';
+import { boolean, explicitObject, literal, number, object, optional, string, array, unknown } from '../../schema/index.js';
+import { NotificationChannel } from '../enums.js';
+import { ServerSentEvents } from '../../sse/server-sent-events.js';
+export const notificationApiDefinition = defineApi({
+    resource: 'notification',
+    endpoints: {
+        stream: {
+            resource: 'stream',
+            method: 'GET',
+            result: ServerSentEvents,
+        },
+        listInApp: {
+            resource: 'in-app',
+            method: 'GET',
+            parameters: object({
+                limit: optional(number()),
+                offset: optional(number()),
+                includeArchived: optional(boolean()),
+            }),
+            result: array(object({
+                id: string(),
+                logId: string(),
+                readAt: optional(number()),
+                archivedAt: optional(number()),
+                // Add more joined fields from Log if needed, or return polymorphic payload
+                type: string(),
+                priority: string(),
+                createdAt: number(),
+                payload: optional(object({})),
+            })),
+        },
+        markRead: {
+            resource: 'in-app/:id/read',
+            method: 'POST',
+            parameters: object({
+                id: string(),
+            }),
+            result: literal('ok'),
+        },
+        archive: {
+            resource: 'in-app/:id/archive',
+            method: 'POST',
+            parameters: object({
+                id: string(),
+            }),
+            result: literal('ok'),
+        },
+        getPreferences: {
+            resource: 'preferences',
+            method: 'GET',
+            result: array(object({
+                categoryId: string(),
+                channel: string(),
+                enabled: boolean(),
+            })),
+        },
+        updatePreference: {
+            resource: 'preferences',
+            method: 'POST',
+            parameters: explicitObject({
+                categoryId: string(),
+                channel: string(),
+                enabled: boolean(),
+            }),
+            result: literal('ok'),
+        },
+        registerWebPush: {
+            resource: 'web-push/register',
+            method: 'POST',
+            parameters: explicitObject({
+                endpoint: string(),
+                keys: object({
+                    p256dh: string(),
+                    auth: string(),
+                }),
+            }),
+            result: literal('ok'),
+        },
+    },
+});

package/notification/enums.d.ts

@@ -0,0 +1,22 @@
+import { type EnumType } from '../enumeration/index.js';
+export declare const NotificationChannel: {
+    readonly InApp: "in-app";
+    readonly Email: "email";
+    readonly WebPush: "web-push";
+};
+export type NotificationChannel = EnumType<typeof NotificationChannel>;
+export declare const NotificationPriority: {
+    readonly Low: "low";
+    readonly Medium: "medium";
+    readonly High: "high";
+    readonly Urgent: "urgent";
+};
+export type NotificationPriority = EnumType<typeof NotificationPriority>;
+export declare const NotificationStatus: {
+    readonly Pending: "pending";
+    readonly Sent: "sent";
+    readonly Delivered: "delivered";
+    readonly Read: "read";
+    readonly Failed: "failed";
+};
+export type NotificationStatus = EnumType<typeof NotificationStatus>;

package/notification/enums.js

@@ -0,0 +1,19 @@
+import { defineEnum } from '../enumeration/index.js';
+export const NotificationChannel = defineEnum('NotificationChannel', {
+    InApp: 'in-app',
+    Email: 'email',
+    WebPush: 'web-push',
+});
+export const NotificationPriority = defineEnum('NotificationPriority', {
+    Low: 'low',
+    Medium: 'medium',
+    High: 'high',
+    Urgent: 'urgent',
+});
+export const NotificationStatus = defineEnum('NotificationStatus', {
+    Pending: 'pending',
+    Sent: 'sent',
+    Delivered: 'delivered',
+    Read: 'read',
+    Failed: 'failed',
+});

package/notification/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enums.js';
+export * from './models/index.js';

package/notification/index.js

@@ -0,0 +1,2 @@
+export * from './enums.js';
+export * from './models/index.js';

package/notification/models/in-app-notification.model.d.ts

@@ -0,0 +1,9 @@
+import { TenantEntity, type Uuid } from '../../orm/index.js';
+import type { Timestamp } from '../../orm/types.js';
+export declare class InAppNotification extends TenantEntity {
+    static readonly entityName = "InAppNotification";
+    userId: Uuid;
+    logId: Uuid;
+    readAt: Timestamp | null;
+    archivedAt: Timestamp | null;
+}

package/notification/models/in-app-notification.model.js

@@ -0,0 +1,42 @@
+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 { User } from '../../authentication/models/user.model.js';
+import { TenantEntity, TenantReference, TimestampProperty, UuidProperty } from '../../orm/index.js';
+import { NotificationLog } from './notification-log.model.js';
+import { NotificationTable } from './notification-table.js';
+let InAppNotification = class InAppNotification extends TenantEntity {
+    static entityName = 'InAppNotification';
+    userId;
+    logId;
+    readAt;
+    archivedAt;
+};
+__decorate([
+    UuidProperty(),
+    TenantReference(() => User),
+    __metadata("design:type", String)
+], InAppNotification.prototype, "userId", void 0);
+__decorate([
+    UuidProperty(),
+    TenantReference(() => NotificationLog),
+    __metadata("design:type", String)
+], InAppNotification.prototype, "logId", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], InAppNotification.prototype, "readAt", void 0);
+__decorate([
+    TimestampProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], InAppNotification.prototype, "archivedAt", void 0);
+InAppNotification = __decorate([
+    NotificationTable({ name: 'in_app' })
+], InAppNotification);
+export { InAppNotification };

package/notification/models/index.d.ts

@@ -0,0 +1,6 @@
+export * from './in-app-notification.model.js';
+export * from './notification-category.model.js';
+export * from './notification-log.model.js';
+export * from './notification-preference.model.js';
+export * from './notification-table.js';
+export * from './web-push-subscription.model.js';

package/notification/models/index.js

@@ -0,0 +1,6 @@
+export * from './in-app-notification.model.js';
+export * from './notification-category.model.js';
+export * from './notification-log.model.js';
+export * from './notification-preference.model.js';
+export * from './notification-table.js';
+export * from './web-push-subscription.model.js';

package/notification/models/notification-category.model.d.ts

@@ -0,0 +1,17 @@
+import { TenantEntity } from '../../orm/index.js';
+import { NotificationChannel } from '../enums.js';
+export type ThrottlingConfig = {
+    limit: number;
+    intervalMs: number;
+};
+export type EscalationRule = {
+    delayMs: number;
+    channel: NotificationChannel;
+};
+export declare class NotificationCategory extends TenantEntity {
+    static readonly entityName = "NotificationCategory";
+    label: string;
+    key: string;
+    throttling: ThrottlingConfig | null;
+    escalations: EscalationRule[] | null;
+}

package/notification/models/notification-category.model.js

@@ -0,0 +1,41 @@
+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 { JsonProperty, TenantEntity, Unique } from '../../orm/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { NotificationChannel } from '../enums.js';
+import { NotificationTable } from './notification-table.js';
+let NotificationCategory = class NotificationCategory extends TenantEntity {
+    static entityName = 'NotificationCategory';
+    label;
+    key;
+    throttling;
+    escalations;
+};
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], NotificationCategory.prototype, "label", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], NotificationCategory.prototype, "key", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], NotificationCategory.prototype, "throttling", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], NotificationCategory.prototype, "escalations", void 0);
+NotificationCategory = __decorate([
+    NotificationTable({ name: 'category' }),
+    Unique(['tenantId', 'key'])
+], NotificationCategory);
+export { NotificationCategory };

package/notification/models/notification-log.model.d.ts

@@ -0,0 +1,13 @@
+import { type Json, TenantEntity, type Uuid } from '../../orm/index.js';
+import type { ObjectLiteral } from '../../types/types.js';
+import { NotificationPriority, NotificationStatus } from '../enums.js';
+export declare class NotificationLog extends TenantEntity {
+    static readonly entityName = "NotificationLog";
+    userId: Uuid;
+    categoryId: Uuid;
+    type: string;
+    priority: NotificationPriority;
+    status: NotificationStatus;
+    currentStep: number;
+    payload: Json<ObjectLiteral> | null;
+}

package/notification/models/notification-log.model.js

@@ -0,0 +1,59 @@
+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 { User } from '../../authentication/models/user.model.js';
+import { JsonProperty, TenantEntity, TenantReference, UuidProperty } from '../../orm/index.js';
+import { Enumeration, Integer, StringProperty } from '../../schema/index.js';
+import { NotificationPriority, NotificationStatus } from '../enums.js';
+import { NotificationCategory } from './notification-category.model.js';
+import { NotificationTable } from './notification-table.js';
+let NotificationLog = class NotificationLog extends TenantEntity {
+    static entityName = 'NotificationLog';
+    userId;
+    categoryId;
+    type;
+    priority;
+    status;
+    currentStep;
+    payload;
+};
+__decorate([
+    UuidProperty(),
+    TenantReference(() => User),
+    __metadata("design:type", String)
+], NotificationLog.prototype, "userId", void 0);
+__decorate([
+    UuidProperty(),
+    TenantReference(() => NotificationCategory),
+    __metadata("design:type", String)
+], NotificationLog.prototype, "categoryId", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], NotificationLog.prototype, "type", void 0);
+__decorate([
+    Enumeration(NotificationPriority),
+    __metadata("design:type", String)
+], NotificationLog.prototype, "priority", void 0);
+__decorate([
+    Enumeration(NotificationStatus),
+    __metadata("design:type", String)
+], NotificationLog.prototype, "status", void 0);
+__decorate([
+    Integer(),
+    __metadata("design:type", Number)
+], NotificationLog.prototype, "currentStep", void 0);
+__decorate([
+    JsonProperty({ nullable: true }),
+    __metadata("design:type", Object)
+], NotificationLog.prototype, "payload", void 0);
+NotificationLog = __decorate([
+    NotificationTable({ name: 'log' })
+], NotificationLog);
+export { NotificationLog };

package/notification/models/notification-preference.model.d.ts

@@ -0,0 +1,9 @@
+import { TenantEntity, type Uuid } from '../../orm/index.js';
+import { NotificationChannel } from '../enums.js';
+export declare class NotificationPreference extends TenantEntity {
+    static readonly entityName = "NotificationPreference";
+    userId: Uuid;
+    categoryId: Uuid;
+    channel: NotificationChannel;
+    enabled: boolean;
+}

package/notification/models/notification-preference.model.js

@@ -0,0 +1,45 @@
+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 { User } from '../../authentication/models/user.model.js';
+import { TenantEntity, TenantReference, Unique, UuidProperty } from '../../orm/index.js';
+import { BooleanProperty, Enumeration } from '../../schema/index.js';
+import { NotificationChannel } from '../enums.js';
+import { NotificationCategory } from './notification-category.model.js';
+import { NotificationTable } from './notification-table.js';
+let NotificationPreference = class NotificationPreference extends TenantEntity {
+    static entityName = 'NotificationPreference';
+    userId;
+    categoryId;
+    channel;
+    enabled;
+};
+__decorate([
+    UuidProperty(),
+    TenantReference(() => User),
+    __metadata("design:type", String)
+], NotificationPreference.prototype, "userId", void 0);
+__decorate([
+    UuidProperty(),
+    TenantReference(() => NotificationCategory),
+    __metadata("design:type", String)
+], NotificationPreference.prototype, "categoryId", void 0);
+__decorate([
+    Enumeration(NotificationChannel),
+    __metadata("design:type", String)
+], NotificationPreference.prototype, "channel", void 0);
+__decorate([
+    BooleanProperty(),
+    __metadata("design:type", Boolean)
+], NotificationPreference.prototype, "enabled", void 0);
+NotificationPreference = __decorate([
+    NotificationTable({ name: 'preference' }),
+    Unique(['tenantId', 'userId', 'categoryId', 'channel'])
+], NotificationPreference);
+export { NotificationPreference };

package/notification/models/notification-table.d.ts

@@ -0,0 +1,3 @@
+import { type TableOptions } from '../../orm/index.js';
+import type { TypedOmit } from '../../types/index.js';
+export declare function NotificationTable(options?: TypedOmit<TableOptions, 'schema'>): ClassDecorator;

package/notification/models/notification-table.js

@@ -0,0 +1,4 @@
+import { Table } from '../../orm/index.js';
+export function NotificationTable(options) {
+    return Table({ ...options, schema: 'notification' });
+}

package/notification/models/web-push-subscription.model.d.ts

@@ -0,0 +1,8 @@
+import { TenantEntity, type Uuid } from '../../orm/index.js';
+export declare class WebPushSubscription extends TenantEntity {
+    static readonly entityName = "WebPushSubscription";
+    userId: Uuid;
+    endpoint: string;
+    p256dh: string;
+    auth: string;
+}

package/notification/models/web-push-subscription.model.js

@@ -0,0 +1,41 @@
+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 { User } from '../../authentication/models/user.model.js';
+import { TenantEntity, TenantReference, UuidProperty } from '../../orm/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { NotificationTable } from './notification-table.js';
+let WebPushSubscription = class WebPushSubscription extends TenantEntity {
+    static entityName = 'WebPushSubscription';
+    userId;
+    endpoint;
+    p256dh;
+    auth;
+};
+__decorate([
+    UuidProperty(),
+    TenantReference(() => User),
+    __metadata("design:type", String)
+], WebPushSubscription.prototype, "userId", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], WebPushSubscription.prototype, "endpoint", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], WebPushSubscription.prototype, "p256dh", void 0);
+__decorate([
+    StringProperty(),
+    __metadata("design:type", String)
+], WebPushSubscription.prototype, "auth", void 0);
+WebPushSubscription = __decorate([
+    NotificationTable({ name: 'web_push_subscription' })
+], WebPushSubscription);
+export { WebPushSubscription };