@synapseone/sdk 0.7.0 → 0.7.1-dev.56

package/dist/iam.d.ts

@@ -1,12 +1,92 @@
-import { HttpClient } from './_http';
+import { HttpClient, RequestOptions } from './_http';
+export interface RegisterInput {
+    email: string;
+    password: string;
+    displayName?: string;
+    orgSlug?: string;
+}
+export interface PasswordLoginInput {
+    email: string;
+    password: string;
+    orgSlug?: string;
+}
+export interface Session {
+    id: string;
+    created_at: string | null;
+    expires_at: string | null;
+    revoked_at: string | null;
+}
+export interface ExchangeInput {
+    userId: string;
+    accountId?: string;
+    orgId?: string;
+    scopes?: string[];
+    audience?: string;
+    ttlSeconds?: number;
+}
+export interface DelegatedToken {
+    accessToken: string;
+    expiresIn: number;
+    tokenType: 'Bearer';
+    delegated: true;
+    userId: string;
+    orgId: string;
+    accountId: string;
+    scopes: string[];
+    audience?: string;
+}
 export declare class IamService {
     private readonly http;
     constructor(http: HttpClient);
+    /** Passwordless dev login (IAM_ALLOW_DEV_LOGIN; disabled in production). */
     login(email: string, orgSlug?: string): Promise<{
         accessToken: string;
         refreshToken: string;
         user: any;
     }>;
+    /** First-party registration (email + password). */
+    register(input: RegisterInput): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        user: any;
+        emailVerificationToken?: string;
+    }>;
+    /** First-party email+password login (works in production). */
+    loginWithPassword(input: PasswordLoginInput): Promise<{
+        accessToken: string;
+        refreshToken: string;
+        user: any;
+    }>;
+    changePassword(currentPassword: string, newPassword: string): Promise<{
+        ok: boolean;
+        revokedSessions: number;
+    }>;
+    /** Request a reset token. The response is always 202 (no account enumeration).
+     *  In non-production, `resetToken` is returned when no mailer is configured. */
+    requestPasswordReset(email: string, orgSlug?: string): Promise<{
+        ok: boolean;
+        resetToken?: string;
+    }>;
+    resetPassword(token: string, newPassword: string): Promise<{
+        ok: boolean;
+        revokedSessions: number;
+    }>;
+    verifyEmail(token: string): Promise<{
+        ok: boolean;
+        emailVerified: boolean;
+    }>;
+    requestEmailVerification(): Promise<{
+        ok: boolean;
+        emailVerified?: boolean;
+        emailVerificationToken?: string;
+    }>;
+    listSessions(): Promise<Session[]>;
+    revokeSession(id: string): Promise<unknown>;
+    /**
+     * Delegated token exchange (Tier 2 → Tier 1). The client must present a
+     * service-account Bearer token or an API key; a user JWT is refused.
+     */
+    exchangeToken(input: ExchangeInput, opts?: RequestOptions): Promise<DelegatedToken>;
     refresh(refreshToken: string): Promise<{
         accessToken: string;
         refreshToken: string;
@@ -50,8 +130,28 @@ export declare class IamService {
     simulate(documents: any[], action: string, resource: string, context?: Record<string, unknown>): Promise<{
         allowed: boolean;
     }>;
-    listAudit(limit?: number, actor?: string): Promise<unknown>;
-    createApiKey(accountId: string, name?: string, scopes?: string[]): Promise<{
+    /**
+     * Read the tenant-scoped audit trail. Accepts the legacy `(limit, actor)`
+     * form or a filter object with action/resource/time/pagination (#32).
+     */
+    listAudit(limitOrFilter?: number | {
+        limit?: number;
+        offset?: number;
+        actor?: string;
+        allowed?: boolean;
+        action?: string;
+        resource?: string;
+        from?: string | Date;
+        to?: string | Date;
+    }, actor?: string): Promise<unknown>;
+    /**
+     * Create an API key. Scopes default to least-privilege read access
+     * (`*:read`); pass `['*']` explicitly for a full administrator key.
+     */
+    createApiKey(accountId: string, name?: string, scopes?: string[], opts?: {
+        userId?: string;
+        expiresInSeconds?: number;
+    }): Promise<{
         apiKey: string;
     }>;
     revokeApiKey(keyId: string): Promise<unknown>;

package/dist/iam.js

@@ -1,4 +1,6 @@
 "use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,11 +18,64 @@ class IamService {
         this.http = http;
     }
     // ---- auth ----
+    /** Passwordless dev login (IAM_ALLOW_DEV_LOGIN; disabled in production). */
     login(email, orgSlug = 'acme') {
         return this.http.req('/v1/auth/login', {
             method: 'POST', body: JSON.stringify({ email, orgSlug }),
         });
     }
+    /** First-party registration (email + password). */
+    register(input) {
+        return this.http.req('/v1/auth/register', {
+            method: 'POST', body: JSON.stringify(input),
+        });
+    }
+    /** First-party email+password login (works in production). */
+    loginWithPassword(input) {
+        return this.http.req('/v1/auth/login', {
+            method: 'POST', body: JSON.stringify(input),
+        });
+    }
+    changePassword(currentPassword, newPassword) {
+        return this.http.req('/v1/auth/password/change', {
+            method: 'POST', body: JSON.stringify({ currentPassword, newPassword }),
+        });
+    }
+    /** Request a reset token. The response is always 202 (no account enumeration).
+     *  In non-production, `resetToken` is returned when no mailer is configured. */
+    requestPasswordReset(email, orgSlug = 'acme') {
+        return this.http.req('/v1/auth/password/forgot', {
+            method: 'POST', body: JSON.stringify({ email, orgSlug }),
+        });
+    }
+    resetPassword(token, newPassword) {
+        return this.http.req('/v1/auth/password/reset', {
+            method: 'POST', body: JSON.stringify({ token, newPassword }),
+        });
+    }
+    verifyEmail(token) {
+        return this.http.req('/v1/auth/email/verify', {
+            method: 'POST', body: JSON.stringify({ token }),
+        });
+    }
+    requestEmailVerification() {
+        return this.http.req('/v1/auth/email/verify/request', {
+            method: 'POST', body: JSON.stringify({}),
+        });
+    }
+    listSessions() { return this.http.req('/v1/auth/sessions'); }
+    revokeSession(id) {
+        return this.http.req(`/v1/auth/sessions/${encodeURIComponent(id)}`, { method: 'DELETE' });
+    }
+    /**
+     * Delegated token exchange (Tier 2 → Tier 1). The client must present a
+     * service-account Bearer token or an API key; a user JWT is refused.
+     */
+    exchangeToken(input, opts = {}) {
+        return this.http.req('/v1/auth/exchange', {
+            method: 'POST', body: JSON.stringify(input),
+        }, opts);
+    }
     refresh(refreshToken) {
         return this.http.req('/v1/auth/refresh', {
             method: 'POST', body: JSON.stringify({ refreshToken }),
@@ -90,13 +145,30 @@ class IamService {
     simulate(documents, action, resource, context) {
         return this.http.req('/v1/authorize/dry-run', { method: 'POST', body: JSON.stringify({ documents, action, resource, context }) });
     }
-    listAudit(limit = 50, actor) {
-        const qs = `?limit=${limit}${actor ? `&actor=${encodeURIComponent(actor)}` : ''}`;
-        return this.http.req(`/v1/audit${qs}`);
+    /**
+     * Read the tenant-scoped audit trail. Accepts the legacy `(limit, actor)`
+     * form or a filter object with action/resource/time/pagination (#32).
+     */
+    listAudit(limitOrFilter = 50, actor) {
+        const f = typeof limitOrFilter === 'number' ? { limit: limitOrFilter, actor } : limitOrFilter;
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(f || {})) {
+            if (v !== undefined && v !== null && String(v) !== '')
+                qs.set(k, v instanceof Date ? v.toISOString() : String(v));
+        }
+        const s = qs.toString();
+        return this.http.req(`/v1/audit${s ? `?${s}` : ''}`);
     }
     // ---- API keys ----
-    createApiKey(accountId, name = 'default', scopes = ['*']) {
-        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/keys`, { method: 'POST', body: JSON.stringify({ name, scopes }) });
+    /**
+     * Create an API key. Scopes default to least-privilege read access
+     * (`*:read`); pass `['*']` explicitly for a full administrator key.
+     */
+    createApiKey(accountId, name = 'default', scopes = ['*:read'], opts = {}) {
+        return this.http.req(`/v1/accounts/${encodeURIComponent(accountId)}/keys`, {
+            method: 'POST',
+            body: JSON.stringify({ name, scopes, ...opts }),
+        });
     }
     revokeApiKey(keyId) {
         return this.http.req(`/v1/keys/${encodeURIComponent(keyId)}`, { method: 'DELETE' });

package/dist/index.d.ts

@@ -8,6 +8,9 @@ import { QueueService } from './queue';
 import { StreamService } from './stream';
 import { InferenceService } from './inference';
 import { AiService } from './ai';
+import { HealthService } from './health';
+import { StorageService } from './storage';
+import { NotificationsService } from './notifications';
 export * from './_http';
 export * from './iam';
 export * from './workflow';
@@ -18,6 +21,9 @@ export * from './faststore';
 export * from './queue';
 export * from './stream';
 export * from './inference';
+export * from './health';
+export * from './storage';
+export * from './notifications';
 /** Legacy flat LDS signatures (the namespaced service drops the `lds` prefix). */
 export interface LdsLegacyMethods {
     ldsLicenses(): Promise<any[]>;
@@ -49,7 +55,17 @@ export declare class SynapseOneClient {
     readonly queue: QueueService;
     readonly stream: StreamService;
     readonly inference: InferenceService;
-    constructor(opts: SynapseOneClientOptions);
+    readonly storage: StorageService;
+    readonly notifications: NotificationsService;
+    readonly health: HealthService;
+    readonly readiness: HealthService;
+    constructor(opts?: SynapseOneClientOptions);
+    /** Shallow gateway health. */
+    getHealth(opts?: import('./_http').RequestOptions): Promise<import("./health").HealthResponse>;
+    /** Aggregate readiness; returns the payload on 503 unless `throwOnDegraded`. */
+    getReady(opts?: import('./health').ReadyOptions): Promise<import("./health").ReadyResponse>;
+    /** Projected `{ok, tier1, upstreams}` status for Tier-2 readiness endpoints. */
+    getStatus(opts?: import('./health').ReadyOptions): Promise<import("./health").StatusResponse>;
     get baseUrl(): string;
     setToken(t: string): void;
     setApiKey(k: string): void;

package/dist/index.js

@@ -1,4 +1,6 @@
 "use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -46,6 +48,9 @@ const queue_1 = require("./queue");
 const stream_1 = require("./stream");
 const inference_1 = require("./inference");
 const ai_1 = require("./ai");
+const health_1 = require("./health");
+const storage_1 = require("./storage");
+const notifications_1 = require("./notifications");
 __exportStar(require("./_http"), exports);
 __exportStar(require("./iam"), exports);
 __exportStar(require("./workflow"), exports);
@@ -56,6 +61,9 @@ __exportStar(require("./faststore"), exports);
 __exportStar(require("./queue"), exports);
 __exportStar(require("./stream"), exports);
 __exportStar(require("./inference"), exports);
+__exportStar(require("./health"), exports);
+__exportStar(require("./storage"), exports);
+__exportStar(require("./notifications"), exports);
 class SynapseOneClient {
     http;
     iam;
@@ -67,7 +75,11 @@ class SynapseOneClient {
     queue;
     stream;
     inference;
-    constructor(opts) {
+    storage;
+    notifications;
+    health;
+    readiness;
+    constructor(opts = {}) {
         this.http = new _http_1.HttpClient(opts);
         this.iam = new iam_1.IamService(this.http);
         this.workflow = new workflow_1.WorkflowService(this.http);
@@ -78,7 +90,18 @@ class SynapseOneClient {
         this.queue = new queue_1.QueueService(this.http);
         this.stream = new stream_1.StreamService(this.http);
         this.inference = new inference_1.InferenceService(this.http);
+        this.storage = new storage_1.StorageService(this.http);
+        this.notifications = new notifications_1.NotificationsService(this.http);
+        this.health = new health_1.HealthService(this.http);
+        // Alias: `client.readiness.ready()` reads naturally; same instance.
+        this.readiness = this.health;
     }
+    /** Shallow gateway health. */
+    getHealth(opts) { return this.health.health(opts); }
+    /** Aggregate readiness; returns the payload on 503 unless `throwOnDegraded`. */
+    getReady(opts) { return this.health.ready(opts); }
+    /** Projected `{ok, tier1, upstreams}` status for Tier-2 readiness endpoints. */
+    getStatus(opts) { return this.health.status(opts); }
     get baseUrl() { return this.http.baseUrl; }
     setToken(t) { this.http.setToken(t); }
     setApiKey(k) { this.http.setApiKey(k); }
@@ -91,7 +114,9 @@ class SynapseOneClient {
 exports.SynapseOneClient = SynapseOneClient;
 exports.SynapseDXClient = SynapseOneClient;
 const IAM_METHODS = [
-    'login', 'refresh', 'logout', 'logoutAll', 'verify', 'me',
+    'login', 'register', 'loginWithPassword', 'changePassword', 'requestPasswordReset',
+    'resetPassword', 'verifyEmail', 'requestEmailVerification', 'listSessions', 'revokeSession',
+    'exchangeToken', 'refresh', 'logout', 'logoutAll', 'verify', 'me',
     'oidcConfig', 'oidcStart', 'oidcCallback',
     'listOrgs', 'createOrg', 'listAccounts', 'listUsers', 'createUser',
     'createAccount', 'userPolicies',

package/dist/inference.d.ts

@@ -1,4 +1,4 @@
-import { HttpClient } from './_http';
+import { HttpClient, RequestOptions } from './_http';
 export interface InferenceHealthResponse {
     status: string;
     service: string;
@@ -98,13 +98,36 @@ export declare class InferenceService {
     /** Check health and status of inference subsystems (LLM, embedding, decision). */
     health(): Promise<InferenceHealthResponse>;
     /** Run chat completions through the OpenRouter-backed LLM proxy. */
-    chat(messages: ChatMessage[], opts?: ChatCompletionOptions): Promise<ChatCompletionResponse>;
+    chat(messages: ChatMessage[], opts?: ChatCompletionOptions, reqOpts?: RequestOptions): Promise<ChatCompletionResponse>;
+    /**
+     * Stream chat completions token-by-token (OpenAI-compatible SSE).
+     *
+     * Yields `{event, data}` records where `data` is the raw SSE payload; use
+     * {@link parseChatDelta} to read the incremental text. Pass `{signal}` to
+     * cancel the request (the underlying fetch is aborted).
+     *
+     * ```ts
+     * for await (const ev of client.inference.chatStream(msgs, {}, { signal })) {
+     *   const delta = parseChatDelta(ev.data);
+     *   if (delta) process.stdout.write(delta);
+     * }
+     * ```
+     */
+    chatStream(messages: ChatMessage[], opts?: ChatCompletionOptions, reqOpts?: RequestOptions): AsyncGenerator<{
+        event: string;
+        data: string;
+    }>;
     /** Generate text embeddings using the self-hosted lightweight model. */
     embeddings(input: string | string[], opts?: {
         model?: string;
-    }): Promise<EmbeddingResponse>;
+    }, reqOpts?: RequestOptions): Promise<EmbeddingResponse>;
     /** Run structured question evaluation via Decision-2.0-Eos-0.8B (system_one). */
-    decision(state: string, questions: Record<string, DecisionQuestion>): Promise<DecisionResponse>;
+    decision(state: string, questions: Record<string, DecisionQuestion>, reqOpts?: RequestOptions): Promise<DecisionResponse>;
     /** Semantic route an input text between candidate choices for workflow branching. */
-    route(input: string, choices: Record<string, string>, instruction?: string): Promise<RouteResponse>;
+    route(input: string, choices: Record<string, string>, instruction?: string, reqOpts?: RequestOptions): Promise<RouteResponse>;
 }
+/**
+ * Extract the incremental assistant text from one SSE `data:` payload.
+ * Returns `null` for `[DONE]`, keep-alives and frames without content.
+ */
+export declare function parseChatDelta(data: string): string | null;

package/dist/inference.js

@@ -1,4 +1,6 @@
 "use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -7,7 +9,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InferenceService = void 0;
+exports.parseChatDelta = parseChatDelta;
+const _http_1 = require("./_http");
 const P = '/v1/inference';
+/** LLM calls are allowed 120s by the gateway route; the SDK must match it. */
+const INFERENCE_OPTS = { timeoutMs: _http_1.INFERENCE_TIMEOUT_MS };
 class InferenceService {
     http;
     constructor(http) {
@@ -18,37 +24,57 @@ class InferenceService {
         return this.http.req(`${P}/health`);
     }
     /** Run chat completions through the OpenRouter-backed LLM proxy. */
-    chat(messages, opts = {}) {
+    chat(messages, opts = {}, reqOpts = {}) {
         return this.http.req(`${P}/chat/completions`, {
             method: 'POST',
             body: JSON.stringify({
                 messages,
                 ...opts,
             }),
-        });
+        }, { ...INFERENCE_OPTS, ...reqOpts });
+    }
+    /**
+     * Stream chat completions token-by-token (OpenAI-compatible SSE).
+     *
+     * Yields `{event, data}` records where `data` is the raw SSE payload; use
+     * {@link parseChatDelta} to read the incremental text. Pass `{signal}` to
+     * cancel the request (the underlying fetch is aborted).
+     *
+     * ```ts
+     * for await (const ev of client.inference.chatStream(msgs, {}, { signal })) {
+     *   const delta = parseChatDelta(ev.data);
+     *   if (delta) process.stdout.write(delta);
+     * }
+     * ```
+     */
+    chatStream(messages, opts = {}, reqOpts = {}) {
+        return this.http.stream(`${P}/chat/completions`, {
+            method: 'POST',
+            body: JSON.stringify({ messages, ...opts, stream: true }),
+        }, { ...INFERENCE_OPTS, ...reqOpts });
     }
     /** Generate text embeddings using the self-hosted lightweight model. */
-    embeddings(input, opts = {}) {
+    embeddings(input, opts = {}, reqOpts = {}) {
         return this.http.req(`${P}/embeddings`, {
             method: 'POST',
             body: JSON.stringify({
                 input,
                 ...opts,
             }),
-        });
+        }, { ...INFERENCE_OPTS, ...reqOpts });
     }
     /** Run structured question evaluation via Decision-2.0-Eos-0.8B (system_one). */
-    decision(state, questions) {
+    decision(state, questions, reqOpts = {}) {
         return this.http.req(`${P}/decision`, {
             method: 'POST',
             body: JSON.stringify({
                 state,
                 questions,
             }),
-        });
+        }, { ...INFERENCE_OPTS, ...reqOpts });
     }
     /** Semantic route an input text between candidate choices for workflow branching. */
-    route(input, choices, instruction) {
+    route(input, choices, instruction, reqOpts = {}) {
         return this.http.req(`${P}/decision/route`, {
             method: 'POST',
             body: JSON.stringify({
@@ -56,7 +82,28 @@ class InferenceService {
                 choices,
                 ...(instruction ? { instruction } : {}),
             }),
-        });
+        }, { ...INFERENCE_OPTS, ...reqOpts });
     }
 }
 exports.InferenceService = InferenceService;
+/**
+ * Extract the incremental assistant text from one SSE `data:` payload.
+ * Returns `null` for `[DONE]`, keep-alives and frames without content.
+ */
+function parseChatDelta(data) {
+    if (!data || data === '[DONE]')
+        return null;
+    try {
+        const j = JSON.parse(data);
+        const choice = j?.choices?.[0];
+        const delta = choice?.delta?.content ?? choice?.message?.content;
+        if (typeof delta === 'string' && delta.length)
+            return delta;
+        if (typeof j?.content === 'string' && j.content.length)
+            return j.content;
+        return null;
+    }
+    catch {
+        return data;
+    }
+}

package/dist/lds.js

@@ -1,4 +1,6 @@
 "use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
 /*
  * Copyright 2026 SynapseOne Contributors
  * Licensed under the Apache License, Version 2.0 (the "License");

package/dist/notifications.d.ts

@@ -0,0 +1,70 @@
+import { HttpClient } from './_http';
+export type NotificationChannel = 'email' | 'sms' | 'webhook' | 'push' | 'log';
+export type NotificationStatus = 'queued' | 'sending' | 'delivered' | 'failed' | 'dead' | 'cancelled';
+export interface NotificationRecipient {
+    email?: string;
+    phone?: string;
+    userId?: string;
+    url?: string;
+    webhookUrl?: string;
+    pushToken?: string;
+    [key: string]: string | undefined;
+}
+export interface SendNotificationInput {
+    /** One channel, or several at once (fan-out creates one record per channel). */
+    channel?: NotificationChannel;
+    channels?: NotificationChannel[];
+    recipient: NotificationRecipient;
+    subject?: string;
+    /** Template with `{{var}}` placeholders filled from `data`. */
+    body: string;
+    data?: Record<string, unknown>;
+    idempotencyKey?: string;
+}
+export interface NotificationRecord {
+    id: string;
+    tenant: string;
+    channel: NotificationChannel;
+    recipient: NotificationRecipient;
+    subject: string;
+    body: string;
+    status: NotificationStatus;
+    attempts: Array<{
+        at: string;
+        ok: boolean;
+        error?: string;
+    }>;
+    idempotencyKey: string | null;
+    metadata: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+    nextAttemptAt: string;
+    deadReason: string | null;
+}
+export interface NotificationPreference {
+    tenant: string;
+    recipient: string;
+    channels: NotificationChannel[];
+    unsubscribed: boolean;
+    updatedAt?: string;
+}
+export declare class NotificationsService {
+    private readonly http;
+    constructor(http: HttpClient);
+    /** Queue one notification per channel (202). */
+    send(input: SendNotificationInput): Promise<{
+        notifications: NotificationRecord[];
+    }>;
+    get(id: string): Promise<NotificationRecord>;
+    list(opts?: {
+        status?: NotificationStatus;
+        limit?: number;
+    }): Promise<NotificationRecord[]>;
+    cancel(id: string): Promise<NotificationRecord>;
+    getPreference(recipient: string): Promise<NotificationPreference>;
+    setPreference(recipient: string, prefs: {
+        channels?: NotificationChannel[];
+        unsubscribed?: boolean;
+    }): Promise<NotificationPreference>;
+    unsubscribe(recipient: string): Promise<NotificationPreference>;
+}

package/dist/notifications.js

@@ -0,0 +1,55 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 VKU.VIC
+/*
+ * Copyright 2026 SynapseOne Contributors
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * SynapseNotifications client: outbox, templates, preferences and delivery.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationsService = void 0;
+const P = '/v1/notifications';
+class NotificationsService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Queue one notification per channel (202). */
+    send(input) {
+        return this.http.req(P, {
+            method: 'POST',
+            body: JSON.stringify(input),
+        });
+    }
+    get(id) {
+        return this.http.req(`${P}/${encodeURIComponent(id)}`);
+    }
+    list(opts = {}) {
+        const qs = new URLSearchParams();
+        if (opts.status)
+            qs.set('status', opts.status);
+        if (opts.limit)
+            qs.set('limit', String(opts.limit));
+        const s = qs.toString();
+        return this.http.req(`${P}${s ? `?${s}` : ''}`);
+    }
+    cancel(id) {
+        return this.http.req(`${P}/${encodeURIComponent(id)}/cancel`, { method: 'POST', body: '{}' });
+    }
+    getPreference(recipient) {
+        return this.http.req(`${P}/preferences/${encodeURIComponent(recipient)}`);
+    }
+    setPreference(recipient, prefs) {
+        return this.http.req(`${P}/preferences/${encodeURIComponent(recipient)}`, {
+            method: 'PUT',
+            body: JSON.stringify(prefs),
+        });
+    }
+    unsubscribe(recipient) {
+        return this.http.req(`${P}/unsubscribe`, {
+            method: 'POST',
+            body: JSON.stringify({ recipient }),
+        });
+    }
+}
+exports.NotificationsService = NotificationsService;

package/dist/notifications.test.d.ts

@@ -0,0 +1 @@
+export {};