@opencxh/domain 1.113.0 → 1.113.1

package/dist/platform/communication.d.ts

@@ -1,4 +1,10 @@
 export type SessionState = 'idle' | 'ringing' | 'connecting' | 'connected' | 'on_hold' | 'ended' | 'failed';
+/**
+ * `"appName:ResourceName"` — how the platform addresses a federated resource.
+ * Not to be confused with the read-state `ResourceRef`, which points at a
+ * domain object rather than at a piece of UI.
+ */
+export type FederatedResourceRef = `${string}:${string}`;
 export interface Session {
     id: string;
     accountId: string;
@@ -25,8 +31,8 @@ export interface Session {
      */
     externalId?: string;
     ui: {
-        canvas: `${string}:${string}`;
-        actionTray?: `${string}:${string}`;
+        canvas: FederatedResourceRef;
+        actionTray?: FederatedResourceRef;
     };
 }
 export interface CommsAccount<T = any> {
@@ -278,25 +284,36 @@ export declare const InteractionParticipantRole: {
     readonly PARTICIPANT: "participant";
 };
 export type InteractionParticipantRoleValue = typeof InteractionParticipantRole[keyof typeof InteractionParticipantRole];
-/**
- * Which surface the call dock shows in place of the provider's canvas.
- *
- * The canvas and the action tray are separate federated resources, so they
- * cannot hold state between them. The host owns this instead: it renders the
- * keypad and the transfer form itself — both are platform operations
- * (`session.dtmf`, `session.transfer`), not provider UI — and hands the tray
- * the current value plus a setter through `CallActionTrayProps`. A tray that
- * ignores them simply never offers the panels, which is the right answer for a
- * provider that cannot do tones or transfers.
- */
-export type CallPanel = "main" | "keypad" | "transfer";
 /** Props the host passes to a provider's `ui.actionTray` resource. */
 export interface CallActionTrayProps {
     session: Session;
     account?: CommsAccount;
-    /** Absent when the host does not offer swappable panels. */
-    panel?: CallPanel;
-    onPanelChange?: (panel: CallPanel) => void;
+    /**
+     * Resource currently shown in place of `ui.canvas`, or null for the canvas
+     * itself. The canvas and the tray are separate federated resources and
+     * cannot hold state between them, so the host holds this one value and both
+     * sides speak the same currency they already use for `ui.canvas`: a
+     * resource reference.
+     *
+     * Deliberately a reference and not an enum of known panels. A keypad or a
+     * transfer form is not the same everywhere — a provider that transfers to a
+     * directory rather than to a dialled number points this at its own
+     * resource, and a provider that can do neither leaves the affordance out.
+     * `communication:CallKeypad` and `communication:CallTransfer` are there to
+     * be reused by any provider that wants the plain ones.
+     *
+     * Both are absent when the host does not support overriding the canvas; a
+     * tray must then not offer the affordance.
+     */
+    canvasOverride?: FederatedResourceRef | null;
+    onCanvasOverride?: (resource: FederatedResourceRef | null) => void;
+}
+/** Props the host passes to a resource shown via `canvasOverride`. */
+export interface CallCanvasOverrideProps {
+    session: Session;
+    account?: CommsAccount;
+    /** Return to the provider's own canvas. */
+    onClose: () => void;
 }
 export interface SessionAction {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.113.0",
+  "version": "1.113.1",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",