@ethora/chat-component-rn 26.10.10 → 26.10.11

package/lib/typescript/booking/pendingScheduledCall.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Opening a scheduled call from a link or a reminder push.
+ *
+ * A link can arrive while the app is still starting: before the user is
+ * signed in, or before `<Chat>` has configured the store and connected. The
+ * slug is then held (in memory, and in AsyncStorage so a cold start that
+ * is interrupted by the sign-in screen keeps it) and opened once both are
+ * true. Opening = resolve the slug through the API, open its room, show the
+ * pre-join sheet. No media starts before the user taps Join.
+ */
+export declare const PENDING_SCHEDULED_CALL_KEY = "ethora_pending_scheduled_call";
+/** A link older than this is dropped instead of ambushing the user later. */
+export declare const PENDING_SCHEDULED_CALL_TTL_MS: number;
+export interface PendingStorage {
+    read(): Promise<{
+        slug: string;
+        at: number;
+    } | null>;
+    write(value: {
+        slug: string;
+        at: number;
+    }): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare const asyncPendingStorage: PendingStorage;
+export interface PendingQueueDeps {
+    /** Signed in AND the chat is configured and connected. */
+    isReady: () => boolean;
+    /** Opens the call; called once per held link, when ready. */
+    open: (slug: string) => void;
+    storage: PendingStorage;
+    now?: () => number;
+    ttlMs?: number;
+}
+/**
+ * The hold-until-ready logic, free of the store so it can be tested. One
+ * slot: a newer link replaces an older one (the user tapped it last).
+ */
+export declare const createPendingScheduledCallQueue: (deps: PendingQueueDeps) => {
+    /** A link arrived: open it now, or hold it. Returns what happened. */
+    submit(slug: string): "opened" | "held";
+    /** Something that can make us ready changed. */
+    poke(): boolean;
+    /** Pick up a link persisted by an earlier run of the app. */
+    restore(): Promise<void>;
+    peek: () => {
+        slug: string;
+        at: number;
+    } | null;
+    reset(): void;
+};
+export declare const isScheduledCallReady: () => boolean;
+/** Resolve the slug, open its room, show the pre-join sheet. */
+export declare const resolveAndOpenScheduledCall: (slug: string) => Promise<void>;
+/**
+ * Watches the store so a held link opens the moment sign-in and the chat
+ * are both there. Idempotent; `<Chat>` arms it on import and
+ * `openScheduledCall` arms it too, so a link that beats `<Chat>` is not lost.
+ */
+export declare const installScheduledCallHook: () => void;
+/**
+ * Open a scheduled call by slug: now when the user is signed in and the
+ * chat is up, otherwise as soon as both are true. Returns `'opening'` when
+ * it started right away and `'pending'` when it is held.
+ */
+export declare const openScheduledCall: (slug: string) => "opening" | "pending";
+/**
+ * Hand any URL to the SDK: a scheduled-call link is opened (or held) and
+ * `true` is returned; anything else returns `false` untouched.
+ */
+export declare const handleScheduledCallUrl: (url: string | null | undefined) => boolean;
+/** The reminder push the backend sends 10 minutes before a call. */
+export declare const SCHEDULED_CALL_REMINDER_PUSH_TYPE = "scheduledCallReminder";
+export declare const isScheduledCallReminderPush: (data: Record<string, unknown> | null | undefined) => boolean;
+/** Slug of a reminder push: `slug`, else parsed out of `joinUrl`. */
+export declare const scheduledCallSlugFromPush: (data: Record<string, unknown> | null | undefined) => string | null;
+/** A tap on the reminder push opens the same flow as the join link. */
+export declare const handleScheduledCallPush: (data: Record<string, unknown> | null | undefined) => boolean;
+export declare const __resetPendingScheduledCallForTests: () => void;
+//# sourceMappingURL=pendingScheduledCall.d.ts.map

package/lib/typescript/booking/pendingScheduledCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pendingScheduledCall.d.ts","sourceRoot":"","sources":["../../../src/booking/pendingScheduledCall.ts"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AAEH,eAAO,MAAM,0BAA0B,kCAAkC,CAAC;AAC1E,6EAA6E;AAC7E,eAAO,MAAM,6BAA6B,QAAiB,CAAC;AAE5D,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACrD,KAAK,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,eAAO,MAAM,mBAAmB,EAAE,cA2BjC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,0DAA0D;IAC1D,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,6DAA6D;IAC7D,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7B,OAAO,EAAE,cAAc,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,eAAO,MAAM,+BAA+B,GAAI,MAAM,gBAAgB;IAyBlE,sEAAsE;iBACzD,MAAM,GAAG,QAAQ,GAAG,MAAM;IAMvC,gDAAgD;YACxC,OAAO;IAGf,6DAA6D;eAC5C,OAAO,CAAC,IAAI,CAAC;;cAlCd,MAAM;YAAM,MAAM;;;CAoDrC,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAO,OAOvC,CAAC;AAeF,gEAAgE;AAChE,eAAO,MAAM,2BAA2B,GACtC,MAAM,MAAM,KACX,OAAO,CAAC,IAAI,CAoCd,CAAC;AAYF;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,QAAO,IAM3C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,SAAS,GAAG,SAG5D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,KAAG,OAKvE,CAAC;AAEF,oEAAoE;AACpE,eAAO,MAAM,iCAAiC,0BAA0B,CAAC;AAEzE,eAAO,MAAM,2BAA2B,GACtC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,KAC/C,OAAyE,CAAC;AAE7E,qEAAqE;AACrE,eAAO,MAAM,yBAAyB,GACpC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,KAC/C,MAAM,GAAG,IAKX,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,uBAAuB,GAClC,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,GAAG,SAAS,KAC/C,OAKF,CAAC;AAEF,eAAO,MAAM,mCAAmC,QAAO,IAItD,CAAC"}

package/lib/typescript/booking/scheduleForm.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Pure helpers behind the schedule / edit sheet: the default start, the
+ * stepper arithmetic and the validation the server repeats.
+ */
+export declare const MIN_DURATION_MINUTES = 5;
+export declare const MAX_DURATION_MINUTES = 480;
+export declare const DEFAULT_DURATION_MINUTES = 30;
+export declare const DURATION_CHOICES: number[];
+export declare const TIME_STEP_MINUTES = 15;
+export declare const TITLE_MAX = 200;
+export declare const NOTES_MAX = 2000;
+/** The server accepts a start this far in the past (clock skew). */
+export declare const CLOCK_SKEW_MS: number;
+/** The next quarter hour that is at least 15 minutes away. */
+export declare const defaultStartMs: (now: number) => number;
+/** Move by whole local days (DST safe: done on the calendar, not by 24 h). */
+export declare const shiftDays: (ms: number, days: number) => number;
+export declare const shiftMinutes: (ms: number, minutes: number) => number;
+export declare const clampDuration: (minutes: number) => number;
+export type ScheduleFormError = 'pastTime' | null;
+/** Only the rules the client can check; the server stays the authority. */
+export declare const validateStart: (startMs: number, now: number, options?: {
+    allowPast?: boolean;
+}) => ScheduleFormError;
+export declare const deviceTimezone: () => string | undefined;
+export declare const formatDay: (ms: number, locale?: string) => string;
+export declare const formatClock: (ms: number, locale?: string) => string;
+//# sourceMappingURL=scheduleForm.d.ts.map

package/lib/typescript/booking/scheduleForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduleForm.d.ts","sourceRoot":"","sources":["../../../src/booking/scheduleForm.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,wBAAwB,KAAK,CAAC;AAC3C,eAAO,MAAM,gBAAgB,UAA4B,CAAC;AAC1D,eAAO,MAAM,iBAAiB,KAAK,CAAC;AACpC,eAAO,MAAM,SAAS,MAAM,CAAC;AAC7B,eAAO,MAAM,SAAS,OAAO,CAAC;AAC9B,oEAAoE;AACpE,eAAO,MAAM,aAAa,QAAgB,CAAC;AAI3C,8DAA8D;AAC9D,eAAO,MAAM,cAAc,GAAI,KAAK,MAAM,KAAG,MAI5C,CAAC;AAEF,8EAA8E;AAC9E,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,EAAE,MAAM,MAAM,KAAG,MAIpD,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,IAAI,MAAM,EAAE,SAAS,MAAM,KAAG,MACpC,CAAC;AAExB,eAAO,MAAM,aAAa,GAAI,SAAS,MAAM,KAAG,MAI/C,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,IAAI,CAAC;AAElD,2EAA2E;AAC3E,eAAO,MAAM,aAAa,GACxB,SAAS,MAAM,EACf,KAAK,MAAM,EACX,UAAU;IAAE,SAAS,CAAC,EAAE,OAAO,CAAA;CAAE,KAChC,iBAIF,CAAC;AAEF,eAAO,MAAM,cAAc,QAAO,MAAM,GAAG,SAM1C,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,EAAE,SAAS,MAAM,KAAG,MAWvD,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,IAAI,MAAM,EAAE,SAAS,MAAM,KAAG,MASzD,CAAC"}

package/lib/typescript/booking/scheduledCall.d.ts

@@ -0,0 +1,52 @@
+import type { IMessage } from '../types/types';
+/**
+ * Scheduled-call invite cards: what a `<data type="scheduledCall">` message
+ * says, and the pure rules for which message owns a card and what state the
+ * card is in. No React, no store: everything here is unit-testable.
+ */
+export declare const SCHEDULED_CALL_MESSAGE_TYPE = "scheduledCall";
+/** Join opens this long before the start (contract: 15 minutes). */
+export declare const JOIN_WINDOW_BEFORE_MS: number;
+export type ScheduledCallMessageStatus = 'scheduled' | 'updated' | 'cancelled';
+/** upcoming -> joinable (15 min before start until the end) -> ended; or cancelled. */
+export type ScheduledCallCardState = 'upcoming' | 'joinable' | 'ended' | 'cancelled';
+export interface ScheduledCallCardData {
+    slug: string;
+    title: string;
+    /** ISO UTC. */
+    startAt: string;
+    startMs: number;
+    durationMinutes: number;
+    kind: 'video' | 'audio';
+    status: ScheduledCallMessageStatus;
+    joinUrl: string;
+    icsUrl: string;
+    googleUrl: string;
+    outlookUrl: string;
+    /** Creator's user id (`scheduledCallCreatedBy`); '' on an invite that predates it. */
+    createdBy: string;
+}
+export declare const isScheduledCallMessage: (message: unknown) => boolean;
+/**
+ * The card data a message carries, or null when it is not a usable invite
+ * (no slug, or a start time that is not a date). Defaults follow the
+ * contract: 30 minutes, video, status `scheduled`.
+ */
+export declare const parseScheduledCallMessage: (message: unknown) => ScheduledCallCardData | null;
+export declare const latestScheduledCallMessages: (messages: ReadonlyArray<IMessage> | undefined | null) => Map<string, IMessage>;
+/** The message that owns this slug's card, or undefined for no invite at all. */
+export declare const latestScheduledCallMessage: (messages: ReadonlyArray<IMessage> | undefined | null, slug: string) => IMessage | undefined;
+export declare const scheduledCallEndMs: (card: Pick<ScheduledCallCardData, "startMs" | "durationMinutes">) => number;
+/** Where a card stands at `now` (epoch ms). */
+export declare const getScheduledCallCardState: (card: Pick<ScheduledCallCardData, "startMs" | "durationMinutes" | "status">, now: number) => ScheduledCallCardState;
+/**
+ * The next instant the card's state changes (join window opens, call ends),
+ * or null when it will not change on its own (cancelled / ended). Lets the
+ * card sleep until then instead of polling.
+ */
+export declare const nextScheduledCallTransition: (card: Pick<ScheduledCallCardData, "startMs" | "durationMinutes" | "status">, now: number) => number | null;
+/** Longest a single setTimeout may sleep (the platform clamps at 2^31-1 ms). */
+export declare const MAX_TIMER_MS = 2000000000;
+/** The room's bare name, as the call and booking endpoints take it. */
+export declare const chatNameOfRoom: (roomJidOrName: string) => string;
+//# sourceMappingURL=scheduledCall.d.ts.map

package/lib/typescript/booking/scheduledCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduledCall.d.ts","sourceRoot":"","sources":["../../../src/booking/scheduledCall.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE/C;;;;GAIG;AAEH,eAAO,MAAM,2BAA2B,kBAAkB,CAAC;AAE3D,oEAAoE;AACpE,eAAO,MAAM,qBAAqB,QAAiB,CAAC;AAEpD,MAAM,MAAM,0BAA0B,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,CAAC;AAE/E,uFAAuF;AACvF,MAAM,MAAM,sBAAsB,GAC9B,UAAU,GACV,UAAU,GACV,OAAO,GACP,WAAW,CAAC;AAEhB,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,eAAe;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,MAAM,EAAE,0BAA0B,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC;CACnB;AAKD,eAAO,MAAM,sBAAsB,GAAI,SAAS,OAAO,KAAG,OAEb,CAAC;AAE9C;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GACpC,SAAS,OAAO,KACf,qBAAqB,GAAG,IA4B1B,CAAC;AASF,eAAO,MAAM,2BAA2B,GACtC,UAAU,aAAa,CAAC,QAAQ,CAAC,GAAG,SAAS,GAAG,IAAI,KACnD,GAAG,CAAC,MAAM,EAAE,QAAQ,CAoBtB,CAAC;AAEF,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,GACrC,UAAU,aAAa,CAAC,QAAQ,CAAC,GAAG,SAAS,GAAG,IAAI,EACpD,MAAM,MAAM,KACX,QAAQ,GAAG,SAA4D,CAAC;AAE3E,eAAO,MAAM,kBAAkB,GAC7B,MAAM,IAAI,CAAC,qBAAqB,EAAE,SAAS,GAAG,iBAAiB,CAAC,KAC/D,MAAyD,CAAC;AAE7D,+CAA+C;AAC/C,eAAO,MAAM,yBAAyB,GACpC,MAAM,IAAI,CACR,qBAAqB,EACrB,SAAS,GAAG,iBAAiB,GAAG,QAAQ,CACzC,EACD,KAAK,MAAM,KACV,sBAKF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,GACtC,MAAM,IAAI,CACR,qBAAqB,EACrB,SAAS,GAAG,iBAAiB,GAAG,QAAQ,CACzC,EACD,KAAK,MAAM,KACV,MAAM,GAAG,IAKX,CAAC;AAEF,gFAAgF;AAChF,eAAO,MAAM,YAAY,aAAgB,CAAC;AAE1C,uEAAuE;AACvE,eAAO,MAAM,cAAc,GAAI,eAAe,MAAM,KAAG,MACZ,CAAC"}

package/lib/typescript/booking/scheduledCallActions.d.ts

@@ -0,0 +1,22 @@
+import { type ScheduledCallDetail } from '../networking/api-requests/scheduledCalls.api';
+export declare const notifyScheduledCall: (type: "success" | "error", message: string) => void;
+/** A link the backend gave us, opened as is. Only web links are opened. */
+export declare const openBackendLink: (url: string | undefined) => Promise<void>;
+/** The user tapped Join: the room's ordinary call start / join. */
+export declare const joinScheduledCall: (roomJidOrName: string, kind: "audio" | "video") => Promise<boolean>;
+/** Ask, then cancel. Resolves true when the call was cancelled. */
+export declare const confirmAndCancelScheduledCall: (slug: string) => Promise<boolean>;
+export declare const getScheduledCallDetailCached: (slug: string, version: string) => Promise<ScheduledCallDetail>;
+export declare const invalidateScheduledCallDetail: (slug: string) => void;
+export declare const __resetScheduledCallDetailCacheForTests: () => void;
+/**
+ * May this user edit or cancel the call? The server decides for real
+ * (creator or room owner); this only decides whether to show the buttons.
+ */
+export declare const canManageScheduledCall: (params: {
+    createdBy?: string;
+    userId?: string;
+    roomRole?: string;
+}) => boolean;
+export declare const currentUserId: () => string;
+//# sourceMappingURL=scheduledCallActions.d.ts.map

package/lib/typescript/booking/scheduledCallActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduledCallActions.d.ts","sourceRoot":"","sources":["../../../src/booking/scheduledCallActions.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,+CAA+C,CAAC;AAmBvD,eAAO,MAAM,mBAAmB,SARX,SAAS,GAAG,OAAO,WAAW,MAAM,SAQjB,CAAC;AAEzC,2EAA2E;AAC3E,eAAO,MAAM,eAAe,GAAU,KAAK,MAAM,GAAG,SAAS,KAAG,OAAO,CAAC,IAAI,CAU3E,CAAC;AASF,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,GAC5B,eAAe,MAAM,EACrB,MAAM,OAAO,GAAG,OAAO,KACtB,OAAO,CAAC,OAAO,CAQjB,CAAC;AAuBF,mEAAmE;AACnE,eAAO,MAAM,6BAA6B,GACxC,MAAM,MAAM,KACX,OAAO,CAAC,OAAO,CAWjB,CAAC;AAMF,eAAO,MAAM,4BAA4B,GACvC,MAAM,MAAM,EACZ,SAAS,MAAM,KACd,OAAO,CAAC,mBAAmB,CAS7B,CAAC;AAEF,eAAO,MAAM,6BAA6B,GAAI,MAAM,MAAM,KAAG,IAI5D,CAAC;AAEF,eAAO,MAAM,uCAAuC,QAAO,IAAuB,CAAC;AAEnF;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ;IAC7C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,KAAG,OAIH,CAAC;AAEF,eAAO,MAAM,aAAa,QAAO,MACkB,CAAC"}

package/lib/typescript/booking/scheduledCallLink.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Deep links for scheduled calls.
+ *
+ *   https://<host>/call/<slug>      universal / app link, <host> must be a known host
+ *   <scheme>://call/<slug>          the app's own URL scheme
+ *
+ * The slug is the secret in the link; this only extracts it. Whether the
+ * signed-in user may see the call is the server's answer to
+ * `GET /v1/chats/calls/scheduled/:slug`.
+ *
+ * Known hosts and schemes come from `config.scheduledCalls` and from
+ * `configureScheduledCallLinks()`, which a host calls at startup so a link
+ * that opens the app before `<Chat>` is mounted can already be recognised.
+ */
+/** The hosted web app: always accepted. */
+export declare const DEFAULT_SCHEDULED_CALL_HOSTS: string[];
+export interface ScheduledCallLinkOptions {
+    /** Hosts whose `https://<host>/call/<slug>` links open the app. */
+    hosts?: string[];
+    /** Custom URL schemes, without `://` (e.g. `ethorachat`). */
+    schemes?: string[];
+}
+/** Replaces the host list and schemes set by a previous call. */
+export declare const configureScheduledCallLinks: (options: ScheduledCallLinkOptions) => void;
+export declare const __resetScheduledCallLinksForTests: () => void;
+/** Every host and scheme in force right now. */
+export declare const getScheduledCallLinkTargets: () => Required<ScheduledCallLinkOptions>;
+/**
+ * The slug of a scheduled-call link, or null when the URL is anything else.
+ *
+ * `https://app.chat.ethora.com/call/<slug>` (and any other configured host)
+ * and `<scheme>://call/<slug>` qualify. With no scheme configured any custom
+ * scheme is accepted (only `http(s)` and a few script-like ones never are);
+ * once schemes are configured only those are.
+ */
+export declare const parseScheduledCallLink: (url: string | null | undefined, options?: ScheduledCallLinkOptions) => string | null;
+//# sourceMappingURL=scheduledCallLink.d.ts.map

package/lib/typescript/booking/scheduledCallLink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduledCallLink.d.ts","sourceRoot":"","sources":["../../../src/booking/scheduledCallLink.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AAEH,2CAA2C;AAC3C,eAAO,MAAM,4BAA4B,UAA0B,CAAC;AAEpE,MAAM,WAAW,wBAAwB;IACvC,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAmBD,iEAAiE;AACjE,eAAO,MAAM,2BAA2B,GACtC,SAAS,wBAAwB,KAChC,IAKF,CAAC;AAEF,eAAO,MAAM,iCAAiC,QAAO,IAEpD,CAAC;AAUF,gDAAgD;AAChD,eAAO,MAAM,2BAA2B,QAAO,QAAQ,CAAC,wBAAwB,CAc/E,CAAC;AAqBF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,GACjC,KAAK,MAAM,GAAG,IAAI,GAAG,SAAS,EAC9B,UAAU,wBAAwB,KACjC,MAAM,GAAG,IA+BX,CAAC"}

package/lib/typescript/booking/scheduledCallStore.d.ts

@@ -0,0 +1,47 @@
+import type { ScheduledCallDetail } from '../networking/api-requests/scheduledCalls.api';
+/**
+ * UI state of the scheduled-call flow: the pre-join sheet (a call opened from
+ * a card or a link) and the editor (schedule a new call / edit one). Kept
+ * outside redux because it is transient and has no business in persistence,
+ * the same way the call overlay's own UI state is (VideoCalls/callUiStore).
+ */
+export type PreJoinErrorReason = 'not-a-member' | 'not-found' | 'cancelled' | 'network';
+export type PreJoinState = {
+    phase: 'loading';
+    slug: string;
+} | {
+    phase: 'ready';
+    slug: string;
+    detail: ScheduledCallDetail;
+} | {
+    phase: 'error';
+    slug: string;
+    reason: PreJoinErrorReason;
+    /** The call's title when the server told us (cancelled). */
+    title?: string;
+};
+export type EditorState = {
+    mode: 'create';
+    roomJid: string;
+} | {
+    mode: 'edit';
+    roomJid: string;
+    detail: ScheduledCallDetail;
+};
+interface ScheduledCallUiState {
+    preJoin: PreJoinState | null;
+    editor: EditorState | null;
+}
+export declare const scheduledCallUi: {
+    getState: () => ScheduledCallUiState;
+    subscribe: (listener: () => void) => (() => void);
+    showPreJoin: (preJoin: PreJoinState) => void;
+    closePreJoin: () => void;
+    openCreate: (roomJid: string) => void;
+    openEdit: (roomJid: string, detail: ScheduledCallDetail) => void;
+    closeEditor: () => void;
+    reset: () => void;
+};
+export declare const useScheduledCallUi: () => ScheduledCallUiState;
+export {};
+//# sourceMappingURL=scheduledCallStore.d.ts.map

package/lib/typescript/booking/scheduledCallStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduledCallStore.d.ts","sourceRoot":"","sources":["../../../src/booking/scheduledCallStore.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,mBAAmB,EACpB,MAAM,+CAA+C,CAAC;AAEvD;;;;;GAKG;AAEH,MAAM,MAAM,kBAAkB,GAC1B,cAAc,GACd,WAAW,GACX,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,MAAM,YAAY,GACpB;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAClC;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,GAC7D;IACE,KAAK,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,kBAAkB,CAAC;IAC3B,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEN,MAAM,MAAM,WAAW,GACnB;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAAC;AAEnE,UAAU,oBAAoB;IAC5B,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;CAC5B;AAUD,eAAO,MAAM,eAAe;oBACZ,oBAAoB;0BACZ,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC;2BAMxB,YAAY;;0BAEb,MAAM;wBACR,MAAM,UAAU,mBAAmB;;;CAIxD,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAO,oBAKnC,CAAC"}

package/lib/typescript/booking/startRoomCall.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Joining a scheduled call is the ordinary call start for that room, taken
+ * on a user tap: a private room starts (or answers) its call, a group or
+ * public room starts or joins the room call. This file is the ONE place the
+ * booking flow reaches into the call path, so when the call transport
+ * changes only this function follows (it mirrors CallButtons.placeCall and
+ * hands the request to the shared requestOutgoingCall, so a private room
+ * gets the p2p call and a group room the LiveKit one, as the server decides).
+ */
+export type StartRoomCallOutcome = 'started' | 'answered' | 'busy' | 'disabled' | 'no-room' | 'failed';
+export declare const startRoomCall: (roomJid: string, kind: "audio" | "video") => Promise<StartRoomCallOutcome>;
+//# sourceMappingURL=startRoomCall.d.ts.map

package/lib/typescript/booking/startRoomCall.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"startRoomCall.d.ts","sourceRoot":"","sources":["../../../src/booking/startRoomCall.ts"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AAEH,MAAM,MAAM,oBAAoB,GAC5B,SAAS,GACT,UAAU,GACV,MAAM,GACN,UAAU,GACV,SAAS,GACT,QAAQ,CAAC;AAIb,eAAO,MAAM,aAAa,GACxB,SAAS,MAAM,EACf,MAAM,OAAO,GAAG,OAAO,KACtB,OAAO,CAAC,oBAAoB,CAqE9B,CAAC"}

package/lib/typescript/calls/callBusy.d.ts

@@ -0,0 +1,9 @@
+import type { BusyCallSnapshot } from './callMode';
+/**
+ * The call slice as `decideIncomingWhileBusy` should see it. A call that
+ * failed (phase 'error') only has its error card left on screen, waiting to
+ * be dismissed; it must not make the phone refuse the next incoming call as
+ * busy.
+ */
+export declare const busySnapshot: (call: BusyCallSnapshot) => BusyCallSnapshot;
+//# sourceMappingURL=callBusy.d.ts.map

package/lib/typescript/calls/callBusy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callBusy.d.ts","sourceRoot":"","sources":["../../../src/calls/callBusy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,gBAAgB,KAAG,gBACM,CAAC"}

package/lib/typescript/calls/callDisplay.d.ts

@@ -0,0 +1,23 @@
+/** Shown on the ring screen when no human-readable name is known. */
+export declare const NEUTRAL_INCOMING_CALL_LABEL = "Incoming call";
+/**
+ * True for strings that are a chat's internal name or an id rather than
+ * something a person would be called: two user JIDs joined (the private chat
+ * name), a lone user id, an `<appId>_<uuid>` group name, or any long run of
+ * hex / underscore / hyphen.
+ */
+export declare const looksLikeRawRoomName: (value: unknown) => boolean;
+/**
+ * Plain-text, display-safe version of a name: control characters stripped,
+ * whitespace collapsed and trimmed, capped at about 80 characters. Returns ''
+ * when nothing usable is left or the value is a raw chat name / id.
+ */
+export declare const sanitizeCallName: (value: unknown) => string;
+/** sanitizeCallName with null instead of '' (state-friendly). */
+export declare const safeCallName: (value: unknown) => string | null;
+/**
+ * An xmppUsername from a stanza attribute, or null when it is not shaped like
+ * one (it is only ever used for lookups and routing, never shown).
+ */
+export declare const sanitizeXmppUsername: (value: unknown) => string | null;
+//# sourceMappingURL=callDisplay.d.ts.map

package/lib/typescript/calls/callDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callDisplay.d.ts","sourceRoot":"","sources":["../../../src/calls/callDisplay.ts"],"names":[],"mappings":"AAKA,qEAAqE;AACrE,eAAO,MAAM,2BAA2B,kBAAkB,CAAC;AAiB3D;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,OAQrD,CAAC;AAOF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,MAUjD,CAAC;AAEF,iEAAiE;AACjE,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,IACtB,CAAC;AAElC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,MAAM,GAAG,IAI9D,CAAC"}

package/lib/typescript/calls/callMode.d.ts

@@ -0,0 +1,106 @@
+export type CallMode = 'livekit' | 'p2p';
+export type CallKindName = 'audio' | 'video';
+export type CallRoomType = 'private' | 'group';
+/** Serializable subset of RTCIceServer (kept free of DOM types for redux). */
+export interface IceServerConfig {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+}
+/**
+ * Accepts an array, an `{ iceServers }` envelope or a JSON string of either
+ * (the call-token stanza carries the list as a JSON attribute) and returns
+ * only well formed stun/turn entries. Anything else is dropped, never thrown.
+ */
+export declare const normalizeIceServers: (raw: unknown) => IceServerConfig[];
+/**
+ * A LiveKit server URL as the backend publishes it. Only websocket / http(s)
+ * URLs are accepted: the value ends up as the connect target of the media
+ * session, so anything else (javascript:, data:, garbage) is treated as unset.
+ */
+export declare const normalizeLivekitUrl: (raw: unknown) => string | null;
+/** Attributes of a `<data type="call-token">` element, defensively read. */
+export interface ParsedCallTokenAttrs {
+    token: string;
+    room: string;
+    /** Raw `callId` attribute, null when absent (the JWT may still carry it). */
+    callId: string | null;
+    /** Valid `kind` attribute, null when absent or unrecognised. */
+    kind: CallKindName | null;
+    mode: CallMode;
+    group: boolean;
+    /** Callee's ICE servers for `mode=p2p`, null when absent or unparseable. */
+    iceServers: IceServerConfig[] | null;
+    /**
+     * Public LiveKit wss URL for `mode=livekit`, null when the server did not
+     * send one (older backends), it is empty, or it is not a usable URL.
+     */
+    livekitUrl: string | null;
+    /**
+     * Caller's display name as plain text (control characters stripped, capped,
+     * raw chat names refused); '' when absent. Only trustworthy from the system
+     * account, see calls/senderTrust.
+     */
+    callerName: string;
+    /** Caller's xmppUsername when well formed, else null. Same trust rule. */
+    caller: string | null;
+}
+/**
+ * Tolerant reader for the call-token stanza. A server that sends neither
+ * `mode` nor `group` (every server before P2P / group calls) yields
+ * `mode: 'livekit'`, `group: false`, i.e. exactly the legacy behaviour.
+ */
+export declare const parseCallTokenAttrs: (attrs: Record<string, any> | undefined | null) => ParsedCallTokenAttrs;
+/** Normalised `POST /v1/chats/call/create/:chatName` response. */
+export interface CallCreateResult {
+    callId: string | null;
+    mode: CallMode;
+    kind: CallKindName;
+    /** Server-reported group flag, null when the server did not say. */
+    group: boolean | null;
+    /** Public LiveKit wss URL when the server knows it. */
+    livekitUrl: string | null;
+    iceServers: IceServerConfig[];
+    ttlSeconds: number | null;
+}
+/**
+ * Reads the create response. Old servers answer with no `mode`, which maps to
+ * `livekit` (the caller then waits for its own call-token as before). A p2p
+ * answer without a callId is unusable (no way to correlate signalling) and
+ * throws.
+ */
+export declare const parseCallCreateResponse: (data: unknown, fallbackKind: CallKindName) => CallCreateResult;
+/**
+ * Which room types may start / receive calls. Hosts that never set
+ * `allowedRoomTypes` get 1:1 and group chats; an explicit list is respected
+ * as written (so `['private']` keeps a host on 1:1 only).
+ */
+export declare const DEFAULT_CALL_ROOM_TYPES: CallRoomType[];
+export declare const isCallRoomTypeAllowed: (roomType: string | undefined | null, allowedRoomTypes?: CallRoomType[] | null) => boolean;
+export interface BusyCallSnapshot {
+    phase: string;
+    direction: 'incoming' | 'outgoing' | null;
+    mode: CallMode;
+    callId: string | null;
+    roomBareName: string | null;
+}
+/**
+ * What to do with an incoming call-token while another call may be active.
+ *  - accept:      nothing active, ring.
+ *  - duplicate:   same callId as the active call (server re-delivery), ignore.
+ *  - replace:     legacy LiveKit behaviour (a new token overwrites the old
+ *                 call), kept exactly for livekit-vs-livekit.
+ *  - glare-yield: both sides dialled each other; the lexicographically smaller
+ *                 callId wins on BOTH ends, and this is the loser: drop our
+ *                 outgoing call and ring for theirs.
+ *  - glare-keep:  same race, we hold the winning callId, ignore theirs (the
+ *                 other side yields).
+ *  - busy:        a different call is in progress, decline the newcomer.
+ */
+export type IncomingWhileBusyDecision = 'accept' | 'duplicate' | 'replace' | 'glare-yield' | 'glare-keep' | 'busy';
+export declare const decideIncomingWhileBusy: (current: BusyCallSnapshot, incoming: {
+    mode: CallMode;
+    callId: string | null;
+    roomBareName: string | null;
+}) => IncomingWhileBusyDecision;
+//# sourceMappingURL=callMode.d.ts.map

package/lib/typescript/calls/callMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callMode.d.ts","sourceRoot":"","sources":["../../../src/calls/callMode.ts"],"names":[],"mappings":"AAYA,MAAM,MAAM,QAAQ,GAAG,SAAS,GAAG,KAAK,CAAC;AACzC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,OAAO,CAAC;AAC7C,MAAM,MAAM,YAAY,GAAG,SAAS,GAAG,OAAO,CAAC;AAE/C,8EAA8E;AAC9E,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAID;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,OAAO,KAAG,eAAe,EA4CjE,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,KAAK,OAAO,KAAG,MAAM,GAAG,IAG3D,CAAC;AASF,4EAA4E;AAC5E,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,gEAAgE;IAChE,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,4EAA4E;IAC5E,UAAU,EAAE,eAAe,EAAE,GAAG,IAAI,CAAC;IACrC;;;OAGG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB,0EAA0E;IAC1E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,GAAG,IAAI,KAC5C,oBAyBF,CAAC;AAEF,kEAAkE;AAClE,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,YAAY,CAAC;IACnB,oEAAoE;IACpE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IACtB,uDAAuD;IACvD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,MAAM,OAAO,EACb,cAAc,YAAY,KACzB,gBAoCF,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,YAAY,EAAyB,CAAC;AAE5E,eAAO,MAAM,qBAAqB,GAChC,UAAU,MAAM,GAAG,SAAS,GAAG,IAAI,EACnC,mBAAmB,YAAY,EAAE,GAAG,IAAI,KACvC,OAIF,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,IAAI,CAAC;IAC1C,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,yBAAyB,GACjC,QAAQ,GACR,WAAW,GACX,SAAS,GACT,aAAa,GACb,YAAY,GACZ,MAAM,CAAC;AAEX,eAAO,MAAM,uBAAuB,GAClC,SAAS,gBAAgB,EACzB,UAAU;IACR,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B,KACA,yBAmBF,CAAC"}

package/lib/typescript/calls/declineReport.d.ts

@@ -0,0 +1,11 @@
+/**
+ * A peer to peer call has no LiveKit webhook, so the server learns that the
+ * callee rejected it (and relays that to the caller) only from this report.
+ * Never sent for a LiveKit call, where a REST decline would act on the
+ * LiveKit room. REST needs no socket, so it can go out at once.
+ */
+export declare const reportDeclineIfP2P: (call: {
+    mode: string;
+    callId: string | null;
+}) => void;
+//# sourceMappingURL=declineReport.d.ts.map

package/lib/typescript/calls/declineReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declineReport.d.ts","sourceRoot":"","sources":["../../../src/calls/declineReport.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,GAAI,MAAM;IACvC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,KAAG,IAIH,CAAC"}

package/lib/typescript/calls/p2p/P2PCallController.d.ts

@@ -0,0 +1,150 @@
+import type { IceServerConfig } from '../callMode';
+import { P2PRole } from './negotiator';
+import type { P2PSignal, P2PSignalName, P2PSignalPayload } from './signalStanza';
+export type P2PStatus = 'preparing' | 'waiting' | 'connecting' | 'connected' | 'reconnecting' | 'failed' | 'ended';
+export interface P2PSnapshot {
+    status: P2PStatus;
+    localStream: MediaStream | null;
+    remoteStream: MediaStream | null;
+    micEnabled: boolean;
+    camEnabled: boolean;
+    remoteVideoLive: boolean;
+    /** Dismissible, non-fatal hint (e.g. the camera could not be re-enabled). */
+    notice: string | null;
+}
+export interface P2PCallParams {
+    callId: string;
+    role: P2PRole;
+    kind: 'audio' | 'video';
+    /** Peer's xmpp localpart; signals from anyone else are ignored. */
+    peerLocal: string;
+    iceServers: IceServerConfig[];
+    startWithMicOn?: boolean;
+    startWithCameraOn?: boolean;
+}
+export interface P2PCallDeps {
+    createPeerConnection: (config: RTCConfiguration) => RTCPeerConnection;
+    getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+    createMediaStream: () => MediaStream;
+    /** Fresh credentials; null/empty keeps the servers already in use. */
+    fetchIceServers: () => Promise<IceServerConfig[] | null>;
+    sendSignal: (signal: P2PSignalName, payload: P2PSignalPayload) => void;
+    log?: (message: string, detail?: unknown) => void;
+}
+export interface P2PCallEvents {
+    /** The offer/answer exchange completed: media is now negotiating. */
+    onNegotiated?: () => void;
+    /** Media is flowing for the first time. */
+    onConnected?: () => void;
+    /** The peer ended the call (hang up, decline, their own failure). */
+    onRemoteEnd?: (reason: string) => void;
+    /** The call failed locally; the message is meant for the user. */
+    onFailed?: (message: string) => void;
+    /**
+     * Called exactly once when the call's resources are released. `started` is
+     * false for a callee that never accepted (nothing was negotiated).
+     */
+    onDisposed?: (info: {
+        started: boolean;
+    }) => void;
+}
+export interface P2PTimings {
+    connectTimeoutMs: number;
+    offerResendMs: number[];
+}
+export declare const describeMediaError: (error: unknown) => string;
+/**
+ * What to show when the PEER ended the call for a reason that is a failure
+ * rather than a normal hang up / decline. Null means "just close the call".
+ */
+export declare const remoteEndNotice: (reason: string) => string | null;
+export declare class P2PCallController {
+    readonly callId: string;
+    readonly role: P2PRole;
+    readonly kind: 'audio' | 'video';
+    private readonly params;
+    private readonly deps;
+    private readonly events;
+    private readonly timings;
+    private readonly negotiator;
+    private readonly policy;
+    private snapshot;
+    private readonly listeners;
+    private pc;
+    private localStream;
+    private audioTrack;
+    private videoTrack;
+    private videoSender;
+    private ownedTracks;
+    private remoteStream;
+    private remoteCleanups;
+    private queue;
+    private timers;
+    private graceTimer;
+    private deadlineTimer;
+    private connectTimer;
+    private started;
+    private disposed;
+    private endSent;
+    private connectedOnce;
+    private negotiated;
+    private cameraBusy;
+    private lastConn;
+    private candidateGateOpen;
+    private heldOutgoingCandidates;
+    private sentCandidates;
+    private lastOffer;
+    constructor(params: P2PCallParams, deps: P2PCallDeps, events?: P2PCallEvents, timings?: Partial<P2PTimings>);
+    subscribe: (listener: () => void) => (() => void);
+    getSnapshot: () => P2PSnapshot;
+    private update;
+    private log;
+    private later;
+    private cancel;
+    /**
+     * Caller: get media, build the connection, offer. Callee: get media, build
+     * the connection, then apply the offer that may already be waiting. Safe to
+     * call once; every failure ends the call with a message instead of throwing.
+     */
+    start(): Promise<void>;
+    /** Feed a signal from the peer (already routed by callId). */
+    receive(signal: P2PSignal): void;
+    /** Local user hung up (or cancelled): tell the peer and release everything. */
+    hangup(reason?: string): void;
+    /**
+     * Release every resource: timers, listeners, media tracks, the connection.
+     * Idempotent, safe from any exit path. Tells the peer unless it is already
+     * known to be over.
+     */
+    dispose(): void;
+    private sendEnd;
+    private fail;
+    private handleRemoteEnd;
+    private acquireMedia;
+    private releaseMedia;
+    toggleMic(): void;
+    /**
+     * Turning the camera off stops sending video and releases the device (the
+     * camera light goes out); turning it on opens the camera again and swaps it
+     * into the existing sender, so no renegotiation is needed.
+     */
+    toggleCamera(): Promise<void>;
+    dismissNotice(): void;
+    private createConnection;
+    private emitCandidate;
+    private openCandidateGate;
+    private onRemoteTrack;
+    private remoteVideoLive;
+    private enqueue;
+    private sendOffer;
+    private scheduleOfferResends;
+    private runCommands;
+    private applyOffer;
+    private onNegotiated;
+    private connState;
+    private onConnectionState;
+    private runIceAction;
+    /** ICE restart with fresh TURN credentials; the caller of this is the policy. */
+    private restartIce;
+}
+//# sourceMappingURL=P2PCallController.d.ts.map