@tstdl/base 0.93.97 → 0.93.99

package/intl/number-parser.js

@@ -1,12 +1,12 @@
 import { createArray } from '../utils/array/array.js';
 import { memoizeClassSingle } from '../utils/function/memoize.js';
 export class NumberParser {
-    group;
-    decimal;
-    numeral;
-    loosePattern;
-    numeralIndex;
-    numeralReplacer;
+    #group;
+    #decimal;
+    #numeral;
+    #loosePattern;
+    #numeralIndex;
+    #numeralReplacer;
     locale;
     constructor(locale) {
         this.locale = locale;
@@ -14,28 +14,40 @@ export class NumberParser {
         const parts = format.formatToParts(12345.6);
         const numerals = createArray(10, (i) => format.format(i));
         const numeralPattern = `[${numerals.join('')}]`;
-        this.numeralIndex = new Map(numerals.map((d, i) => [d, i.toString()]));
-        this.group = parts.find((part) => part.type == 'group').value;
-        this.decimal = parts.find((part) => part.type == 'decimal').value;
-        this.numeral = new RegExp(numeralPattern, 'ug');
-        this.loosePattern = new RegExp(`[^${numerals.join()}${this.group}${this.decimal}]`, 'ug');
-        this.numeralReplacer = (numeral) => this.numeralIndex.get(numeral);
+        this.#numeralIndex = new Map(numerals.map((d, i) => [d, i.toString()]));
+        this.#group = parts.find((part) => part.type == 'group').value;
+        this.#decimal = parts.find((part) => part.type == 'decimal').value;
+        this.#numeral = new RegExp(numeralPattern, 'ug');
+        this.#loosePattern = new RegExp(`[^${numerals.join()}${this.#group}${this.#decimal}]`, 'ug');
+        this.#numeralReplacer = (numeral) => this.#numeralIndex.get(numeral);
     }
     /**
-     * Parse a string
-     * @param value Value to parse
-     * @param loose Try to parse an invalid string by removing unsupported characters. Might produce incorrect results, depending on input
+     * Parse a string.
+     * @param value Value to parse.
+     * @param loose Try to parse an invalid string by removing unsupported characters. Might produce incorrect results, depending on input.
      */
     parse(value, loose = false) {
-        const source = loose ? value.replaceAll(this.loosePattern, '') : value;
+        const source = loose ? value.replaceAll(this.#loosePattern, '') : value;
         const normalized = source.trim()
-            .replaceAll(this.group, '')
-            .replaceAll(this.decimal, '.')
-            .replaceAll(this.numeral, this.numeralReplacer);
+            .replaceAll(this.#group, '')
+            .replaceAll(this.#decimal, '.')
+            .replaceAll(this.#numeral, this.#numeralReplacer);
         return Number(normalized);
     }
 }
+/**
+ * Get a memoized {@link NumberParser} instance for a given locale.
+ * @param locale The locale to get the parser for.
+ * @returns A {@link NumberParser} instance.
+ */
 export const getNumberParser = memoizeClassSingle(NumberParser);
+/**
+ * Parses a localized number string into a standard JavaScript number.
+ * @param locale The locale of the number string.
+ * @param value The string to parse.
+ * @param loose Whether to use loose parsing (stripping non-numeric characters).
+ * @returns The parsed number, or `NaN` if parsing fails.
+ */
 export function parseNumber(locale, value, loose) {
     return getNumberParser(locale).parse(value, loose);
 }

package/module/module.js

@@ -44,6 +44,9 @@ export class Module {
         }
     }
     async stop() {
+        if (this._state == ModuleState.Running) {
+            this._state = ModuleState.Stopping;
+        }
         this.cancellationToken.set();
         await this.runPromise.catch(() => { });
     }

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 };

package/notification/server/api/notification.api-controller.d.ts

@@ -0,0 +1,16 @@
+import type { ApiController, ApiRequestContext } from '../../../api/types.js';
+import type { NotificationApiDefinition } from '../../api/notification.api.js';
+import { NotificationService } from '../services/notification.service.js';
+import { NotificationSseService } from '../services/notification-sse.service.js';
+import type { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
+export declare class NotificationApiController implements ApiController<NotificationApiDefinition> {
+    protected readonly notificationService: NotificationService;
+    protected readonly sseService: NotificationSseService;
+    stream({ getToken }: ApiRequestContext<NotificationApiDefinition, 'stream'>): Promise<ServerSentEventsSource>;
+    listInApp({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'listInApp'>): Promise<any>;
+    markRead({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'markRead'>): Promise<'ok'>;
+    archive({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'archive'>): Promise<'ok'>;
+    getPreferences({ getToken }: ApiRequestContext<NotificationApiDefinition, 'getPreferences'>): Promise<any>;
+    updatePreference({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'updatePreference'>): Promise<'ok'>;
+    registerWebPush({ parameters, getToken }: ApiRequestContext<NotificationApiDefinition, 'registerWebPush'>): Promise<'ok'>;
+}