@opencxh/domain 1.171.0 → 1.172.2

package/dist/platform/transcript-cadence.d.ts

@@ -1,75 +1,71 @@
 import { TranscriptSegment } from './media';
 /**
- * Wanneer is er genoeg nieuw gezegd om opnieuw te gaan kijken?
+ * When has enough new been said to go looking again?
  *
- * Dit is de héle beslissing achter een live-meelezende assistent, en met opzet puur: geen
- * model, geen klok, geen store. Comms bepaalt *wanneer* (hier), de ai-app bepaalt *wat*.
+ * This is the *whole* decision behind a live-listening assistant, and deliberately pure: no model,
+ * no clock, no store. Comms decides *when* (here), the ai app decides *what*.
  *
- * De twee valkuilen die de drempels hieronder afdekken:
+ * The two traps the thresholds below cover:
  *
- * - **Te vaak.** De transcribe-route wordt elke ~3 seconden per actief gesprek geraakt. Zonder
- *   vloer is dat 20 zoekrondes per minuut per gesprek, waarvan de meeste hetzelfde antwoord
- *   opleveren omdat er één woord bij is gekomen.
- * - **Te gretig.** "Ja." en "Klopt." zijn nieuwe uitingen maar geen nieuw onderwerp. Daarom
- *   telt niet alleen tijd, maar ook of de zoekvraag wérkelijk verschoven is.
+ * - **Too often.** The transcribe route is hit every ~3 seconds per active call. Without a floor
+ *   that is 20 search rounds a minute per call, most of them returning the same answer because one
+ *   word was added.
+ * - **Too eager.** "Ja." and "Klopt." are new utterances but not a new topic. So not only time
+ *   counts, but whether the query has really shifted.
  *
- * De vergelijking gebeurt tegen de vorige **uitgevoerde** zoekvraag, niet tegen het vorige
- * venster: anders schuift het onderwerp mee met het venster en vuurt hij eeuwig door.
+ * The comparison runs against the previously **executed** query, not against the previous window:
+ * otherwise the topic slides along with the window and it fires forever.
  */
-/** Hoeveel gesprek er in de zoekvraag gaat. Ouder dan dit is niet meer waar het over gaat. */
+/** How much conversation goes into the query. Older than this is no longer what it is about. */
 export declare const CADENCE_WINDOW_MS = 60000;
-/** Ondergrens tussen twee rondes, ongeacht hoeveel er gezegd is. */
+/** Lower bound between two rounds, however much was said. */
 export declare const CADENCE_FLOOR_MS = 8000;
-/** Minder dan dit aantal nieuwe definitieve uitingen is nog geen nieuw onderwerp. */
+/** Fewer than this many new final utterances is not a new topic yet. */
 export declare const CADENCE_MIN_NEW_SEGMENTS = 2;
-/** Onder dit aandeel nieuwe woorden gaat het nog over hetzelfde. */
+/** Below this share of new words it is still about the same thing. */
 export declare const CADENCE_MIN_NOVELTY = 0.4;
-/** De losse woorden waar een zoekvraag op rust: kleine letters, zonder ruis, zonder dubbelen. */
+/** The individual words a query rests on: lowercase, no noise, no duplicates. */
 export declare function extractTerms(text: string): string[];
 /**
- * Welk deel van waar het nú over gaat, is nog niet opgezocht? 1 is volledig nieuw, 0 is
- * precies dezelfde vraag.
+ * Which part of what it is about right now has not been looked up yet? 1 is entirely new, 0 is
+ * exactly the same question.
  *
- * Bewust asymmetrisch, en niet Jaccard. Het venster groeit terwijl de vorige zoekvraag
- * blijft staan, en Jaccard straft die groei af: hoe langer het gesprek over één onderwerp
- * doorgaat, hoe lager de symmetrische overlap wordt, tot hij alsnog vuurt. Dat is exact de
- * "vuurt eeuwig door"-fout die de vergelijking moest voorkomen. De vraag die telt is
- * eenzijdig: staat er iets nieuws op tafel?
+ * Deliberately asymmetric, and not Jaccard. The window grows while the previous query stays put,
+ * and Jaccard punishes that growth: the longer a conversation stays on one topic, the lower the
+ * symmetric overlap gets, until it fires anyway — exactly the "fires forever" bug the comparison
+ * had to prevent. The question that counts is one-sided: is there something new on the table?
  */
 export declare function novelty(current: readonly string[], previous: readonly string[]): number;
 /**
- * De laatste ~60 seconden gesproken tekst, schoongemaakt.
+ * The last ~60 seconds of spoken text, cleaned up.
  *
- * Het venster wordt gemeten vanaf de **laatste uiting**, niet vanaf de serverklok:
- * `startedAt`/`endedAt` van een segment komen van de transcriptieprovider en hoeven niet
- * dezelfde oorsprong te hebben als `Date.now()` hier. Onderling verschil is wél
- * betrouwbaar, en dat is alles wat een venster nodig heeft.
+ * The window is measured from the **last utterance**, not from the server clock: a segment's
+ * `startedAt`/`endedAt` come from the transcription provider and need not share an origin with
+ * `Date.now()` here. Their difference *is* reliable, and that is all a window needs.
  *
- * Partiële segmenten blijven eruit: die veranderen nog terwijl je ze leest.
+ * Partial segments stay out: those still change while you read them.
  */
 export declare function buildWindow(segments: readonly TranscriptSegment[], windowMs?: number): {
     text: string;
     segmentCount: number;
 };
 /**
- * Hoeveel getoonde sleutels we bijhouden. Een gesprek van een half uur kan er honderden
- * opleveren en de rij wordt bij elke flush in zijn geheel herschreven, dus dit is geen
- * geheugen maar een venster: wat eruit valt mag opnieuw verschijnen.
+ * How many shown keys we keep. A half-hour call can produce hundreds and the row is rewritten
+ * whole on every flush, so this is not memory but a window: what falls out may appear again.
  */
 export declare const MAX_SHOWN_KEYS = 60;
 /**
- * Wat dit gesprek al te zien heeft gekregen, plus wat er net bij kwam — zonder dubbelen en
- * begrensd. De oudste sleutels vallen eruit, want de nieuwste zijn de kaarten die nu op het
- * scherm staan.
+ * What this conversation has already been shown, plus what just came in — deduplicated and
+ * bounded. The oldest keys fall out, because the newest are the cards on screen right now.
  */
 export declare function mergeShownKeys(existing: readonly string[], shown: readonly string[], max?: number): string[];
-/** Wat er van de vorige ronde bewaard is. Leeg betekent "nog nooit gekeken". */
+/** What was kept from the previous round. Empty means "never looked yet". */
 export interface CadenceState {
-    /** Serverklok van de vorige ronde — alleen voor de vloer. */
+    /** Server clock of the previous round — only for the floor. */
     lastTriggerAt?: number;
-    /** Aantal definitieve uitingen op dat moment — alleen voor "hoeveel is er bij gekomen". */
+    /** Number of final utterances at that moment — only for "how much was added". */
     lastSegmentCount?: number;
-    /** De vorige uitgevoerde zoekvraag, waar de onderwerpwissel tegen gemeten wordt. */
+    /** The previously executed query, which the topic shift is measured against. */
     lastQueryTerms?: string[];
 }
 export type CadenceDecision = {
@@ -82,8 +78,8 @@ export type CadenceDecision = {
     segmentCount: number;
 };
 /**
- * Vier poorten, van goedkoop naar duur — de eerste die dichtblijft, is het antwoord.
- * `reason` is er zodat een gesprek dat níets oplevert te verklaren is zonder een debugger.
+ * Four gates, cheap to expensive — the first one that stays shut is the answer. `reason` exists so
+ * a conversation yielding nothing can be explained without a debugger.
  */
 export declare function decideCadence(input: {
     segments: readonly TranscriptSegment[];

package/dist/platform/ui.d.ts

@@ -5,8 +5,8 @@ export interface ModalConfig {
     id: string;
     displayName: string;
     resource: string;
-    size?: 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
-    position?: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'corner' | 'sidebar';
+    size?: "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";
+    position?: "center" | "top" | "bottom" | "left" | "right" | "corner" | "sidebar";
     props?: Record<string, any>;
     hideHeader?: boolean;
 }
@@ -22,7 +22,7 @@ export interface DockConfig {
     id: string;
     displayName: string;
     resource: string;
-    size?: 'sm' | 'md' | 'lg' | 'xl';
+    size?: "sm" | "md" | "lg" | "xl";
     props?: Record<string, any>;
     hideHeader?: boolean;
     /**
@@ -98,7 +98,7 @@ export interface SettingsPageConfig {
 export interface ToastConfig {
     id: string;
     title?: string;
-    type: 'success' | 'error' | 'warning' | 'info';
+    type: "success" | "error" | "warning" | "info";
     message?: string;
     duration?: number;
     /**
@@ -117,14 +117,14 @@ export interface ToastConfig {
         label: string;
         onClick: () => void;
         /** Visual emphasis of the action button. Defaults to `secondary`. */
-        variant?: 'primary' | 'secondary';
+        variant?: "primary" | "secondary";
     }[];
 }
 /**
  * Well-known context kinds, kept for autocomplete; any app may declare its own
  * kind (e.g. "contact") via a context provider, so the type stays open.
  */
-export type ExtensionContext = 'global' | 'call' | 'interaction' | (string & {});
+export type ExtensionContext = "global" | "call" | "interaction" | (string & {});
 export interface ExtensionConfig {
     id: string;
     slot: string;

package/dist/text/endpoint.d.ts

@@ -1,18 +1,12 @@
 /**
  * One normalisation for communication endpoints — phone numbers, e-mail addresses
- * and the lookup keys built from them.
- *
- * Before this module there were five copies of `resource.replace(/[\s()-]/g, "")`
- * spread over eylo-voip, microsoft and three comms services, plus a sixth variant
- * with `+31` hardcoded. None of them turned a national number into an international
- * one, so `0882112121` never matched `+31882112121`. Every lookup key in the platform
- * has to be produced here, or the write side and the read side drift apart and the
- * index is worthless.
+ * and the lookup keys built from them. Every lookup key in the platform must be
+ * produced here, or the write and read sides drift apart and the index is worthless
+ * (ad-hoc copies never mapped `0882112121` onto `+31882112121`).
  *
  * Deliberately dependency-free: `libphonenumber-js` is ~145 kB for a rule we express
- * in a table. The honest cost is that we cannot validate per-country number *plans*,
- * only plausible lengths — so we reject implausible input instead of forcing it, and
- * callers keep the raw value for display.
+ * in a table. Cost: we validate plausible lengths, not per-country number plans — so
+ * we reject implausible input instead of forcing it; callers keep the raw value for display.
  */
 /** A dialling plan entry: enough to normalise, not enough to validate a number plan. */
 export interface PhoneRegion {
@@ -40,17 +34,9 @@ export declare const DEFAULT_PHONE_REGION = "NL";
 export declare function looksLikeEmail(value: string | undefined | null): boolean;
 /**
  * Turn any written form of a phone number into `+<callingCode><nsn>`, or `null` when
- * it cannot be resolved without guessing.
- *
- * | input | output |
- * |---|---|
- * | `+31 88 211 2121` | `+31882112121` |
- * | `0031882112121` | `+31882112121` |
- * | `088 211 2121` (region NL) | `+31882112121` |
- * | `882112121` | `null` — ambiguous, we do not guess |
- *
- * Resolution order for the region: an explicit `+` or `00` wins, then `defaultRegion`
- * (the organisation setting, or the region of the channel the call came in on).
+ * it cannot be resolved without guessing (a bare `882112121` is ambiguous → null).
+ * Region resolution: explicit `+`/`00` wins, then `defaultRegion` (organisation
+ * setting, or the region of the receiving channel).
  */
 export declare function toE164(raw: string | undefined | null, defaultRegion?: string): string | null;
 /**
@@ -86,11 +72,9 @@ export declare const PUBLIC_EMAIL_DOMAINS: Set<string>;
 /** True when a domain is consumer mail and must never identify a company. */
 export declare function isPublicEmailDomain(domain: string | undefined | null): boolean;
 /**
- * Does normalising this scheme need a phone region?
- *
- * Worth asking before resolving one: the region lives on the organisation, so fetching it
- * is a cross-app round trip, while an e-mail address has no region at all. A mail-only
- * lookup that resolves the region anyway pays for four internal RPCs it never uses.
+ * Does normalising this scheme need a phone region? Check before resolving one:
+ * the region lives on the organisation, so fetching it is a cross-app round trip
+ * a mail-only lookup would pay for nothing.
  */
 export declare function needsPhoneRegion(scheme: string | undefined | null): boolean;
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.171.0",
+  "version": "1.172.2",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -22,10 +22,8 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest",
     "test:run": "vitest run",
-    "test:watch": "vitest --watch"
-  },
-  "peerDependencies": {
-    "rxjs": "^7.8.2"
+    "test:watch": "vitest --watch",
+    "lint": "biome check ."
   },
   "devDependencies": {
     "typescript": "6.0.3",

package/dist/entities/note/types.d.ts

@@ -1,14 +0,0 @@
-/**
- * Data model for a single Note.
- */
-export interface Note {
-    id: string;
-    organizationId: string;
-    interactionId: string;
-    serviceName: string;
-    authorId: string;
-    authorDisplayName: string;
-    content: string;
-    createdAt: Date;
-    updatedAt: Date;
-}

package/dist/entities/shopify/index.d.ts

@@ -1 +0,0 @@
-export * from './types';

package/dist/entities/shopify/types.d.ts

@@ -1,79 +0,0 @@
-/**
- * Shopify DTO's — gedeeld tussen de shopify-server (mapping uit Admin API),
- * platform-api (typed client) en de frontend-tool. Geen Shopify-SDK-types
- * lekken naar consumers; dit is de smalle, stabiele contractlaag.
- */
-export interface ShopifyCustomer {
-    id: string;
-    firstName?: string;
-    lastName?: string;
-    email?: string;
-    phone?: string;
-    ordersCount?: number;
-    totalSpent?: string;
-    currency?: string;
-    /** Klant sinds — ISO-datum uit Shopify. */
-    createdAt?: string;
-    /** Shopify-klantlabels ("wholesale", "net-30"): segment, betaaltermijn, wat de shop erin zet. */
-    tags?: string[];
-    defaultAddress?: ShopifyAddress;
-}
-export interface ShopifyLineItem {
-    title: string;
-    variantTitle?: string;
-    quantity: number;
-    price: string;
-}
-export interface ShopifyTracking {
-    company?: string;
-    number?: string;
-    url?: string;
-}
-export interface ShopifyAddress {
-    name?: string;
-    address1?: string;
-    address2?: string;
-    zip?: string;
-    city?: string;
-    province?: string;
-    country?: string;
-    phone?: string;
-}
-export interface ShopifyOrder {
-    id: string;
-    /** Human order-name, bv. "#1001". */
-    name: string;
-    createdAt: string;
-    financialStatus?: string;
-    fulfillmentStatus?: string;
-    totalPrice: string;
-    /** Opsplitsing van het totaal. Optioneel: oudere orders leveren niet elk veld. */
-    subtotalPrice?: string;
-    totalShipping?: string;
-    totalTax?: string;
-    currency: string;
-    lineItems: ShopifyLineItem[];
-    shippingAddress?: ShopifyAddress;
-    tracking: ShopifyTracking[];
-    note?: string;
-    /** Deep-link naar de order in de Shopify-admin (nieuw tabblad). */
-    adminUrl: string;
-}
-export interface ShopifyOrderEvent {
-    id: string;
-    createdAt: string;
-    /** Mensvriendelijke omschrijving van het event. */
-    message: string;
-    /** Shopify "verb" (bv. "confirmed", "fulfilled", "sale"). */
-    verb?: string;
-}
-export interface ShopifyLookupResult {
-    /** False = geen verbonden/enabled shop voor deze org (admin moet koppelen). */
-    connected: boolean;
-    /** De shop waar dit uit komt, bv. "leufgens-shop.myshopify.com". */
-    shopDomain?: string;
-    customer: ShopifyCustomer | null;
-    /** Deep-link naar de klant in de Shopify-admin. */
-    customerAdminUrl?: string;
-    orders: ShopifyOrder[];
-}

package/dist/platform/lifecycle.d.ts

@@ -1,13 +0,0 @@
-export interface AppLifecycle {
-    /** * On-load: Registreer services, menu-items en andere metadata.
-     * Wordt éénmalig uitgevoerd bij het laden van de JS.
-     */
-    setup: () => void;
-    /** * On-mount: Render de UI in de meegeleverde container.
-     * Wordt uitgevoerd wanneer de gebruiker naar de app navigeert.
-     */
-    mount: (container: HTMLElement, props?: any) => void;
-    /** * On-unmount: Ruim eventuele listeners of DOM-elementen op.
-     */
-    unmount: (container: HTMLElement) => void;
-}

package/dist/platform/reactive.d.ts

@@ -1,13 +0,0 @@
-export interface Subscriber<T> {
-    next: (value?: T) => void;
-    error?: (err: any) => void;
-    complete?: () => void;
-}
-export interface Observable<T> {
-    subscribe(subscriber: Subscriber<T>): () => void;
-}
-export interface Result<T> {
-    success: boolean;
-    value?: T;
-    error?: any;
-}

package/dist/platform/sdk.d.ts

@@ -1,182 +0,0 @@
-import { Observable } from 'rxjs';
-import { InvokeOptions, SSEMessage } from './api';
-import { IncomingCallDecision } from './call-lines';
-import { CommsAccount, Session } from './communication';
-import { PlatformConfig, PlatformContext } from './kernel';
-import { AudioPipelineOptions, AudioSegment, MediaPermissionKind, MediaPermissionState, MediaPermissionStatus, TranscriptSegment } from './media';
-import { ServiceCallOptions, ServiceMap } from './services';
-import { DeepPartial, DeviceList, UserSettings } from './settings';
-import { ExtensionConfig, ToastConfig } from './ui';
-type ServiceKey<S extends ServiceMap> = keyof S;
-export type ParamsOf<S extends ServiceMap, K extends ServiceKey<S>> = S[K]['params'];
-export type PayloadOf<S extends ServiceMap, K extends ServiceKey<S>> = S[K]['payload'];
-export type ResponseOf<S extends ServiceMap, K extends ServiceKey<S>> = S[K]['response'];
-export type SSEHandlerOf<S extends ServiceMap, K extends ServiceKey<S>> = (payload: SSEMessage<PayloadOf<S, K>>) => Promise<void>;
-export interface InternalSDK<LocalServices extends ServiceMap = {}, TranslationKeys extends string = string, ModalKeys extends string = string, ExtensionKeys extends string = string> {
-    readonly context: PlatformContext;
-    readonly config: PlatformConfig;
-    readonly services: {
-        execute<K extends ServiceKey<LocalServices>>(key: K, options: ServiceCallOptions<ParamsOf<LocalServices, K>, PayloadOf<LocalServices, K>>): Promise<ResponseOf<LocalServices, K>>;
-        observe<K extends ServiceKey<LocalServices>>(key: K, options: ServiceCallOptions<ParamsOf<LocalServices, K>, PayloadOf<LocalServices, K>>): Observable<ResponseOf<LocalServices, K>>;
-    };
-    readonly http: {
-        invoke<R = any>(options: InvokeOptions): Promise<R>;
-    };
-    readonly router: {
-        /** Relative to the app's own `/apps/{appName}` prefix. */
-        navigate(path: string, options?: any): void;
-        /**
-         * Straight to a shell path, no prefix.
-         *
-         * For the app's `public: true` routes: those hang off the manifest's
-         * `publicBasePath` (`/help/…`), so the app prefix would point at a page
-         * that does not exist.
-         */
-        navigateAbsolute(path: string, options?: any): void;
-        /**
-         * Terug naar de vorige pagina — de echte, inclusief die van een andere app.
-         *
-         * Waarom dit hier hoort en niet per app: elk detailscherm heeft een terugknop, en zonder
-         * gedeelde vorm wordt dat overal een vaste route ("terug" = altijd de lijst) die liegt zodra
-         * je van een bord of uit een gesprek komt.
-         *
-         * `fallback` is app-relatief, net als {@link navigate}, en geldt alleen als er geen vorige
-         * pagina ín deze sessie is — dat is precies het geval bij een koud geopende deeplink. Geef je
-         * er geen, dan gebeurt er niets: uit het product lopen is geen taak van een terugknop.
-         */
-        back(fallback?: string): void;
-        /** Is er een vorige pagina in deze sessie? Voor een knop die zichzelf wil verbergen. */
-        canGoBack(): boolean;
-        currentPath(): string;
-        path$: Observable<string>;
-    };
-    readonly resources: {
-        get<T = any>(appName: string, resourceKey: string): Promise<T>;
-    };
-    readonly localization: {
-        /**
-         * Vertaal een sleutel.
-         *
-         * Zonder `:` is het een sleutel van deze app zelf. Mét `:` is hij al genamespaced
-         * (`"helpdesk:ticket.added.text"`) en wordt hij ongewijzigd opgezocht — nodig om tekst
-         * te tonen die een andere app meestuurde bij iets wat wij renderen.
-         */
-        t(key: TranslationKeys | `${string}:${string}`, params?: Record<string, any>): string;
-        /**
-         * De actieve taal ("nl" | "en").
-         *
-         * Nodig zodra een app zélf iets moet opmaken in plaats van een sleutel op te
-         * zoeken: `Intl.ListFormat` voor een opsomming, `toLocaleTimeString` voor een
-         * tijd. Zonder dit viel dat terug op `navigator.language`, die niet meebeweegt
-         * als de gebruiker de taal in de app omzet.
-         */
-        readonly currentLocale: string;
-    };
-    readonly ui: {
-        modals: {
-            open(key: ModalKeys, props?: any): void;
-            close(key: ModalKeys): void;
-        };
-        docks: {
-            open(key: string, props?: any): void;
-            close(key: string): void;
-            minimize(key: string, minimized?: boolean): void;
-            expand(key: string, expanded?: boolean): void;
-        };
-        settings: {
-            open(initialPageId?: string): void;
-            close(): void;
-        };
-        toasts: {
-            show(config: ToastConfig): void;
-            close(id: string): void;
-        };
-        extensions: {
-            getForSlot(slot: string): Observable<ExtensionConfig[]>;
-        };
-    };
-    readonly communication: {
-        sessions$: Observable<Session[]>;
-        accounts$: Observable<CommsAccount[]>;
-        activeSession$: Observable<Session | null>;
-        /**
-         * Routeert een TransportOp naar de provider die de gegeven session bezit.
-         * Vervangt de losse hangupSession/handleSessionAction APIs.
-         */
-        dispatchSessionOp(sessionId: string, op: import('./communication').TransportOp): Promise<void>;
-        /**
-         * Initieert een nieuwe outbound sessie via `session.invite`. Sugar
-         * voor `dispatchSessionOp` op het juiste provider; sessieId bestaat
-         * pas na invite.
-         */
-        invite(target: string, accountId: string): Promise<void>;
-        interceptStream(sessionId: string, callback: (stream: MediaStream) => void): Promise<() => void>;
-        setActiveSession(sessionId: string): Promise<void>;
-        /**
-         * Mag dit inkomende gesprek rinkelen? Een transport-provider vraagt dit zodra
-         * een invite binnenkomt, vóór het een sessie aanmaakt: het beleid ("zit ik al
-         * in een gesprek") kijkt over providers heen, de provider vertaalt alleen het
-         * antwoord naar zijn protocol (SIP 486 bijvoorbeeld).
-         */
-        admitIncomingCall(options?: {
-            exceptSessionId?: string;
-        }): Promise<IncomingCallDecision>;
-        registerAccount(organizationId: string, userId: string, providerId: string, config: any): Promise<CommsAccount>;
-        transcripts: {
-            ingest(segments: TranscriptSegment[]): void;
-            byCallSession$(sessionId: string): Observable<TranscriptSegment[]>;
-            deltas$(sessionId: string): Observable<TranscriptSegment[]>;
-            partials$(sessionId: string): Observable<TranscriptSegment>;
-            persist(sessionId: string): Promise<void>;
-            clear(sessionId: string): void;
-            /**
-             * `opts.from` is de index waar `segments` in het transcript begint: `0` is het hele
-             * transcript, hoger maakt het een delta op wat de ontvanger al heeft. Zonder dat stuurde
-             * elke flush (elke ~3s) de complete array opnieuw.
-             */
-            setPersister(fn: (sessionId: string, segments: TranscriptSegment[], opts: {
-                finalize: boolean;
-                from: number;
-            }) => Promise<void>): void;
-        };
-    };
-    readonly media: {
-        localStream$: Observable<MediaStream | null>;
-        audioSegments$: Observable<AudioSegment>;
-        devices$: Observable<DeviceList>;
-        permissions$: Observable<MediaPermissionStatus>;
-        emitAudioSegment(segment: AudioSegment): void;
-        configureAudioPipeline(opts: Partial<AudioPipelineOptions>): void;
-        setAudioPipelineEnabled(enabled: boolean): void;
-        setSessionAudioEnabled(sessionId: string, enabled: boolean): void;
-        isSessionAudioPaused(sessionId: string): boolean;
-        setInputDevice(deviceId: string): Promise<void>;
-        acquireMicStream(deviceId?: string): Promise<MediaStream>;
-        deviceChanges$: Observable<string>;
-        toggleMute(mute?: boolean): void;
-        attachProviderStream(sessionId: string, stream: MediaStream): void;
-        detachStream(sessionId: string): void;
-        setAudioOutput(deviceId: string): Promise<void>;
-        getInputDevices(): MediaDeviceInfo[];
-        getOutputDevices(): MediaDeviceInfo[];
-        enumerateDevices(): Promise<void>;
-        checkPermission(kind: MediaPermissionKind): Promise<MediaPermissionState>;
-        requestPermission(kind: MediaPermissionKind): Promise<MediaPermissionState>;
-        ensurePermission(kind: MediaPermissionKind): Promise<boolean>;
-        refreshPermissions(): Promise<MediaPermissionStatus>;
-    };
-    readonly settings: {
-        settings$: Observable<UserSettings>;
-        get(): UserSettings;
-        update(partial: DeepPartial<UserSettings>): void;
-        getIceServers(): RTCIceServer[];
-        getAudioInputDeviceId(): string;
-        setAudioInputDeviceId(deviceId: string): void;
-        getAudioOutputDeviceId(): string;
-        setAudioOutputDeviceId(deviceId: string): void;
-        getVideoDeviceId(): string;
-        setVideoDeviceId(deviceId: string): void;
-        setIceServers(servers: RTCIceServer[]): void;
-    };
-}
-export {};

package/dist/platform/service-registry.d.ts

@@ -1,13 +0,0 @@
-import { Observable } from './reactive';
-export interface Command<TParams = any, TResponse = any> {
-    params: TParams;
-    response: TResponse;
-}
-export interface Query<TParams = any, TResponse = any> {
-    params: TParams;
-    response: TResponse;
-}
-export interface ServiceRegistry<TCommands extends Record<string, Command> = any, TQueries extends Record<string, Query> = any> {
-    execute<K extends keyof TCommands>(name: K, params: TCommands[K]["params"]): Promise<TCommands[K]["response"]>;
-    observe<K extends keyof TQueries>(name: K, params: TQueries[K]["params"]): Observable<TQueries[K]["response"]>;
-}