@opencxh/domain 1.23.2 → 1.28.0

package/dist/entities/calendar-event/index.d.ts

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

package/dist/entities/calendar-event/types.d.ts

@@ -0,0 +1,55 @@
+import { OwnerScope } from '../contact/types';
+export type CalendarEventStatus = "confirmed" | "cancelled" | "tentative";
+export type AttendeeResponse = "accepted" | "declined" | "tentative" | "none";
+export interface EventAttendee {
+    email: string;
+    name?: string;
+    response?: AttendeeResponse;
+    optional?: boolean;
+}
+export interface EventConferencing {
+    provider: "teams" | "meet" | "zoom" | "other";
+    joinUrl: string;
+    conferenceId?: string;
+    passcode?: string;
+}
+export type RecurrenceFrequency = "daily" | "weekly" | "monthly" | "yearly";
+/**
+ * RFC5545-subset. MVP: read-only — provider supplies, we display.
+ */
+export interface RecurrenceRule {
+    frequency: RecurrenceFrequency;
+    interval?: number;
+    count?: number;
+    until?: number;
+    byWeekday?: ("MO" | "TU" | "WE" | "TH" | "FR" | "SA" | "SU")[];
+}
+export interface EventReminder {
+    minutesBefore: number;
+}
+export interface CalendarEvent {
+    id: string;
+    organizationId: string;
+    ownerScope: OwnerScope;
+    title: string;
+    description?: string;
+    location?: string;
+    startTime: number;
+    endTime: number;
+    allDay?: boolean;
+    timezone?: string;
+    organizer?: EventAttendee;
+    attendees?: EventAttendee[];
+    /** Link to a communication Interaction (e.g. Teams meeting chat). */
+    interactionId?: string;
+    /** Channel used for external sync (provider-resolved). */
+    channelId?: string;
+    /** Provider-side IDs for dedupe (e.g. Graph event id, iCalUId). */
+    externalIds?: string[];
+    status: CalendarEventStatus;
+    recurrence?: RecurrenceRule;
+    reminders?: EventReminder[];
+    conferencing?: EventConferencing;
+    createdAt?: number;
+    updatedAt?: number;
+}

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

@@ -60,3 +60,48 @@ export interface Transcription {
 export interface SessionMetadata {
     [custom: string]: unknown;
 }
+export type AuthState = {
+    type: "oauth2";
+    accessToken: string;
+    refreshToken?: string;
+    /** Epoch ms */
+    expiresAt: number;
+    scopes: string[];
+    idToken?: string;
+} | {
+    type: "password";
+    username: string;
+    /** Reference into secret-store; never the raw password. */
+    passwordRef: string;
+} | {
+    type: "certificate";
+    certRef: string;
+} | {
+    type: "static";
+};
+export type ManagedAccountStatus = "connected" | "disconnected" | "error" | "expired";
+export interface ManagedAccount {
+    id: string;
+    organizationId: string;
+    /** null = org-level account (geen specifieke user). */
+    userId?: string;
+    providerId: string;
+    /** "oauth2" | "imap" | "sip" | "webhook" | provider-eigen string */
+    protocol: string;
+    displayName: string;
+    status: ManagedAccountStatus;
+    auth: AuthState;
+    /** Provider-specifieke metadata (tenantId, externalUserId, scope-flags). */
+    metadata: Record<string, unknown>;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * Public-view zonder tokens — wat `account/list` en `account/get` aan
+ * UI/comm-server retourneren. `auth` is gestripped tot alleen het type.
+ */
+export type ManagedAccountPublic = Omit<ManagedAccount, "auth"> & {
+    authType: AuthState["type"];
+    scopes?: string[];
+    expiresAt?: number;
+};

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function c(t){return t.endpoints??[]}const u=t=>!!t.assignedUserId||!!t.assignedInboxId,d=t=>t.status==="closed",g=t=>({urgent:10,high:5,normal:2,low:1})[t.priority]||0,p=(t,n=30)=>t.title?.length<=n?t.title:`${t.title.substring(0,n)}...`;function l(t,n){const s=new Set(t.disabledIntents??[]),i=t.intentOverrides??{},e=n.intents.filter(r=>!s.has(r.intent)).map(r=>I(r,i[r.intent]));if(!t.extraIntents||t.extraIntents.length===0)return e;const o=new Set(e.map(r=>r.intent));for(const r of t.extraIntents)o.has(r.intent)||(e.push(r),o.add(r.intent));return e}function I(t,n){return n?{intent:n.intent??t.intent,targetSchemes:n.targetSchemes??t.targetSchemes,transport:n.transport??t.transport}:t}function y(t,n){const s=[];for(const i of t){if(!i.enabled)continue;const e=n[i.providerId];if(e)for(const o of l(i,e))s.push({channel:i,description:e,capability:o})}return s}function b(t,n){return n.filter(s=>s.capability.intent===t)}function a(t,n){return n.filter(s=>s.capability.targetSchemes.includes(t))}function h(t,n){return a(t.scheme,n)}function T(t,n,s){const i=[];for(const e of t)for(const o of s)o.capability.intent===n&&o.capability.targetSchemes.includes(e.scheme)&&i.push({channelIntent:o,endpoint:e});return i}var f=(t=>(t.MAILTO="mailto",t.SIP="sip",t.TEL="tel",t.WEBHOOK="webhook",t.USERNAME="username",t.ID="id",t.CUSTOM="custom",t.URL="url",t.TELEGRAM="telegram",t.WHATSAPP="whatsapp",t.VIBER="viber",t.SMS="sms",t.FAX="fax",t.TEAMS="teams",t))(f||{});exports.CommunicationScheme=f;exports.buildChannelIntents=y;exports.filterByEndpoint=h;exports.filterByIntent=b;exports.filterByTargetScheme=a;exports.getContactEndpoints=c;exports.getShortTitle=p;exports.getUrgencyScore=g;exports.isAssigned=u;exports.isClosed=d;exports.matchContactToIntents=T;exports.resolveChannelIntents=l;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function d(t){return t.endpoints??[]}const c=t=>!!t.assignedUserId||!!t.assignedInboxId,u=t=>t.status==="closed",p=t=>({urgent:10,high:5,normal:2,low:1})[t.priority]||0,g=(t,e=30)=>t.title?.length<=e?t.title:`${t.title.substring(0,e)}...`;function l(t,e){const s=new Set(t.disabledIntents??[]),i=t.intentOverrides??{},n=e.intents.filter(r=>!s.has(r.intent)).map(r=>I(r,i[r.intent]));if(!t.extraIntents||t.extraIntents.length===0)return n;const o=new Set(n.map(r=>r.intent));for(const r of t.extraIntents)o.has(r.intent)||(n.push(r),o.add(r.intent));return n}function I(t,e){return e?{intent:e.intent??t.intent,targetSchemes:e.targetSchemes??t.targetSchemes,transport:e.transport??t.transport}:t}function y(t,e){const s=[];for(const i of t){if(!i.enabled)continue;const n=e[i.providerId];if(n)for(const o of l(i,n))s.push({channel:i,description:n,capability:o})}return s}function E(t,e){return e.filter(s=>s.capability.intent===t)}function a(t,e){return e.filter(s=>s.capability.targetSchemes.includes(t))}function T(t,e){return a(t.scheme,e)}function b(t,e,s){const i=[];for(const n of t)for(const o of s)o.capability.intent===e&&o.capability.targetSchemes.includes(n.scheme)&&i.push({channelIntent:o,endpoint:n});return i}var f=(t=>(t.MAILTO="mailto",t.SIP="sip",t.TEL="tel",t.WEBHOOK="webhook",t.USERNAME="username",t.ID="id",t.CUSTOM="custom",t.URL="url",t.TELEGRAM="telegram",t.WHATSAPP="whatsapp",t.VIBER="viber",t.SMS="sms",t.FAX="fax",t.TEAMS="teams",t.CALENDAR="calendar",t))(f||{});const h=(t,e)=>({intent:t,...e}),S={ok:!1,code:"UNSUPPORTED",message:"Provider does not support this op"};exports.CommunicationScheme=f;exports.UNSUPPORTED=S;exports.buildChannelIntents=y;exports.defineIntent=h;exports.filterByEndpoint=T;exports.filterByIntent=E;exports.filterByTargetScheme=a;exports.getContactEndpoints=d;exports.getShortTitle=g;exports.getUrgencyScore=p;exports.isAssigned=c;exports.isClosed=u;exports.matchContactToIntents=b;exports.resolveChannelIntents=l;

package/dist/index.d.ts

@@ -8,6 +8,7 @@ export * from './entities/ai-profile';
 export * from './entities/channel';
 export * from './entities/communication';
 export * from './entities/contact';
+export * from './entities/calendar-event';
 export * from './entities/inbox';
 export * from './entities/interaction';
 export * from './entities/note';

package/dist/index.js

@@ -1,18 +1,18 @@
-function c(t) {
+function u(t) {
   return t.endpoints ?? [];
 }
-const d = (t) => !!t.assignedUserId || !!t.assignedInboxId, p = (t) => t.status === "closed", g = (t) => ({
+const p = (t) => !!t.assignedUserId || !!t.assignedInboxId, c = (t) => t.status === "closed", g = (t) => ({
   urgent: 10,
   high: 5,
   normal: 2,
   low: 1
 })[t.priority] || 0, I = (t, n = 30) => t.title?.length <= n ? t.title : `${t.title.substring(0, n)}...`;
 function f(t, n) {
-  const r = new Set(t.disabledIntents ?? []), i = t.intentOverrides ?? {}, e = n.intents.filter((s) => !r.has(s.intent)).map((s) => l(s, i[s.intent]));
+  const s = new Set(t.disabledIntents ?? []), i = t.intentOverrides ?? {}, e = n.intents.filter((r) => !s.has(r.intent)).map((r) => l(r, i[r.intent]));
   if (!t.extraIntents || t.extraIntents.length === 0) return e;
-  const o = new Set(e.map((s) => s.intent));
-  for (const s of t.extraIntents)
-    o.has(s.intent) || (e.push(s), o.add(s.intent));
+  const o = new Set(e.map((r) => r.intent));
+  for (const r of t.extraIntents)
+    o.has(r.intent) || (e.push(r), o.add(r.intent));
   return e;
 }
 function l(t, n) {
@@ -22,45 +22,48 @@ function l(t, n) {
     transport: n.transport ?? t.transport
   } : t;
 }
-function b(t, n) {
-  const r = [];
+function E(t, n) {
+  const s = [];
   for (const i of t) {
     if (!i.enabled) continue;
     const e = n[i.providerId];
     if (e)
       for (const o of f(i, e))
-        r.push({ channel: i, description: e, capability: o });
+        s.push({ channel: i, description: e, capability: o });
   }
-  return r;
+  return s;
 }
-function y(t, n) {
-  return n.filter((r) => r.capability.intent === t);
+function b(t, n) {
+  return n.filter((s) => s.capability.intent === t);
 }
 function a(t, n) {
-  return n.filter((r) => r.capability.targetSchemes.includes(t));
+  return n.filter((s) => s.capability.targetSchemes.includes(t));
 }
-function E(t, n) {
+function T(t, n) {
   return a(t.scheme, n);
 }
-function T(t, n, r) {
+function y(t, n, s) {
   const i = [];
   for (const e of t)
-    for (const o of r)
+    for (const o of s)
       o.capability.intent === n && o.capability.targetSchemes.includes(e.scheme) && i.push({ channelIntent: o, endpoint: e });
   return i;
 }
-var u = /* @__PURE__ */ ((t) => (t.MAILTO = "mailto", t.SIP = "sip", t.TEL = "tel", t.WEBHOOK = "webhook", t.USERNAME = "username", t.ID = "id", t.CUSTOM = "custom", t.URL = "url", t.TELEGRAM = "telegram", t.WHATSAPP = "whatsapp", t.VIBER = "viber", t.SMS = "sms", t.FAX = "fax", t.TEAMS = "teams", t))(u || {});
+var d = /* @__PURE__ */ ((t) => (t.MAILTO = "mailto", t.SIP = "sip", t.TEL = "tel", t.WEBHOOK = "webhook", t.USERNAME = "username", t.ID = "id", t.CUSTOM = "custom", t.URL = "url", t.TELEGRAM = "telegram", t.WHATSAPP = "whatsapp", t.VIBER = "viber", t.SMS = "sms", t.FAX = "fax", t.TEAMS = "teams", t.CALENDAR = "calendar", t))(d || {});
+const A = (t, n) => ({ intent: t, ...n }), U = { ok: !1, code: "UNSUPPORTED", message: "Provider does not support this op" };
 export {
-  u as CommunicationScheme,
-  b as buildChannelIntents,
-  E as filterByEndpoint,
-  y as filterByIntent,
+  d as CommunicationScheme,
+  U as UNSUPPORTED,
+  E as buildChannelIntents,
+  A as defineIntent,
+  T as filterByEndpoint,
+  b as filterByIntent,
   a as filterByTargetScheme,
-  c as getContactEndpoints,
+  u as getContactEndpoints,
   I as getShortTitle,
   g as getUrgencyScore,
-  d as isAssigned,
-  p as isClosed,
-  T as matchContactToIntents,
+  p as isAssigned,
+  c as isClosed,
+  y as matchContactToIntents,
   f as resolveChannelIntents
 };

package/dist/platform/capabilities.d.ts

@@ -6,7 +6,7 @@ import { CommunicationScheme, IntentCapability, ProviderDescription, Uri } from
  * default composers). Intent itself is an open string — providers may
  * declare anything. Unknown intents render as generic actions.
  */
-export type CommunicationIntent = "call" | "mail" | "message" | "video";
+export type CommunicationIntent = "call" | "mail" | "message" | "video" | "calendar";
 /**
  * A channel's effective intent — the resolved IntentCapability for this
  * specific channel, ready for routing/UI decisions.

package/dist/platform/communication.d.ts

@@ -33,12 +33,13 @@ export interface ITransportProvider {
         sessionId: string;
         stream: MediaStream;
     }) => void): () => void;
-    createSession(target: string, accountId: string): Promise<void>;
-    hangupSession(sessionId: string): Promise<void>;
     registerAccount(orgId: string, userId: string, config: any): Promise<CommsAccount>;
     unregisterAccount(accountId: string): Promise<void>;
-    setOutgoingStream(sessionId: string, stream: MediaStream | null): Promise<void>;
-    handleAction(sessionId: string, actionId: string, ...args: any[]): void;
+    /**
+     * Uniforme entry voor alle session-ops (invite/answer/hangup/hold/
+     * transfer/dtmf/set-stream).
+     */
+    dispatch(op: TransportOp): Promise<void>;
 }
 export type CommunicationDispatch = "transport" | "compose";
 export declare enum CommunicationScheme {
@@ -55,7 +56,8 @@ export declare enum CommunicationScheme {
     VIBER = "viber",
     SMS = "sms",
     FAX = "fax",
-    TEAMS = "teams"
+    TEAMS = "teams",
+    CALENDAR = "calendar"
 }
 /**
  * Account selector for `transport: session` intents. Tells the frontend
@@ -72,8 +74,18 @@ export interface AccountSelector {
     accountId?: string;
     matcherId?: string;
 }
+/**
+ * Routing-hint voor de frontend en de comm-server: hoe wordt deze intent
+ * uitgevoerd?
+ *
+ *  - `dispatch` — server-side via comm-server `provider/dispatch/` →
+ *    `IProvider.dispatch(op)` op de provider-app's server. Dekt
+ *    message.*, attachment.*, calendar.*, contact.* ServerOps.
+ *  - `session` — client-side via `ITransportProvider.dispatch(op)` in
+ *    de browser-UA (SIP/WebRTC). Geen server-roundtrip.
+ */
 export type TransportConfig = {
-    kind: "compose";
+    kind: "dispatch";
     /** Optional federated composer resource as "<app>:<resource>". */
     composer?: string;
     /**
@@ -168,3 +180,274 @@ export interface RemoteStreamEvent {
     stream: MediaStream | null;
     label?: string;
 }
+/**
+ * Helper voor compactere intent-declaraties in `/provider/describe`.
+ *   defineIntent("mail", { targetSchemes: [MAILTO], transport: { kind: "dispatch" } })
+ */
+export declare const defineIntent: (intent: string, opts: Omit<IntentCapability, "intent">) => IntentCapability;
+export interface ExternalId {
+    providerId: string;
+    kind: string;
+    value: string;
+}
+export interface AuditTrace {
+    actorId?: string;
+    timestamp: number;
+    note?: string;
+}
+export interface MessageBody {
+    subject?: string;
+    text?: string;
+    html?: string;
+    attachments?: Array<{
+        id: string;
+        name: string;
+        mimeType?: string;
+    }>;
+}
+export interface NoteBody {
+    text: string;
+    visibility?: "internal" | "team";
+}
+export interface FileRef {
+    id: string;
+    name: string;
+    mimeType?: string;
+    size?: number;
+}
+export interface CalendarEventInput {
+    title: string;
+    start: number;
+    end: number;
+    attendees?: Array<{
+        uri: Uri;
+        required?: boolean;
+    }>;
+    location?: string;
+    description?: string;
+    conferencing?: {
+        provider: string;
+        joinUri?: string;
+    };
+}
+/**
+ * Server-side ops uitgevoerd door de provider-app's server, getriggerd
+ * door comm-server `provider/dispatch/`. Payloads dragen IDs, geen
+ * volledige entities — provider resolved zelf via platform-api.
+ */
+export type ServerOp = {
+    kind: "message.new";
+    channelId: string;
+    intent: string;
+    recipient: Uri;
+    body: MessageBody;
+} | {
+    kind: "message.reply";
+    channelId: string;
+    interactionId: string;
+    activityId?: string;
+    body: MessageBody;
+} | {
+    kind: "message.comment";
+    channelId: string;
+    interactionId: string;
+    body: NoteBody;
+} | {
+    kind: "message.forward";
+    channelId: string;
+    activityId: string;
+    recipient: Uri;
+    body?: MessageBody;
+} | {
+    kind: "message.transcribe";
+    channelId: string;
+    activityId: string;
+} | {
+    kind: "attachment.download";
+    channelId: string;
+    activityId: string;
+    attachmentId: string;
+} | {
+    kind: "attachment.upload";
+    channelId: string;
+    interactionId: string;
+    file: FileRef;
+} | {
+    kind: "calendar.create";
+    channelId: string;
+    event: CalendarEventInput;
+} | {
+    kind: "calendar.update";
+    channelId: string;
+    eventId: string;
+    patch: Partial<CalendarEventInput>;
+} | {
+    kind: "calendar.cancel";
+    channelId: string;
+    eventId: string;
+    reason?: string;
+} | {
+    kind: "calendar.respond";
+    channelId: string;
+    eventId: string;
+    response: "accepted" | "tentative" | "declined";
+} | {
+    kind: "contact.search";
+    channelId: string;
+    query: string;
+} | {
+    kind: "contact.fetch";
+    channelId: string;
+    externalId: string;
+};
+/**
+ * Result-shape voor `IProvider.dispatch` en de comm-server `dispatchToProvider`-
+ * helper. Discriminated op `ok`. Bewust niet strict-null-discriminated zodat
+ * narrowing ook werkt zonder strictNullChecks (root tsconfig is non-strict).
+ */
+export interface ServerResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    externalIds?: ExternalId[];
+    audit?: AuditTrace;
+    code?: string;
+    message?: string;
+    retryable?: boolean;
+}
+export declare const UNSUPPORTED: ServerResult;
+/**
+ * Transport-ops uitgevoerd in de browser-UA (SIP/WebRTC), getriggerd
+ * door de frontend via `ITransportProvider.dispatch`. Geen server-
+ * roundtrip — directe controle over de lokale stack.
+ */
+export type TransportOp = {
+    kind: "session.invite";
+    accountId: string;
+    target: string;
+    withVideo?: boolean;
+} | {
+    kind: "session.answer";
+    sessionId: string;
+    withVideo?: boolean;
+} | {
+    kind: "session.reject";
+    sessionId: string;
+} | {
+    kind: "session.hangup";
+    sessionId: string;
+} | {
+    kind: "session.hold";
+    sessionId: string;
+    on: boolean;
+} | {
+    kind: "session.mute";
+    sessionId: string;
+    on?: boolean;
+} | {
+    kind: "session.transfer";
+    sessionId: string;
+    target: string;
+    mode: "blind" | "attended";
+} | {
+    kind: "session.dtmf";
+    sessionId: string;
+    digits: string;
+} | {
+    kind: "session.set-stream";
+    sessionId: string;
+    stream: MediaStream | null;
+} | {
+    kind: "session.toggle-camera";
+    sessionId: string;
+} | {
+    kind: "session.toggle-screen-share";
+    sessionId: string;
+};
+export interface TokenResponse {
+    access_token: string;
+    refresh_token?: string;
+    expires_in?: number;
+    id_token?: string;
+    scope?: string;
+    token_type?: string;
+    [extra: string]: unknown;
+}
+export interface OAuthConfig {
+    authorizeEndpoint: string;
+    tokenEndpoint: string;
+    clientId: string;
+    /** Server-side only — uit provider's secret-store. Mag leeg blijven voor PKCE. */
+    clientSecret?: string;
+    scopes: string[];
+    /** Extra params voor authorize-URL (prompt, access_type, etc.). */
+    authorizeParams?: Record<string, string>;
+    /** Optionele identity-decoder voor OAuth-providers met JWT id_token (MS, Google). */
+    decodeIdentity?: (tokens: TokenResponse) => Promise<{
+        externalUserId: string;
+        displayName?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    refresh?: {
+        bufferMs?: number;
+        /** Hook voor provider-specifieke post-refresh acties (bv. tenant-inferentie MS). */
+        postRefresh?: (tokens: TokenResponse) => Promise<void>;
+    };
+}
+export type PersonalAuthConfig = {
+    mode: "oauth2";
+    oauth: OAuthConfig;
+} | {
+    mode: "form";
+    fields: PersonalAuthField[];
+    message?: string;
+} | {
+    mode: "unavailable";
+    message?: string;
+};
+export interface PersonalAuthCtx {
+    organizationId: string;
+    userId: string;
+}
+export interface FormAuthCtx {
+    userId: string;
+    organizationId: string;
+}
+/**
+ * Server-side contract per communication-provider. Provider-apps
+ * registreren zich via `Bridge.providers.role({ type: "provider", group: "communication" })`
+ * en exposen routes die overeenkomen met deze methods (comm-server roept ze
+ * via Bridge.rpc aan).
+ *
+ * Niet bedoeld voor frontend-consumptie — frontend praat alleen met
+ * comm-server's `provider/*` en `account/*` endpoints.
+ */
+export interface IProvider {
+    readonly id: string;
+    describe(): Promise<ProviderDescription>;
+    listChannels(orgId: string, userId?: string): Promise<unknown[]>;
+    /**
+     * Comm-server vraagt provider om huidige auth-config. Reden om dit op
+     * IProvider te houden (i.p.v. statische registratie): clientId/secret/
+     * scopes komen vaak uit secret-store of tenant-config — niet code-statisch.
+     */
+    personalAuth(ctx: PersonalAuthCtx): Promise<PersonalAuthConfig>;
+    /**
+     * Voor `mode: "form"` — provider valideert credentials en bouwt het
+     * Account zelf. OAuth-mode hoeft dit niet; comm-server handelt token-
+     * exchange volledig.
+     */
+    completeFormAuth?(fields: Record<string, string>, ctx: FormAuthCtx): Promise<{
+        accountId: string;
+    }>;
+    /**
+     * Post-connect hook — provider mag eigen vervolgwerk doen (bv. MS
+     * user-connection channel-binding) NA dat het Account is opgeslagen.
+     */
+    onAccountConnected?(account: {
+        id: string;
+        providerId: string;
+        userId?: string;
+        organizationId: string;
+    }): Promise<void>;
+    dispatch(op: ServerOp): Promise<ServerResult>;
+}

package/dist/platform/provider.d.ts

@@ -69,6 +69,40 @@ export interface FindActivityByExternalProviderIdPayload {
     activityType: string;
     interactionId?: string;
 }
+/**
+ * Calendar/schedule transport payloads. Providers that declare an intent
+ * with `transport: { kind: "schedule" }` implement `/provider/schedule/*`
+ * routes. Communication-server dispatches CRUD on CalendarEvents to the
+ * corresponding provider via these payloads.
+ */
+export type ScheduleResponse = "accepted" | "declined" | "tentative";
+export interface SchedulePayload {
+    channelId: string;
+    /** Local CalendarEvent without storage-managed fields. */
+    event: any;
+}
+export interface ScheduleUpdatePayload {
+    channelId: string;
+    externalId: string;
+    patch: any;
+}
+export interface ScheduleCancelPayload {
+    channelId: string;
+    externalId: string;
+    comment?: string;
+}
+export interface ScheduleRespondPayload {
+    channelId: string;
+    externalId: string;
+    response: ScheduleResponse;
+    comment?: string;
+    sendResponse?: boolean;
+}
+export interface ScheduleResult {
+    externalId?: string;
+    /** Provider-side echo for caller persistence (e.g. Graph event id). */
+    providerData?: Record<string, unknown>;
+}
 export interface FileUploadPayload {
     file: Uint8Array;
     filename: string;

package/dist/platform/sdk.d.ts

@@ -49,12 +49,20 @@ export interface InternalSDK<LocalServices extends ServiceMap = {}, TranslationK
         sessions$: Observable<Session[]>;
         accounts$: Observable<CommsAccount[]>;
         activeSession$: Observable<Session | null>;
-        createSession(target: string, accountId: string): Promise<void>;
-        hangupSession(sessionId: string): Promise<void>;
+        /**
+         * 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>;
         registerAccount(organizationId: string, userId: string, providerId: string, config: any): Promise<CommsAccount>;
-        handleSessionAction(sessionId: string, actionId: string, ...args: any[]): Promise<void>;
         transcripts: {
             ingest(segments: TranscriptSegment[]): void;
             byCallSession$(sessionId: string): Observable<TranscriptSegment[]>;

package/package.json

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