@liorian/sdk 0.28.0-alpha.56010ca

package/src/application/index.ts

@@ -0,0 +1,3 @@
+// @liorian/sdk/application — application-level services & orchestration.
+export * from "./module-instance";
+export * from "./service/index";

package/src/application/module-instance.ts

@@ -0,0 +1,36 @@
+import {ModuleDeclarationInterface, ModuleInstanceInterface} from "../domain/entities/module.interface";
+import {useModuleStore} from "../infrastructure/stores/module.store";
+
+export class ModuleInstance implements ModuleInstanceInterface {
+
+    protected declaration!: ModuleDeclarationInterface;
+
+    constructor(public readonly identifier: string) {
+        this.initialize();
+    }
+
+    protected initialize() {
+        const {modules} = useModuleStore.getState();
+        const find = modules.find(
+            module => module.key === this.identifier || module.identifier === this.identifier
+        );
+
+        if (!find)
+            throw new Error(`Module with identifier ${this.identifier} not found`);
+
+        this.declaration = find;
+    }
+
+    getOption<K extends keyof ModuleDeclarationInterface>(key: K): ModuleDeclarationInterface[K] {
+        return this.declaration[key];
+    }
+
+    get options(): ModuleDeclarationInterface {
+        return this.declaration;
+    }
+
+    setOption<K extends keyof ModuleDeclarationInterface>(key: K, value: ModuleDeclarationInterface[K]): this {
+        this.declaration[key] = value;
+        return this;
+    }
+}

package/src/application/service/auth-api-service.ts

@@ -0,0 +1,291 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {AuthUserService} from "./auth-user.service";
+import {
+    type CreateUserAccountInterface,
+    type CreateUserSessionInterface
+} from "../../domain/typing/session.interface";
+import {
+    UserAuthResponseInterface,
+    UserAuthSessionCheckingResponseInterface
+} from "../../domain/entities/user-auth.interface";
+import {FetchResponseInterface} from "../../domain/typing/response";
+import {AuthConfig} from "../../domain/config/auth.config";
+import type {
+    AuthFactor,
+    AuthMethod,
+    AuthorizeClient,
+    AuthorizeParams,
+    AuthorizePasskeyOptions,
+    AuthorizedApplication,
+    ConsentResolution,
+    CreateOAuthClientInput,
+    EnrollTotpResponse,
+    MfaChallengeResponse,
+    MfaVerifyResponse,
+    OAuthClient,
+    OAuthScope,
+    OtpChannel,
+    OtpCreateResponse,
+    RecoveryCodesResponse,
+    ScopeDescriptor,
+    UserInfo,
+    WebAuthnOptions,
+} from "../../domain/typing/auth-oauth.types";
+
+/** Décapsule le payload `data` de l'enveloppe Raiton `{message, data, status}`. */
+async function unwrap<T>(promise: Promise<{data: FetchResponseInterface<T>}>): Promise<T> {
+    const response = await promise;
+    return response?.data?.data as T;
+}
+
+/** Décodage base64url → ArrayBuffer (WebAuthn exige des BufferSource côté navigateur). */
+function base64UrlToBuffer(base64Url: string): ArrayBuffer {
+    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
+    const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+    const binary = atob(padded);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes.buffer;
+}
+
+/** Convertit un BufferSource WebAuthn en tableau de bytes (sérialisable en JSON pour l'API). */
+export function webauthnBytes(value: ArrayBufferView | ArrayBuffer | null | undefined): number[] | undefined {
+    if (value == null) {
+        return undefined;
+    }
+    const buffer = value instanceof ArrayBuffer
+        ? value
+        : (value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength) as ArrayBuffer);
+    return Array.from(new Uint8Array(buffer));
+}
+
+/** Prépare les options WebAuthn reçues de l'API pour `navigator.credentials` (challenge → ArrayBuffer). */
+function prepareWebAuthnOptions<T extends WebAuthnOptions>(options: T): T {
+    if (typeof options.challenge === 'string' && options.challenge.length > 0) {
+        options.challenge = base64UrlToBuffer(options.challenge);
+    }
+    if (options.user && typeof options.user.id === 'string' && options.user.id.length > 0) {
+        options.user.id = new TextEncoder().encode(options.user.id);
+    }
+    return options;
+}
+
+export class AuthApiService extends ApiService {
+    static async fetchAvailableSessions() {
+        // Les tokens/infos de l'utilisateur doivent être disponibles en local
+        // avant de vérifier la validité de la session.
+        await AuthUserService.ready();
+        const token = AuthUserService.getToken();
+        const device = AuthUserService.getDevice();
+
+        if (!token) return undefined;
+        return this.post<FetchResponseInterface<UserAuthSessionCheckingResponseInterface>>(`/auth/sessions`, {
+            token,
+            device
+        });
+    }
+
+    static async signIn(payload: CreateUserSessionInterface & { identifierType?: 'email' | 'phone' | 'username' }) {
+        const { identifierType, ...rest } = payload;
+        const body: Record<string, string | undefined> = { password: rest.password };
+
+        if (identifierType === 'email') {
+            body.email = rest.username;
+        } else if (identifierType === 'phone') {
+            body.phone = rest.username;
+            body.prefix = rest.prefix;
+        } else {
+            body.username = rest.username;
+        }
+
+        return await this.post<FetchResponseInterface<UserAuthResponseInterface>>(`${AuthConfig.routes.login}`, body)
+    }
+
+    static async signUp(payload: CreateUserAccountInterface) {
+        return await this.post<FetchResponseInterface<UserAuthResponseInterface>>(`${AuthConfig.routes.register}`, payload)
+    }
+
+    /**
+     * Vérifie le mot de passe de l'utilisateur actuellement connecté (session valide).
+     * Aucune nouvelle session n'est créée : utilisé notamment pour déverrouiller l'écran.
+     */
+    static async verifyPassword(password: string) {
+        return await this.post<FetchResponseInterface<{valid: boolean}>>('/auth/verify-password', {password})
+    }
+
+    static async checkPhone(phone: string) {
+        return await this.get<FetchResponseInterface<any>>(`${AuthConfig.routes.verifyPhone}`, {phone})
+    }
+
+    static async verifyPhone(payload: { phone: string; code: string }) {
+        return await this.post<FetchResponseInterface<any>>(`${AuthConfig.routes.verifyPhone}`, payload)
+    }
+
+    /* ----------------------------- MFA / challenge ----------------------- */
+
+    /** Déclenche un challenge MFA et liste les facteurs activés. */
+    static async mfaChallenge(): Promise<MfaChallengeResponse> {
+        return unwrap(this.post<FetchResponseInterface<MfaChallengeResponse>>('/mfa/challenge', {}));
+    }
+
+    static async listFactors(): Promise<AuthFactor[]> {
+        const res = await this.mfaChallenge();
+        return res.factors ?? [];
+    }
+
+    /* ----------------------------- TOTP ---------------------------------- */
+
+    static async totpEnroll(issuer?: string): Promise<EnrollTotpResponse> {
+        return unwrap(this.post<FetchResponseInterface<EnrollTotpResponse>>('/mfa/totp/enroll', {issuer}));
+    }
+
+    static async totpVerify(code: string): Promise<MfaVerifyResponse> {
+        return unwrap(this.post<FetchResponseInterface<MfaVerifyResponse>>('/mfa/totp/verify', {code}));
+    }
+
+    /* ----------------------------- WebAuthn ------------------------------ */
+
+    static async webauthnRegisterOptions(deviceName?: string): Promise<WebAuthnOptions> {
+        const options = await unwrap(this.post<FetchResponseInterface<WebAuthnOptions>>('/mfa/webauthn/register/options', {deviceName}));
+        return prepareWebAuthnOptions(options);
+    }
+
+    static async webauthnRegisterVerify(attestationResponse: unknown): Promise<MfaVerifyResponse> {
+        return unwrap(this.post<FetchResponseInterface<MfaVerifyResponse>>('/mfa/webauthn/register/verify', {attestationResponse}));
+    }
+
+    static async webauthnAuthnOptions(): Promise<WebAuthnOptions> {
+        const options = await unwrap(this.post<FetchResponseInterface<WebAuthnOptions>>('/mfa/webauthn/authenticate/options', {}));
+        return prepareWebAuthnOptions(options);
+    }
+
+    static async webauthnAuthnVerify(assertionResponse: unknown): Promise<MfaVerifyResponse> {
+        return unwrap(this.post<FetchResponseInterface<MfaVerifyResponse>>('/mfa/webauthn/authenticate/verify', {assertionResponse}));
+    }
+
+    /* ----------------------------- Récupération -------------------------- */
+
+    static async recoveryCodesGenerate(): Promise<RecoveryCodesResponse> {
+        return unwrap(this.post<FetchResponseInterface<RecoveryCodesResponse>>('/mfa/recovery-codes/generate', {}));
+    }
+
+    static async recoveryVerify(code: string): Promise<MfaVerifyResponse> {
+        return unwrap(this.post<FetchResponseInterface<MfaVerifyResponse>>('/mfa/recovery/verify', {code}));
+    }
+
+    /* ----------------------------- OTP (email / SMS) --------------------- */
+
+    static async otpRequest(channel: OtpChannel, identifier: string): Promise<OtpCreateResponse> {
+        return unwrap(this.post<FetchResponseInterface<OtpCreateResponse>>('/otp/create', {
+            ...(channel === 'email' ? {email: identifier} : {phone: identifier}),
+            channel: channel === 'email' ? 'EMAIL' : 'SMS',
+        }));
+    }
+
+    static async otpValidate(channel: OtpChannel, identifier: string, code: string): Promise<MfaVerifyResponse> {
+        return unwrap(this.post<FetchResponseInterface<MfaVerifyResponse>>('/otp/validate', {
+            ...(channel === 'email' ? {email: identifier} : {phone: identifier}),
+            code,
+        }));
+    }
+
+    /* ----------------------------- Consentement OAuth -------------------- */
+
+    static async describeAuthorize(params: AuthorizeParams): Promise<{client: AuthorizeClient; requestedScopes: ScopeDescriptor[]; alreadyAuthorized: boolean; canConsent: boolean}> {
+        return unwrap(this.post<FetchResponseInterface<{client: AuthorizeClient; requestedScopes: ScopeDescriptor[]; alreadyAuthorized: boolean; canConsent: boolean}>>('/oauth/authorize/describe', params));
+    }
+
+    static async authorizeDecision(params: AuthorizeParams & {approved: boolean}): Promise<ConsentResolution> {
+        return unwrap(this.post<FetchResponseInterface<ConsentResolution>>('/oauth/authorize', params));
+    }
+
+    static async authorizeVerify(params: AuthorizeParams & {code: string}): Promise<ConsentResolution> {
+        return unwrap(this.post<FetchResponseInterface<ConsentResolution>>('/oauth/authorize/verify', params));
+    }
+
+    static async sendOtp(): Promise<{sent: boolean; channel: string}> {
+        return unwrap(this.post<FetchResponseInterface<{sent: boolean; channel: string}>>('/oauth/authorize/otp', {}));
+    }
+
+    static async passkeyOptions(): Promise<AuthorizePasskeyOptions> {
+        const options = await unwrap(this.get<FetchResponseInterface<AuthorizePasskeyOptions>>('/oauth/authorize/passkey/options'));
+        if (typeof options.challenge === 'string' && options.challenge.length > 0) {
+            options.challenge = base64UrlToBuffer(options.challenge);
+        }
+        return options;
+    }
+
+    static async enablePasskey(): Promise<{enabled: boolean}> {
+        return unwrap(this.post<FetchResponseInterface<{enabled: boolean}>>('/oauth/authorize/passkey/enable', {}));
+    }
+
+    static async passkeyVerify(params: AuthorizeParams & {credentialId: string; assertionResponse: unknown}): Promise<ConsentResolution> {
+        return unwrap(this.post<FetchResponseInterface<ConsentResolution>>('/oauth/authorize/passkey/verify', params));
+    }
+
+    /* --------------------------- Apps autorisées ------------------------- */
+
+    static async userinfo(): Promise<UserInfo> {
+        return unwrap(this.get<FetchResponseInterface<UserInfo>>('/oauth/userinfo'));
+    }
+
+    static async listConsents(): Promise<AuthorizedApplication[]> {
+        return unwrap(this.get<FetchResponseInterface<AuthorizedApplication[]>>('/oauth/user/consents'));
+    }
+
+    static async revokeConsent(consentId: string): Promise<void> {
+        return unwrap(this.delete<FetchResponseInterface<void>>(`/oauth/user/consents/${consentId}`));
+    }
+
+    /* ----------------------- Catalogue des scopes ----------------------- */
+
+    static async listScopes(): Promise<OAuthScope[]> {
+        return unwrap(this.get<FetchResponseInterface<OAuthScope[]>>('/oauth/scopes'));
+    }
+
+    static async createScope(payload: Partial<OAuthScope> & {name: string}): Promise<OAuthScope> {
+        return unwrap(this.post<FetchResponseInterface<OAuthScope>>('/oauth/scopes', payload));
+    }
+
+    static async updateScope(id: string, payload: Partial<OAuthScope>): Promise<OAuthScope> {
+        return unwrap(this.put<FetchResponseInterface<OAuthScope>>(`/oauth/scopes/${id}`, payload));
+    }
+
+    static async deleteScope(id: string): Promise<void> {
+        return unwrap(this.delete<FetchResponseInterface<void>>(`/oauth/scopes/${id}`));
+    }
+
+    /* --------------------- Applications pré-enregistrées ----------------- */
+
+    static async listOAuthClients(): Promise<OAuthClient[]> {
+        return unwrap(this.get<FetchResponseInterface<OAuthClient[]>>('/oauth/clients'));
+    }
+
+    static async getOAuthClient(id: string): Promise<OAuthClient> {
+        return unwrap(this.get<FetchResponseInterface<OAuthClient>>(`/oauth/clients/${id}`));
+    }
+
+    static async createOAuthClient(payload: CreateOAuthClientInput): Promise<OAuthClient> {
+        return unwrap(this.post<FetchResponseInterface<OAuthClient>>('/oauth/clients', payload));
+    }
+
+    static async updateOAuthClient(id: string, payload: Partial<CreateOAuthClientInput> & {status?: string}): Promise<OAuthClient> {
+        return unwrap(this.put<FetchResponseInterface<OAuthClient>>(`/oauth/clients/${id}`, payload));
+    }
+
+    static async deleteOAuthClient(id: string): Promise<void> {
+        return unwrap(this.delete<FetchResponseInterface<void>>(`/oauth/clients/${id}`));
+    }
+
+    /* --------------------------- Méthodes MFA ---------------------------- */
+
+    static async listMethods(): Promise<AuthMethod[]> {
+        return unwrap(this.get<FetchResponseInterface<AuthMethod[]>>('/mfa/methods'));
+    }
+
+    static async removeMethod(methodId: string): Promise<void> {
+        return unwrap(this.delete<FetchResponseInterface<void>>(`/mfa/methods/${methodId}`));
+    }
+}

package/src/application/service/auth-user.service.ts

@@ -0,0 +1,108 @@
+"use client"
+
+import {CacheStorageCapability} from "../../infrastructure/capabilities/cache-storage/capability";
+import {AuthCacheInterface} from "../../domain/typing/auth-caches";
+import {CacheStorageType} from "../../infrastructure/capabilities/cache-storage/enum";
+import {UserInterface} from "../../domain/entities/user.interface";
+import {UserAuthResponseInterface} from "../../domain/entities/user-auth.interface";
+import {OrganizationInterface} from "../../domain/entities/organization.interface";
+import {AuthConfig} from "../../domain/config/auth.config";
+
+const instance = new CacheStorageCapability<AuthCacheInterface>(AuthConfig.storages.sessionKey, CacheStorageType.LOCAL);
+
+const setCookie = (name: string, value: string, days = 7) => {
+    if (typeof document === 'undefined') return;
+    const date = new Date();
+    date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+    const expires = "; expires=" + date.toUTCString();
+    document.cookie = name + "=" + encodeURIComponent(value) + expires + "; path=/; SameSite=Strict";
+}
+
+const deleteCookie = (name: string) => {
+    if (typeof document === 'undefined') return;
+    document.cookie = name + '=; Max-Age=-99999999; path=/;';
+}
+
+export class AuthUserService {
+
+    /** Attend que les données locales (token, user, …) soient chargées avant toute lecture. */
+    static async ready(): Promise<AuthCacheInterface> {
+        return instance.ready();
+    }
+
+    static getUser(): UserInterface | null {
+        return instance.get('user') ?? null;
+    }
+
+    static getToken(): string | null {
+        return instance.get('token') ?? null;
+    }
+
+    static getDevice(): string | null {
+        return instance.get('device') ?? null;
+    }
+
+    static getOrganizations(): OrganizationInterface[] {
+        return instance.get('organizations') ?? [];
+    }
+
+    static getCurrentOrganization(): OrganizationInterface | null {
+        return instance.get('currentOrganization') ?? null;
+    }
+
+    static getApiKey(): string | null {
+        return instance.get('apiKey') ?? null;
+    }
+
+    static isAuthenticated(): boolean {
+        return !!this.getToken();
+    }
+
+    static async setUser(user: UserInterface) {
+        await instance.set('user', user).save();
+    }
+
+    static async setToken(token: string) {
+        await instance.set('token', token).save();
+        setCookie('token', token);
+    }
+
+    static async setDevice(device: string) {
+        await instance.set('device', device).save();
+    }
+
+    static async setOrganizations(organizations: OrganizationInterface[]) {
+        await instance.set('organizations', organizations).save();
+    }
+
+    static async setCurrentOrganization(organization: OrganizationInterface) {
+        await instance.set('currentOrganization', organization).save();
+    }
+
+    static async setApiKey(apiKey: string) {
+        await instance.set('apiKey', apiKey).save();
+    }
+
+    static async setSession(payload: UserAuthResponseInterface) {
+        const {user, token, device, organizations} = payload;
+        instance
+            .set('user', user)
+            .set('token', token)
+            .set('device', device)
+            .set('organizations', organizations);
+
+        await instance.save();
+        setCookie('token', token);
+    }
+
+    static async clear() {
+        await instance.clear().save();
+        deleteCookie('token');
+    }
+
+    static getCsrfToken(): string | null {
+        if (typeof document === 'undefined') return null;
+        const match = document.cookie.match(/(?:^|;\s*)_csrf=([^;]*)/);
+        return match ? decodeURIComponent(match[1]) : null;
+    }
+}

package/src/application/service/index.ts

@@ -0,0 +1,12 @@
+// @liorian/sdk/application/service — API / application services.
+export * from "./auth-api-service";
+export * from "./auth-user.service";
+export * from "./module-activation-api.service";
+export * from "./storefront-api.service";
+export * from "./notifications-api-service";
+export * from "./notifications-push.service";
+export * from "./notifications-socket-service";
+export * from "./organizations-api-service";
+export * from "./otp-api-service";
+export * from "./storage-api-service";
+export * from "./user-preferences-api.service";

package/src/application/service/module-activation-api.service.ts

@@ -0,0 +1,105 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {FetchResponseInterface} from "../../domain/typing/response";
+import {
+    ActivateModulePayloadInterface,
+    ModuleActivationInterface,
+    ModuleStoreActivationResultInterface,
+    ModuleStoreConfigInterface,
+    ModuleStoreSyncPayloadInterface,
+    ModuleStoreSyncResultInterface,
+    ModuleUsageAnalyticsInterface,
+    ModuleUsageRecordPayloadInterface,
+    ValidateActivationResponseInterface
+} from "../../domain/entities/module-activation.interface";
+
+/**
+ * Service API pour l'activation des modules (runtime cœur).
+ *
+ * Cible `liorian-api-core` (base `/module-activation`) : activation,
+ * validation, clés sérielles, synchronisation et analytics d'usage.
+ * Le catalogue public est porté par {@link StorefrontApiService} (`/catalog`).
+ */
+export class ModuleActivationApiService extends ApiService {
+
+    /** Activer un module pour une organisation */
+    static async activateModule(organizationId: string, payload: ActivateModulePayloadInterface) {
+        return await this.post<FetchResponseInterface<ModuleStoreActivationResultInterface>>(
+            `/module-activation/organizations/${organizationId}/activate`,
+            payload
+        );
+    }
+
+    /** Valider l'activation d'un module pour une organisation */
+    static async validateActivation(organizationId: string, moduleIdentifier: string) {
+        return await this.get<FetchResponseInterface<ValidateActivationResponseInterface>>(
+            `/module-activation/organizations/${organizationId}/modules/${moduleIdentifier}/validate`
+        );
+    }
+
+    /** Lister les modules activés pour une organisation */
+    static async getOrganizationModules(organizationId: string) {
+        return await this.get<FetchResponseInterface<ModuleActivationInterface[]>>(
+            `/module-activation/organizations/${organizationId}/modules`
+        );
+    }
+
+    /** Désactiver un module pour une organisation */
+    static async deactivateModule(organizationId: string, moduleIdentifier: string) {
+        return await this.delete(
+            `/module-activation/organizations/${organizationId}/modules/${moduleIdentifier}`
+        );
+    }
+
+    /** Lister les clés série d'un module */
+    static async getSerialKeys(moduleIdentifier: string) {
+        return await this.get(`/module-activation/modules/${moduleIdentifier}/serial-keys`);
+    }
+
+    /** Créer une clé série pour un module (SuperAdmin) */
+    static async createSerialKey(moduleIdentifier: string) {
+        return await this.post(`/module-activation/modules/${moduleIdentifier}/serial-keys`, {});
+    }
+
+    /** Supprimer une clé série (SuperAdmin) */
+    static async deleteSerialKey(keyId: string) {
+        return await this.delete(`/module-activation/serial-keys/${keyId}`);
+    }
+
+    /** Récupérer la configuration d'un module pour une organisation */
+    static async getModuleConfig(organizationId: string, moduleIdentifier: string) {
+        return await this.get<FetchResponseInterface<ModuleStoreConfigInterface>>(
+            `/module-activation/organizations/${organizationId}/modules/${moduleIdentifier}/config`
+        );
+    }
+
+    /** Sauvegarder la configuration d'un module pour une organisation */
+    static async saveModuleConfig(organizationId: string, moduleIdentifier: string, settings: Record<string, string>) {
+        return await this.post<FetchResponseInterface<ModuleStoreConfigInterface>>(
+            `/module-activation/organizations/${organizationId}/modules/${moduleIdentifier}/config`,
+            {settings}
+        );
+    }
+
+    /** Synchroniser l'état local des modules avec le backend */
+    static async syncModules(organizationId: string, payload: ModuleStoreSyncPayloadInterface) {
+        return await this.post<FetchResponseInterface<ModuleStoreSyncResultInterface>>(
+            `/module-activation/organizations/${organizationId}/modules/sync`,
+            payload
+        );
+    }
+
+    /** Enregistrer l'usage d'un module (temps + fréquence) — respecte le consentement de partage */
+    static async recordModuleUsage(organizationId: string, payload: ModuleUsageRecordPayloadInterface) {
+        return await this.post<FetchResponseInterface<{consented: boolean; tracked: boolean}>>(
+            `/module-activation/analytics/usage`,
+            payload
+        );
+    }
+
+    /** Récupérer les analytics d'usage des modules (scope : organization | user) */
+    static async getModuleUsageAnalytics(organizationId: string, scope: 'organization' | 'user' = 'organization') {
+        return await this.get<FetchResponseInterface<ModuleUsageAnalyticsInterface>>(
+            `/module-activation/analytics/usage?scope=${scope}`
+        );
+    }
+}

package/src/application/service/notifications-api-service.ts

@@ -0,0 +1,38 @@
+import {ApiService} from "../../infrastructure/utilities/api-service";
+import {PaginationWithSearchOptions} from "../../domain/typing/response";
+
+export interface PushSubscriptionKeys {
+    p256dh: string;
+    auth: string;
+}
+
+export interface PushSubscriptionPayload {
+    endpoint: string;
+    keys: PushSubscriptionKeys;
+}
+
+export class NotificationsApiService extends ApiService {
+    static async getAll(options?: PaginationWithSearchOptions & { read?: boolean }) {
+        return await this.get('/notifications/', options);
+    }
+
+    static async getAllByOrganization(id: string, options?: PaginationWithSearchOptions & { read?: boolean }) {
+        return await this.get(`/notifications/organizations/${id}`, options);
+    }
+
+    static async markAsRead(id: string) {
+        return await this.patch(`/notifications/${id}/read`);
+    }
+
+    static async getAnalytics() {
+        return await this.get('/notifications/analytics');
+    }
+
+    static async savePushSubscription(subscription: PushSubscriptionPayload) {
+        return await this.post('/notifications/push-subscription', subscription);
+    }
+
+    static async removePushSubscription(endpoint: string) {
+        return await this.delete('/notifications/push-subscription', {endpoint});
+    }
+}