@hipnation-truth/sdk 0.15.3 → 0.16.0

package/dist/react.d.ts

@@ -1,6 +1,8 @@
 import * as react from 'react';
 import { ReactNode } from 'react';
 import { ConvexReactClient } from 'convex/react';
+import * as convex_browser from 'convex/browser';
+import { ConvexHttpClient } from 'convex/browser';
 
 /**
  * React hooks for Truth SDK — reactive conversation + message data.
@@ -437,7 +439,7 @@ declare function useAppointment(id: string): any;
  * Subscribe to an appointment by its Elation ID.
  */
 declare function useAppointmentByElationId(elationId: string): any;
-interface Physician {
+interface Physician$1 {
     _id: string;
     elationId: number;
     firstName?: string;
@@ -666,6 +668,272 @@ interface UseNotificationsResult {
 }
 declare function useNotifications(options: UseNotificationsOptions): UseNotificationsResult;
 
+/**
+ * React hook for patient family-member lookup — Truth SDK.
+ *
+ * Replaces the CommHub Hasura `useFamilyMembersQuery` (backed by
+ * `queries/family_members.graphql`). Queries the Convex
+ * `patients:listFamilyMembers` function, which returns the set of
+ * patients that share a `familyId` OR share at least one phone number
+ * with the reference patient, excluding the reference patient themselves.
+ *
+ * Arguments mirror the Hasura `FamilyMembers` GraphQL query variables:
+ *  - `familyId`      → `$familyId`    (Hint family/account id)
+ *  - `phoneNumbers`  → `$phoneNumbers` (patient's phone numbers)
+ *  - `excludeHintId` → `$excludePatientId` (skip the reference patient)
+ *
+ * Must be used within a `<TruthProvider />`.
+ *
+ * @example
+ * ```tsx
+ * import { usePatientFamilyMembers } from '@hipnation-truth/sdk/react/patient-family';
+ *
+ * function FamilyPanel({ hintId, familyId, phones }: Props) {
+ *   const { data: members, loading } = usePatientFamilyMembers({
+ *     familyId,
+ *     phoneNumbers: phones,
+ *     excludeHintId: hintId,
+ *   });
+ *   if (loading) return <Spinner />;
+ *   return members?.map((m) => <div key={m._id}>{m.firstName} {m.lastName}</div>);
+ * }
+ * ```
+ */
+
+/**
+ * Shape of a single patient row returned by `patients:listFamilyMembers`.
+ * Mirrors the fields CommHub's `FamilyMembersQuery` selected from Hasura:
+ *  - `id`            → `_id`       (Convex document id)
+ *  - `name`          → `firstName + " " + lastName`
+ *  - `hint_id`       → `hintId`
+ *  - `elation_id`    → `elationId`
+ *  - `family_id`     → `familyId`
+ *  - `phone_numbers` → `phones[].number`
+ */
+interface FamilyMemberRow {
+    _id: string;
+    _creationTime: number;
+    firstName: string;
+    lastName: string;
+    elationId?: string;
+    hintId?: string;
+    familyId?: string;
+    phones: Array<{
+        type?: string;
+        number: string;
+    }>;
+    membershipStatus?: string;
+    sources: string[];
+    lastSyncedAt: string;
+}
+/** Arguments for `usePatientFamilyMembers`. */
+interface UsePatientFamilyMembersInput {
+    /**
+     * Hint family/account id — when present, all patients sharing this id
+     * are returned (matches the Hasura `family_id` column).
+     *
+     * BACKFILL NEEDED: `familyId` was added to the Convex `patients` schema
+     * in this PR. Existing patient rows will return empty for this branch
+     * until the Hint patient upsert path (upsertFromHint / basic-refresh)
+     * is updated to write this field, or a one-time backfill script runs.
+     * The phone-number fallback continues to work in the interim.
+     */
+    familyId?: string | null;
+    /**
+     * Patient's phone numbers — patients sharing at least one phone number
+     * are included as family members (mirrors Hasura `phone_numbers._overlap`).
+     */
+    phoneNumbers?: string[] | null;
+    /**
+     * Hint patient ID of the reference patient to exclude from results
+     * (mirrors Hasura `$excludePatientId`).
+     */
+    excludeHintId?: string | null;
+}
+/**
+ * Subscribe to family members of a patient in real time.
+ *
+ * Returns all patients that share the same `familyId` OR share at least one
+ * phone number with the reference patient, sorted by name. The reference
+ * patient is excluded via `excludeHintId`.
+ *
+ * Pass `undefined` (or an object where all fields are undefined/null) to
+ * skip the query — returns `{ data: undefined, loading: false }`.
+ *
+ * @param input - Query inputs. The query is skipped if `input` is undefined
+ *   or all fields are falsy.
+ */
+declare function usePatientFamilyMembers(input: UsePatientFamilyMembersInput | undefined): UseQueryResult<FamilyMemberRow[]>;
+
+/**
+ * React hook for Truth SDK — reactive patient search.
+ *
+ * Wraps the `patients:search` Convex query so CommHub consumers
+ * (and other frontends) can search patients by name, phone, or email
+ * with live-updating results and optional office scoping, without
+ * managing Convex subscriptions themselves.
+ *
+ * **Hook contract:** returns `UseQueryResult<PatientSearchResult[]>`.
+ * - `data` is `undefined` while loading or when the query is skipped
+ *   (empty `query` string or `query === undefined`).
+ * - `loading` is `true` only while a real subscription is in-flight.
+ * - `error` is reserved for SDK-side validation; Convex query errors
+ *   propagate as React errors and should be caught with an error
+ *   boundary.
+ *
+ * **Backed by `patients:search`** — added in agent-A-search.
+ * Multi-word queries split on whitespace; every token must match at
+ * least one of firstName / lastName / email / phone digits.
+ *
+ * Must be used within `<TruthProvider />` (see `./provider`).
+ *
+ * @example
+ * ```tsx
+ * import { usePatientSearch } from '@hipnation-truth/sdk/react/patient-search';
+ *
+ * function PatientPicker({ officeId }: { officeId?: string }) {
+ *   const [query, setQuery] = useState('');
+ *   const { data: patients, loading } = usePatientSearch({ query, officeId });
+ *   return (
+ *     <>
+ *       <input value={query} onChange={e => setQuery(e.target.value)} />
+ *       {loading && <Spinner />}
+ *       {patients?.map(p => <PatientRow key={p.id} patient={p} />)}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+
+/**
+ * A single patient result from `patients:search`.
+ *
+ * Fields are normalised across the `patients` + `hintPatients` tables
+ * so callers get a flat, consistent object regardless of which source
+ * contributed the match.
+ */
+interface PatientSearchResult {
+    /** Convex `_id` of the matching `patients` or `hintPatients` row. */
+    id: string;
+    /** Hint patient id — present when the row originates from Hint. */
+    hintId: string | undefined;
+    firstName: string;
+    lastName: string;
+    /** ISO date string (YYYY-MM-DD) — undefined when not available. */
+    dob: string | undefined;
+    /** Email addresses associated with the patient. */
+    emails: string[];
+    /**
+     * Raw phone strings from the source table.  Callers should
+     * strip non-digits for dialling; the first entry is the primary
+     * contact number.
+     */
+    phones: string[];
+    /** Hint office id — present for Hint-sourced results. */
+    officeId: string | undefined;
+    /** Human-readable office name — present when officeId is set. */
+    officeName: string | undefined;
+}
+interface UsePatientSearchOptions {
+    /**
+     * The search term entered by the user.  Multi-word queries are split
+     * on whitespace and every token must match.  Pass `""` or `undefined`
+     * to skip the query and get `{ data: undefined, loading: false }`.
+     */
+    query: string | undefined;
+    /**
+     * When supplied, restricts results to patients whose authoritative
+     * Hint office id matches.  Maps to the `officeId` arg on the Convex
+     * query and uses the `hintPatients.by_officeId` index path.
+     */
+    officeId?: string | null;
+    /**
+     * `"fuzzy"` (default) uses Convex full-text search indexes for name
+     * queries; `"exact"` uses a bounded scan-filter only.  Most callers
+     * should leave this at the default.
+     */
+    mode?: "fuzzy" | "exact";
+    /** Maximum number of results to return (server caps at 200). */
+    limit?: number;
+}
+/**
+ * Subscribe to a live patient search backed by `patients:search` on the
+ * Truth Convex deployment.
+ *
+ * Results update reactively whenever the underlying `patients` or
+ * `hintPatients` tables change — no polling required.
+ *
+ * @param options - Search options (see `UsePatientSearchOptions`).
+ * @returns `UseQueryResult<PatientSearchResult[]>` — always defined
+ *   once a non-empty `query` is provided and the subscription resolves.
+ */
+declare function usePatientSearch(options: UsePatientSearchOptions): UseQueryResult<PatientSearchResult[]>;
+
+/**
+ * Patient interfaces for the Truth SDK.
+ */
+/**
+ * Normalized patient record from the Truth platform.
+ */
+interface Patient {
+    /** Truth platform patient ID */
+    id: string;
+    /** Elation EHR patient ID (if linked) */
+    elationId?: string;
+    /** Hint EHR patient ID (if linked) */
+    hintId?: string;
+    /** Patient first name */
+    firstName: string;
+    /** Patient last name */
+    lastName: string;
+    /** Date of birth (ISO 8601 date string, e.g. "1990-01-15") */
+    dateOfBirth?: string;
+    /** Patient sex */
+    sex?: string;
+    /** Primary email address */
+    email?: string;
+    /** Primary phone number */
+    phone?: string;
+    /** Patient status in the system */
+    status: string;
+    /** Associated organization/tenant ID */
+    tenantId: string;
+    /** ISO 8601 timestamp of record creation */
+    createdAt: string;
+    /** ISO 8601 timestamp of last update */
+    updatedAt: string;
+}
+/**
+ * Options for listing patients.
+ */
+interface PatientListOptions {
+    /** Search patients by name, email, or phone */
+    search?: string;
+    /** Maximum number of results to return */
+    limit?: number;
+    /** Cursor for pagination */
+    cursor?: string;
+}
+
+/**
+ * Bulk patient lookup by Convex ids.
+ *
+ * Backs the inbox card render in CommHub — one reactive subscription
+ * resolves names + office + EHR ids for the entire visible list
+ * instead of N per-row queries.
+ *
+ * Must be used within `<TruthProvider />`.
+ */
+
+/**
+ * Subscribe to a list of patients by their Convex ids. Returns a
+ * `Record<patientId, Patient>` for O(1) lookup at render time.
+ *
+ * Pass an empty array (or `undefined`) to skip the query. Missing ids
+ * are absent from the map (silently dropped server-side).
+ */
+declare function usePatientsByIds(ids: string[] | null | undefined): UseQueryResult<Record<string, Patient>>;
+
 interface TruthProviderProps {
     /** Truth environment — determines which Convex deployment to connect to */
     environment?: string;
@@ -693,6 +961,16 @@ interface Reminder {
     triggeredAt?: string;
     cancelledAt?: string;
 }
+interface ScheduleReminderInput {
+    conversationId: string;
+    remindAt: string | Date;
+    note?: string;
+    createdBy: string;
+}
+interface ScheduleReminderResult {
+    reminderId: string;
+    remindAt: string;
+}
 
 /**
  * React hooks for conversation reminders — bulk lookup keyed by
@@ -1004,6 +1282,52 @@ interface TrackOptions {
     occurredAt?: string;
 }
 
+/**
+ * Configuration interfaces for the Truth SDK.
+ */
+/**
+ * Environment options for the Truth platform.
+ */
+declare const ENVIRONMENTS: {
+    readonly local: "local";
+    readonly staging: "staging";
+    readonly stg: "stg";
+    readonly sandbox: "sandbox";
+    readonly uat: "uat";
+    readonly production: "production";
+};
+type Environment = (typeof ENVIRONMENTS)[keyof typeof ENVIRONMENTS];
+/**
+ * Configuration for initializing a TruthClient.
+ */
+interface TruthClientConfig {
+    /** API key for authenticating with the Truth platform (e.g. "hn_live_...") */
+    apiKey: string;
+    /** Target environment */
+    environment: Environment;
+    /** Override the default Convex URL for data access */
+    convexUrl?: string;
+    /** Event source identifier (e.g. "communication-hub.backend") */
+    source?: string;
+    /** Git SHA or version string for event source versioning */
+    sourceVersion?: string;
+    /** Default tenant (organization) ID for events */
+    tenantId?: string;
+    /** Number of events to buffer before flushing (default: 25) */
+    batchSize?: number;
+    /** Interval in milliseconds between automatic flushes (default: 5000) */
+    flushIntervalMs?: number;
+    /** Base URL for the Truth API (overrides environment-based default) */
+    apiBaseUrl?: string;
+    /**
+     * Auto-register the service worker and subscribe to web push on init.
+     * Only applies in browser environments with Push API support.
+     * Default: true.
+     */
+    autoInitServiceWorker?: boolean;
+    /** Path to the service worker file. Default: "/truth-sw.js" */
+    serviceWorkerPath?: string;
+}
 /**
  * Actor context attached to tracked events.
  */
@@ -1011,6 +1335,14 @@ interface ActorContext {
     actorId: string;
     actorType: "user" | "system" | "webhook";
 }
+/**
+ * Paginated result wrapper for list operations.
+ */
+interface PaginatedResult<T> {
+    data: T[];
+    cursor: string | null;
+    hasMore: boolean;
+}
 
 interface TruthTrackingContextValue {
     track: <T extends EventType>(eventType: T, payload: EventPayloadMap[T], options?: TrackOptions) => void;
@@ -1036,6 +1368,66 @@ declare function TruthTrackingProvider({ environment, source, sourceVersion, ten
  */
 declare function useTruth(): TruthTrackingContextValue;
 
+/**
+ * UserSettingsResource — typed client for the Truth `userSettings` Convex
+ * table. Exposes the one mutation CommHub's Settings screen needs:
+ * `updateNotifications({ userId, notificationsEnabled })`.
+ *
+ * Server-side / imperative use:
+ *   truth.userSettings.updateNotifications({ userId, notificationsEnabled: true })
+ *
+ * Reactive React use lives in `@hipnation-truth/sdk/react` via
+ * `useUserSettings`.
+ */
+
+interface UserSettings {
+    _id: string;
+    userId: string;
+    notificationsEnabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+}
+interface UpdateNotificationsInput {
+    userId: string;
+    notificationsEnabled: boolean;
+}
+interface UpdateNotificationsResult {
+    action: "inserted" | "updated";
+    id: string;
+}
+declare class UserSettingsResource {
+    private readonly convex;
+    constructor(convex: ConvexHttpClient);
+    /**
+     * Upsert notification preferences for a user. Creates the row if it
+     * doesn't exist; patches `notificationsEnabled` + `updatedAt` otherwise.
+     */
+    updateNotifications(input: UpdateNotificationsInput): Promise<UpdateNotificationsResult>;
+}
+
+/**
+ * useUserSettings — reactive hook for per-user notification preferences
+ * stored in the Truth `userSettings` Convex table.
+ *
+ * Must be used within `<TruthProvider />` (see `./provider`).
+ *
+ * @example
+ * ```tsx
+ * const { data: settings, loading } = useUserSettings(userId);
+ * // settings?.notificationsEnabled — boolean or undefined (no row yet)
+ * ```
+ */
+
+/**
+ * Subscribe to the `userSettings` row for `userId`. Returns `null` when
+ * no row exists (treat as all-defaults). Returns `undefined` while the
+ * Convex query is in-flight.
+ *
+ * Pass `null` or `undefined` as `userId` to skip the query (e.g. while
+ * auth is loading).
+ */
+declare function useUserSettings(userId: string | null | undefined): UseQueryResult<UserSettings | null>;
+
 /**
  * Appointment interfaces for the Truth SDK.
  */
@@ -1093,49 +1485,1056 @@ interface AppointmentListOptions {
 }
 
 /**
- * Patient interfaces for the Truth SDK.
+ * AppointmentResource provides data access to normalized appointment records
+ * backed by Convex.
  */
+
+declare class AppointmentResource {
+    private readonly convex;
+    constructor(convexClient: ConvexHttpClient);
+    /**
+     * Get an appointment by its Truth platform ID.
+     */
+    get(id: string): Promise<Appointment | null>;
+    /**
+     * List appointments with optional filters, pagination, and limit.
+     */
+    list(options?: AppointmentListOptions): Promise<PaginatedResult<Appointment>>;
+}
+
 /**
- * Normalized patient record from the Truth platform.
+ * AttachmentsResource — presigned S3 upload/download + Convex metadata.
+ *
+ * Replaces CommHub's base64-in-Postgres attachment flow:
+ *   1. client.attachments.createUploadUrl(...) → presigned PUT URL
+ *   2. Client PUTs bytes directly to S3
+ *   3. client.attachments.record(...) → writes Convex metadata
+ *   4. client.attachments.getDownloadUrl(s3Key) → presigned GET URL
  */
-interface Patient {
-    /** Truth platform patient ID */
+
+interface CreateUploadUrlInput {
+    fileName: string;
+    mimeType: string;
+    size: number;
+    conversationId?: string;
+}
+interface CreateUploadUrlResult {
+    uploadUrl: string;
+    s3Key: string;
+    expiresIn: number;
+    applicationId: string | null;
+}
+interface GetDownloadUrlResult {
+    url: string;
+    expiresIn: number;
+}
+interface RecordAttachmentInput {
+    s3Key: string;
+    fileName: string;
+    mimeType: string;
+    size: number;
+    conversationId?: string;
+    uploadedBy: string;
+}
+interface Attachment {
+    _id: string;
+    s3Key: string;
+    fileName: string;
+    mimeType: string;
+    size: number;
+    conversationId?: string;
+    uploadedBy: string;
+    createdAt: string;
+}
+declare class AttachmentsResource {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly convex;
+    constructor(apiBaseUrl: string, apiKey: string, convexClient: ConvexHttpClient);
+    private post;
+    createUploadUrl(input: CreateUploadUrlInput): Promise<CreateUploadUrlResult>;
+    getDownloadUrl(s3Key: string, expiresIn?: number): Promise<GetDownloadUrlResult>;
+    record(input: RecordAttachmentInput): Promise<{
+        attachmentId: string;
+        s3Key: string;
+    }>;
+    get(attachmentId: string): Promise<Attachment | null>;
+    listByConversation(conversationId: string): Promise<Attachment[]>;
+    /**
+     * One-shot upload: presign → PUT to S3 → record in Convex → return a
+     * 7-day signed download URL ready to embed in an outbound SMS. Caller
+     * passes the resulting `downloadUrl` to `messages.dialpad.sendSms` (or
+     * the new `messages.sendAttachmentMessage`) to actually deliver it.
+     *
+     * Replaces CommHub's NestJS `/send-attachment` controller in a single
+     * SDK call — no base64 round-trip, no legacy `/attachments/:id/download`
+     * REST endpoint required.
+     */
+    upload(input: {
+        file: Blob | ArrayBuffer | Uint8Array;
+        fileName: string;
+        mimeType: string;
+        size: number;
+        conversationId?: string;
+        uploadedBy: string;
+        /** Download URL TTL in seconds. Default 7 days. */
+        downloadExpiresIn?: number;
+    }): Promise<{
+        attachmentId: string;
+        s3Key: string;
+        downloadUrl: string;
+    }>;
+}
+
+/**
+ * ConversationsResource — write methods that hang off a specific
+ * conversation: notes, tasks, outbound messages.
+ *
+ * Replaces CommHub's `truthConversationApi.ts` raw-fetch wrappers so
+ * the frontend goes through a typed SDK surface instead of building
+ * URLs by hand.
+ *
+ * All methods proxy the matching oRPC procedures (`/conversations/*`)
+ * via Truth's application-key auth. Errors surface as
+ * `ConversationsError` with a status code so callers can distinguish
+ * transport failures (status=0) from API rejections (status>=400).
+ */
+/** Address a conversation by either Convex `_id` or the phonePair. */
+interface ConversationAddress {
+    conversationId?: string;
+    phonePair?: string;
+}
+type ConversationTaskStatus = "pending" | "completed";
+type ConversationTaskPriority = "high" | "medium" | "low";
+interface CreateConversationNoteInput extends ConversationAddress {
+    eventId?: string;
+    author: string;
+    content: string;
+    status?: string;
+    type?: string;
+}
+interface CreateConversationTaskInput extends ConversationAddress {
+    eventId?: string;
+    author: string;
+    description: string;
+    status?: ConversationTaskStatus;
+    priority?: ConversationTaskPriority;
+    assignee?: string;
+    type?: string;
+}
+interface SetConversationTaskStatusInput {
+    taskId: string;
+    status: ConversationTaskStatus;
+    resolvedBy?: string;
+}
+interface SendConversationMessageInput {
+    fromNumber: string;
+    toNumber: string;
+    message?: string;
+    media?: string;
+}
+interface SendConversationMessageResult {
+    id: number;
+    messageStatus: string;
+    direction: string;
+}
+declare class ConversationNotesSubresource {
+    private readonly post;
+    constructor(post: <T>(path: string, body: unknown) => Promise<T>);
+    /** Create a note on a conversation (addressed by id or phonePair). */
+    create(input: CreateConversationNoteInput): Promise<{
+        id: string;
+    }>;
+}
+declare class ConversationTasksSubresource {
+    private readonly post;
+    constructor(post: <T>(path: string, body: unknown) => Promise<T>);
+    /** Create a task on a conversation. */
+    create(input: CreateConversationTaskInput): Promise<{
+        id: string;
+    }>;
+    /** Mark a task pending or completed. */
+    setStatus(input: SetConversationTaskStatusInput): Promise<{
+        ok: true;
+    }>;
+}
+declare class ConversationMessagesSubresource {
+    private readonly post;
+    constructor(post: <T>(path: string, body: unknown) => Promise<T>);
+    /**
+     * Send an outbound SMS / MMS via the typed `sendMessage` oRPC procedure.
+     *
+     * Prefer this over the generic Dialpad proxy (`messages.dialpad.sendSms`)
+     * — this hits the validated Truth route and consistently surfaces
+     * `ConversationsError` on failure.
+     */
+    send(input: SendConversationMessageInput): Promise<SendConversationMessageResult>;
+}
+declare class ConversationsResource {
+    readonly notes: ConversationNotesSubresource;
+    readonly tasks: ConversationTasksSubresource;
+    readonly messages: ConversationMessagesSubresource;
+    /** 30s upstream timeout — matches NotesResource for consistency. */
+    private static readonly REQUEST_TIMEOUT_MS;
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly convex;
+    constructor(apiBaseUrl: string, apiKey: string, convex?: convex_browser.ConvexHttpClient);
+    /**
+     * Mark a conversation read for the calling user (zeroes unreadCount,
+     * stamps `lastReadAt`). Calls the public Convex `markRead` mutation
+     * which enforces self-tenancy on the auth identity.
+     */
+    markRead(input: {
+        conversationId: string;
+        userId: string;
+    }): Promise<{
+        ok: true;
+    }>;
+    /**
+     * Mark a conversation unread for the calling user (sets unreadCount=1).
+     */
+    markUnread(input: {
+        conversationId: string;
+        userId: string;
+    }): Promise<{
+        updated: true;
+    }>;
+    /**
+     * Zero unread on every conversation the user has reads for, except
+     * those whose `providerPhone` is in `excludedProviderPhones`.
+     */
+    clearAllUnread(input: {
+        userId: string;
+        excludedProviderPhones?: string[];
+    }): Promise<{
+        cleared: number;
+    }>;
+    private postRequest;
+}
+
+/**
+ * Dialpad resource — typed access to Truth's Dialpad proxy endpoints.
+ *
+ * @example
+ * ```ts
+ * const sms = await truth.messages.dialpad.sendSms({ from_number, to_number, message });
+ * const call = await truth.messages.dialpad.initiateCall(userId, phoneNumber);
+ * await truth.messages.dialpad.hangupCall(callId);
+ * const url = await truth.messages.dialpad.authenticateVoicemail(voicemailLink);
+ * ```
+ */
+interface SendSmsParams {
+    from_number: string;
+    to_number: string;
+    message?: string;
+    media?: string | string[];
+}
+interface SendSmsResponse {
     id: string;
-    /** Elation EHR patient ID (if linked) */
-    elationId?: string;
-    /** Hint EHR patient ID (if linked) */
+    message_status: string;
+    [key: string]: unknown;
+}
+interface InitiateCallResponse {
+    call_id: number;
+    [key: string]: unknown;
+}
+interface CallStatusResponse {
+    state: string;
+    [key: string]: unknown;
+}
+interface DialpadUser {
+    id: number;
+    emails: string[];
+    first_name?: string;
+    last_name?: string;
+    [key: string]: unknown;
+}
+interface DialpadNumberInfo {
+    user_id?: number;
+    type?: string;
+    [key: string]: unknown;
+}
+declare class DialpadResource {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiBaseUrl: string, apiKey: string);
+    /**
+     * Send an SMS or MMS message via Dialpad.
+     */
+    sendSms(params: SendSmsParams): Promise<SendSmsResponse>;
+    /**
+     * Initiate an outbound call from a Dialpad user to a phone number.
+     */
+    initiateCall(userId: number, phoneNumber: string): Promise<InitiateCallResponse>;
+    /**
+     * Hang up an active call.
+     */
+    hangupCall(callId: number): Promise<void>;
+    /**
+     * Alias for `hangupCall` — mirrors the CommHub `endCall` action name so
+     * the SDK swap is a direct rename.
+     */
+    endCall(callId: number): Promise<void>;
+    /**
+     * Send an MMS with a pre-uploaded attachment. Takes the S3 key returned
+     * by `client.attachments.createUploadUrl(...)` + PUT, fetches a short-
+     * lived download URL, and hands it to Dialpad as `media[]`.
+     *
+     * Replaces CommHub's `sendAttachment` Hasura Action (which stored bytes
+     * as base64 in Postgres and served them through a GET endpoint).
+     */
+    sendAttachmentWithUrl(params: {
+        from_number: string;
+        to_number: string;
+        mediaUrl: string;
+        message?: string;
+    }): Promise<SendSmsResponse>;
+    /**
+     * Get the status of a call.
+     */
+    getCallStatus(callId: number): Promise<CallStatusResponse | null>;
+    /**
+     * Get a Dialpad user by their user ID.
+     */
+    getUser(userId: string | number): Promise<DialpadUser | null>;
+    /**
+     * Find a Dialpad user by email.
+     */
+    getUserByEmail(email: string): Promise<DialpadUser | null>;
+    /**
+     * Find a Dialpad user by phone number.
+     */
+    getUserByPhoneNumber(phoneNumber: string): Promise<DialpadUser | null>;
+    /**
+     * Get information about a Dialpad phone number.
+     */
+    getNumberInfo(phoneNumber: string): Promise<DialpadNumberInfo | null>;
+    /**
+     * Authenticate a voicemail download URL. Truth appends the Dialpad API key,
+     * follows redirects, and returns the clean URL for client-side playback.
+     */
+    authenticateVoicemail(voicemailLink: string): Promise<string | null>;
+    private get;
+    private post;
+    private put;
+}
+declare class MessagesResource {
+    readonly dialpad: DialpadResource;
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiBaseUrl: string, apiKey: string);
+    /**
+     * Get an authenticated URL for a Dialpad voicemail recording.
+     *
+     * Replaces CommHub's `getAuthenticatedVoicemailUrl` Hasura mutation
+     * (which proxied to the legacy NestJS backend). Truth appends the
+     * Dialpad API key, follows redirects, strips the key from the final
+     * URL, and returns it for client-side audio playback.
+     *
+     * @param voicemailLink  The raw Dialpad voicemail download URL (value
+     *   of the `voicemail_link` field on the call event row).
+     * @returns An object with `url` (clean playback URL) and `expiresAt`
+     *   (ISO-8601 timestamp, ~5 min from request time, informational only).
+     */
+    getVoicemailUrl(voicemailLink: string): Promise<{
+        url: string;
+        expiresAt: string;
+    }>;
+    /**
+     * End a Dialpad call via the typed oRPC procedure (POST hangup, with
+     * 404→`alreadyEnded` so the UI doesn't flash an error on a natural
+     * race). Replaces CommHub's `useEndCallMutation` Hasura action.
+     *
+     * Prefer this over `messages.dialpad.endCall` which goes through the
+     * generic proxy (PUT, no 404 handling).
+     */
+    endCall(callId: number | string): Promise<{
+        ok: true;
+        alreadyEnded: boolean;
+    }>;
+}
+
+/**
+ * EHR proxy resource — typed access to Truth's EHR proxy endpoints.
+ *
+ * Provides per-provider proxy methods so consumers never construct
+ * proxy URLs manually.
+ *
+ * @example
+ * ```ts
+ * const patient = await truth.ehr.elation.get('/patients/123/');
+ * const notes = await truth.ehr.elation.post('/non_visit_notes/', noteData);
+ * const hintPatient = await truth.ehr.hint.get('/provider/patients/456');
+ * ```
+ */
+declare class EhrProviderProxy {
+    private readonly baseUrl;
+    private readonly provider;
+    constructor(apiBaseUrl: string, provider: string);
+    /**
+     * GET request to the EHR proxy.
+     * @param path — path relative to the provider root (e.g., "/patients/123/")
+     * @param params — optional query parameters
+     */
+    get<T = unknown>(path: string, params?: Record<string, unknown>): Promise<T>;
+    /**
+     * POST request to the EHR proxy.
+     */
+    post<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /**
+     * PUT request to the EHR proxy.
+     */
+    put<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /**
+     * PATCH request to the EHR proxy.
+     */
+    patch<T = unknown>(path: string, body?: unknown): Promise<T>;
+    /**
+     * DELETE request to the EHR proxy.
+     */
+    delete<T = unknown>(path: string): Promise<T>;
+}
+declare class EhrResource {
+    /** Elation EHR proxy */
+    readonly elation: EhrProviderProxy;
+    /** Hint Health proxy */
+    readonly hint: EhrProviderProxy;
+    constructor(apiBaseUrl: string);
+}
+
+/**
+ * NotesResource — push formatted notes to Elation.
+ *
+ * Caller assembles the note body (text + bullets). Truth owns the Elation
+ * OAuth token and the HTTP call so applications can drop Elation
+ * credentials from their own config.
+ */
+interface NonVisitNoteBullet {
+    text: string;
+    category?: string;
+}
+interface PushNoteToElationInput {
+    patient: number;
+    physician: number;
+    practice: number;
+    note: {
+        text: string;
+        type?: string;
+    };
+    document_date?: string;
+    chart_date?: string;
+    bullets?: NonVisitNoteBullet[];
+}
+interface PushNoteToElationResult {
+    success: boolean;
+    elationNoteId: number | null;
+}
+interface PushConversationToElationInput {
+    /** One-of: conversationId (Convex) or phonePair. */
+    conversationId?: string;
+    phonePair?: string;
+    /** Actor user id — recorded on the audit row. */
+    initiatedBy: string;
+    /** Pre-assembled note body (transcript-style text). */
+    noteText: string;
+    bullets?: NonVisitNoteBullet[];
+    notesPushed?: number;
+    messagesPushed?: number;
+    tasksPushed?: number;
+}
+interface PushConversationToElationResult {
+    success: true;
+    batchId: string;
+    elationNoteId: number | null;
+    notesPushed: number;
+    messagesPushed: number;
+    tasksPushed: number;
+}
+declare class NotesResource {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiBaseUrl: string, apiKey: string);
+    /** 30s upstream timeout — Elation API has occasional slow hops; we
+     *  don't want a pending mutation to hold the UI thread indefinitely. */
+    private static readonly REQUEST_TIMEOUT_MS;
+    private post;
+    /**
+     * Low-level — caller has already resolved Elation patient / physician
+     * / practice. Use `pushConversationToElation` if you only have a
+     * conversation handle.
+     */
+    pushToElation(input: PushNoteToElationInput): Promise<PushNoteToElationResult>;
+    /**
+     * Orchestrator — pass a conversation handle + pre-assembled note text.
+     * Truth resolves the linked patient via Convex, looks up
+     * physician/practice in Elation, posts the note, and writes an audit
+     * row to `elationSyncEvents`. Replaces CommHub's `pushNotesToElation`
+     * Hasura action.
+     */
+    pushConversationToElation(input: PushConversationToElationInput): Promise<PushConversationToElationResult>;
+}
+
+/**
+ * NotificationsResource — wraps Truth's /api/notifications/* endpoints.
+ *
+ * Server-side use (for example from a CommHub backend job or
+ * another service): `truth.notifications.send({ userId, title, body })`.
+ *
+ * Client-side React usage lives in `@hipnation-truth/sdk/react` via
+ * the `useNotifications` hook which mirrors `expo-notifications`.
+ */
+type NotificationPlatform = "ios" | "android" | "web";
+interface RegisterDeviceInput {
+    userId: string;
+    platform: NotificationPlatform;
+    nativeToken?: string;
+    webPushSubscription?: {
+        endpoint: string;
+        keys: {
+            p256dh: string;
+            auth: string;
+        };
+    };
+    appVersion?: string;
+    osVersion?: string;
+    locale?: string;
+    timezone?: string;
+    /**
+     * iOS only — which APNs endpoint the `nativeToken` was issued
+     * against. The token bytes don't carry this; it's determined by
+     * the build's `aps-environment` entitlement
+     * (`development` ⇒ sandbox, `production` ⇒ production). When the
+     * consumer is an Expo app, detect via
+     * `Application.getIosPushNotificationServiceEnvironmentAsync()`
+     * from `expo-application` and pass the normalised value here.
+     * Omitting this falls back to the application's default
+     * `pushConfig.ios.environment` server-side.
+     */
+    apnsEnvironment?: "sandbox" | "production";
+}
+interface RegisterDeviceResult {
+    deviceId: string;
+    action: "inserted" | "updated";
+    snsEndpointArn?: string;
+}
+interface UnregisterDeviceInput {
+    nativeToken?: string;
+    deviceId?: string;
+}
+interface SendNotificationInput {
+    userId: string;
+    title: string;
+    body: string;
+    data?: Record<string, unknown>;
+    badge?: number;
+    sound?: string;
+}
+interface SendNotificationResult {
+    delivered: number;
+    failed?: number;
+    suppressed?: boolean;
+    suppressionReason?: string;
+}
+interface NotificationPreferences {
+    channels: {
+        sms: boolean;
+        push: boolean;
+        email: boolean;
+        inApp: boolean;
+    };
+    quietHours?: {
+        enabled: boolean;
+        start: string;
+        end: string;
+        timezone: string;
+    };
+    doNotDisturbUntil?: string;
+    updatedAt: string;
+}
+interface UpdatePreferencesInput {
+    userId: string;
+    channels?: NotificationPreferences["channels"];
+    quietHours?: NotificationPreferences["quietHours"];
+    doNotDisturbUntil?: string | null;
+}
+interface ScheduleNotificationInput extends SendNotificationInput {
+    /** ISO 8601 timestamp; must be strictly in the future. */
+    scheduledAt: string;
+}
+interface ScheduleNotificationResult {
+    jobId: string;
+    scheduledAt: string;
+}
+interface CancelScheduledNotificationResult {
+    cancelled: boolean;
+    reason?: string;
+    status?: string;
+}
+type ScheduledJobStatus = "pending" | "executed" | "cancelled" | "failed";
+interface ScheduledNotification {
+    jobId: string;
+    userId: string;
+    title: string;
+    body: string;
+    data?: unknown;
+    badge?: number;
+    sound?: string;
+    scheduledAt: string;
+    status: ScheduledJobStatus;
+    resultHistoryId?: string;
+    errorMessage?: string;
+    createdAt: string;
+}
+interface PushEventPayload {
+    title: string;
+    body: string;
+    data?: unknown;
+}
+declare class NotificationsResource {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiBaseUrl: string, apiKey: string);
+    private post;
+    private get;
+    private delete;
+    /**
+     * Register a device (or refresh its metadata) for push delivery.
+     * Safe to call repeatedly — the server dedupes by native token.
+     */
+    registerDevice(input: RegisterDeviceInput): Promise<RegisterDeviceResult>;
+    /** Revoke a device — on sign-out or when the OS reports an invalid token. */
+    unregisterDevice(input: UnregisterDeviceInput): Promise<{
+        revoked: boolean;
+    }>;
+    /**
+     * Send a push notification to every active device belonging to
+     * `userId`. Honors the user's notificationPreferences (quiet hours,
+     * DND, channel off) before publishing.
+     */
+    send(input: SendNotificationInput): Promise<SendNotificationResult>;
+    /** Read a user's notification preferences. Returns defaults when no row exists. */
+    getPreferences(userId: string): Promise<NotificationPreferences>;
+    updatePreferences(input: UpdatePreferencesInput): Promise<{
+        ok: boolean;
+    }>;
+    /**
+     * Schedule a future push notification. Convex's native scheduler
+     * fires the send at `scheduledAt` and runs the same delivery
+     * pipeline as `send()` (preferences, devices, history audit).
+     *
+     * Throws `NotificationsError` with status 400 if `scheduledAt` is
+     * not strictly in the future.
+     */
+    schedule(input: ScheduleNotificationInput): Promise<ScheduleNotificationResult>;
+    /**
+     * Cancel a pending scheduled notification. Returns `cancelled: false`
+     * (no error) if the job has already executed, was previously
+     * cancelled, or no longer exists — `reason` describes which case.
+     */
+    cancelScheduled(jobId: string): Promise<CancelScheduledNotificationResult>;
+    /**
+     * List scheduled notifications for a user — pending, executed,
+     * cancelled, or failed. Most-recent first. Default limit 100.
+     */
+    listScheduled(userId: string, options?: {
+        limit?: number;
+    }): Promise<ScheduledNotification[]>;
+    getVapidKey(): Promise<string | null>;
+    onPushReceived(callback: (payload: PushEventPayload) => void): () => void;
+    onPushTapped(callback: (payload: PushEventPayload) => void): () => void;
+}
+
+/**
+ * PatientDetailsResource — merged Hint + Elation patient lookups.
+ *
+ * Backed by the Truth API at /api/patients/details/*, authenticated with
+ * X-API-Key. Replaces CommHub's getPatientDetails / getPatientBasicDetails
+ * / getPatientMedicalDetails actions.
+ */
+interface PatientDetailsInput {
     hintId?: string;
-    /** Patient first name */
-    firstName: string;
-    /** Patient last name */
-    lastName: string;
-    /** Date of birth (ISO 8601 date string, e.g. "1990-01-15") */
-    dateOfBirth?: string;
-    /** Patient sex */
-    sex?: string;
-    /** Primary email address */
+    elationId?: string;
+}
+interface PatientDetailsResult {
+    hint: unknown | null;
+    elation: unknown | null;
+    resolvedElationId: string | null;
+}
+interface PatientBasicDetailsResult {
+    hint: unknown | null;
+    elationId: string | null;
+}
+interface PatientMedicalDetailsResult {
+    problems: unknown | null;
+    medications: unknown | null;
+    allergies: unknown | null;
+    appointments: unknown | null;
+}
+declare class PatientDetailsResource {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiBaseUrl: string, apiKey: string);
+    private post;
+    get(input: PatientDetailsInput): Promise<PatientDetailsResult>;
+    getBasic(input: PatientDetailsInput): Promise<PatientBasicDetailsResult>;
+    getMedical(elationId: string): Promise<PatientMedicalDetailsResult>;
+    /**
+     * Trigger a server-side refresh of the patient's Elation medical
+     * records (medications, problems, allergies, appointments) into the
+     * Convex cache. Fire-and-forget — the UI should read via the Convex-
+     * reactive `usePatientMedical` hook.
+     */
+    refreshMedical(elationId: number): Promise<{
+        totals: {
+            medications: number;
+            problems: number;
+            allergies: number;
+            appointments: number;
+        };
+    }>;
+}
+
+/**
+ * PatientResource provides data access to normalized patient records
+ * backed by Convex.
+ */
+
+declare class PatientResource {
+    private readonly convex;
+    constructor(convexClient: ConvexHttpClient);
+    /**
+     * Get a patient by their Truth platform ID.
+     */
+    get(id: string): Promise<Patient | null>;
+    /**
+     * Get a patient by their Elation EHR ID.
+     */
+    getByElationId(elationId: string): Promise<Patient | null>;
+    /**
+     * Get a patient by their Hint EHR ID.
+     */
+    getByHintId(hintId: string): Promise<Patient | null>;
+    /**
+     * List patients with optional search, pagination, and limit.
+     */
+    list(options?: PatientListOptions): Promise<PaginatedResult<Patient>>;
+}
+
+/**
+ * PhysiciansResource — Convex-backed physician lookups.
+ *
+ * Populated from Elation by Truth's daily PhysiciansBackfillCron. Replaces
+ * per-physician Elation HTTP hops with a single Convex batch query.
+ */
+
+interface Physician {
+    _id: string;
+    elationId: number;
+    firstName?: string;
+    lastName?: string;
+    npi?: string;
+    credentials?: string;
+    specialties?: string[];
+    practice?: number;
     email?: string;
-    /** Primary phone number */
     phone?: string;
-    /** Patient status in the system */
-    status: string;
-    /** Associated organization/tenant ID */
-    tenantId: string;
-    /** ISO 8601 timestamp of record creation */
+    lastSyncedAt: string;
+}
+declare class PhysiciansResource {
+    private readonly convex;
+    constructor(convex: ConvexHttpClient);
+    /**
+     * Resolve a batch of physicians by Elation IDs. Missing ids are dropped.
+     */
+    getByElationIds(ids: number[]): Promise<Physician[]>;
+    getByElationId(id: number): Promise<Physician | null>;
+    listByPractice(practice: number, limit?: number): Promise<Physician[]>;
+}
+
+/**
+ * RemindersResource — schedule, cancel, and list conversation reminders.
+ *
+ * Backed by Convex mutations/queries (durable scheduled functions) — replaces
+ * the in-memory setTimeout scheduler that used to live in CommHub's NestJS
+ * backend.
+ */
+
+declare class RemindersResource {
+    private readonly convex;
+    constructor(convexClient: ConvexHttpClient);
+    /**
+     * Schedule a reminder to fire at `remindAt`. Returns the reminder id,
+     * which callers should store if they may want to cancel it later.
+     */
+    schedule(input: ScheduleReminderInput): Promise<ScheduleReminderResult>;
+    /**
+     * Cancel a pending reminder. No-op if the reminder has already fired or
+     * been cancelled.
+     */
+    cancel(reminderId: string, cancelledBy: string): Promise<{
+        reminderId: string;
+        status: string;
+    }>;
+    /**
+     * List reminders for a conversation (most recent first).
+     */
+    listByConversation(conversationId: string): Promise<Reminder[]>;
+}
+
+type TaskStatus = "open" | "in_progress" | "resolved" | "cancelled";
+interface Task {
+    _id: string;
+    eventId?: string;
+    assignedTo: string;
+    createdBy: string;
+    title: string;
+    description?: string;
+    data?: unknown;
+    status: TaskStatus;
+    resolvedBy?: string;
+    resolvedAt?: string;
     createdAt: string;
-    /** ISO 8601 timestamp of last update */
     updatedAt: string;
 }
+interface CreateTaskInput {
+    eventId?: string;
+    assignedTo: string;
+    createdBy: string;
+    title: string;
+    description?: string;
+    data?: unknown;
+}
+interface UpdateTaskStatusInput {
+    taskId: string;
+    status: TaskStatus;
+    resolvedBy?: string;
+    data?: unknown;
+}
+
 /**
- * Options for listing patients.
+ * TasksResource — create, update status, list, get tasks.
+ *
+ * Backed by Convex. Replaces CommHub's createTaskWithNotification +
+ * updateTaskStatusWithNotification actions. Push notification side-effect
+ * is emitted downstream via Kinesis.
  */
-interface PatientListOptions {
-    /** Search patients by name, email, or phone */
-    search?: string;
-    /** Maximum number of results to return */
-    limit?: number;
-    /** Cursor for pagination */
-    cursor?: string;
+
+declare class TasksResource {
+    private readonly convex;
+    constructor(convexClient: ConvexHttpClient);
+    create(input: CreateTaskInput): Promise<{
+        taskId: string;
+        status: TaskStatus;
+    }>;
+    updateStatus(input: UpdateTaskStatusInput): Promise<{
+        taskId: string;
+        status: TaskStatus;
+        previousStatus: TaskStatus;
+    }>;
+    get(taskId: string): Promise<Task | null>;
+    listByAssignee(assignedTo: string, options?: {
+        status?: TaskStatus;
+        limit?: number;
+    }): Promise<Task[]>;
+    listOpen(limit?: number): Promise<Task[]>;
+}
+
+interface TranslationResult {
+    translatedText: string;
+    detectedLanguage?: {
+        language: string;
+        score: number;
+    };
+    sourceLanguage: string;
+    targetLanguage: string;
+}
+interface DetectionResult {
+    language: string;
+    score: number;
+    isTranslationSupported: boolean;
+    isTransliterationSupported: boolean;
+}
+interface TranslateTextInput {
+    text: string;
+    targetLanguage: string;
+    sourceLanguage?: string;
+}
+interface TranslateBatchInput {
+    texts: string[];
+    targetLanguage: string;
+    sourceLanguage?: string;
 }
 
-export { ACTIVE_CALL_STATES, type Appointment, type AppointmentListOptions, CONNECTED_CALL_STATES, type ConversationListItem, type ConversationMessage, type ConversationMessageRow, type ConversationNoteRow, type ConversationRow, type ConversationTaskForUserRow, type ConversationTaskRow, type DialpadCallLogRow, type DialpadCallRow, DialpadCallState, type EventPayloadMap, type EventType, type Patient, type PatientListOptions, type PermissionStatus, type Physician, RINGING_CALL_STATES, TERMINAL_CALL_STATES, type TrackOptions, TruthProvider, type TruthProviderProps, type TruthTrackingContextValue, TruthTrackingProvider, type TruthTrackingProviderProps, type UseActiveCallsOptions, type UseAppointmentListOptions, type UseConversationMessagesOptions, type UseConversationsFilters, type UseMessagesOptions, type UseNotificationsOptions, type UseNotificationsResult, type UsePatientBasicOptions, type UsePatientBasicResult, type UsePatientListOptions, type UsePatientMedicalOptions, type UsePatientPhotoOptions, type UseQueryResult, useActiveCalls, useAppointment, useAppointmentByElationId, useAppointments, useConversationByPhonePair, useConversationMessages, useConversationNotes, useConversationNotesByPhonePair, useConversationTasks, useConversationTasksByPhonePair, useConversationTasksForUser, useConversations, useDialpadCallByCallId, useDialpadCallLog, useDialpadCallsForConversation, useMessages, useNotifications, usePatient, usePatientBasic, usePatientByElationId, usePatientByHintId, usePatientMedical, usePatientPhoto, usePatients, usePharmacyByNcpdpId, usePhysicianByElationId, usePhysiciansByElationIds, useRemindersForConversations, useTruth, useUnreadCount };
+/**
+ * TranslationResource — Azure Translator proxy through Truth API.
+ *
+ * All three operations are HTTP calls to Truth's oRPC endpoints at
+ * `/api/translation/*`, authenticated with the same X-API-Key as the
+ * event tracker.
+ */
+
+declare class TranslationResource {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(apiBaseUrl: string, apiKey: string);
+    private post;
+    translate(input: TranslateTextInput): Promise<TranslationResult>;
+    translateBatch(input: TranslateBatchInput): Promise<TranslationResult[]>;
+    detect(text: string): Promise<DetectionResult>;
+}
+
+/**
+ * TruthClient -- main entry point for the @hipnation-truth/sdk package.
+ *
+ * Provides:
+ * - `.patients`      Resource-based patient data access (Convex-backed)
+ * - `.appointments`  Resource-based appointment data access (Convex-backed)
+ * - `.ehr`           EHR proxy access (Elation, Hint)
+ * - `.messages`      Messaging proxy access (Dialpad)
+ * - `.track()`       Fire-and-forget event tracking (batched HTTP -> Truth API)
+ * - `.identify()`    Set default actor context for subsequent events
+ * - `.flush()`       Force flush of buffered events (for graceful shutdown)
+ */
+
+declare class TruthClient {
+    /** Patient data resource (Convex-backed) */
+    readonly patients: PatientResource;
+    /** Appointment data resource (Convex-backed) */
+    readonly appointments: AppointmentResource;
+    /** EHR proxy — typed access to Elation and Hint APIs through Truth */
+    readonly ehr: EhrResource;
+    /** Messaging proxy — typed access to Dialpad APIs through Truth */
+    readonly messages: MessagesResource;
+    /** Conversation reminders (Convex-backed, durable scheduler) */
+    readonly reminders: RemindersResource;
+    /** Translation (Azure Translator proxy) */
+    readonly translation: TranslationResource;
+    /** Tasks (Convex-backed) */
+    readonly tasks: TasksResource;
+    /** Patient details — merged Hint + Elation lookups via Truth API */
+    readonly patientDetails: PatientDetailsResource;
+    /** Attachments — presigned S3 upload/download + Convex metadata */
+    readonly attachments: AttachmentsResource;
+    /** Notes — push formatted notes to Elation */
+    readonly notes: NotesResource;
+    /** Physicians (Convex-backed cache from Elation) */
+    readonly physicians: PhysiciansResource;
+    /** Push / web notifications (AWS End User Messaging) */
+    readonly notifications: NotificationsResource;
+    /** Conversation-tied writes — notes, tasks, outbound messages. */
+    readonly conversations: ConversationsResource;
+    /** User settings — notification preferences (Convex-backed) */
+    readonly userSettings: UserSettingsResource;
+    private readonly convex;
+    private readonly tracker;
+    private _vapidPublicKey;
+    private _webPushReady;
+    private readonly _serviceWorkerPath;
+    constructor(config: TruthClientConfig);
+    get vapidPublicKey(): string | null;
+    get webPushReady(): Promise<void> | null;
+    private initWebPush;
+    /**
+     * The resolved Truth API base URL for this environment.
+     * Use this when making HTTP calls to Truth's proxy endpoints
+     * (e.g., EHR proxy, messages proxy).
+     *
+     * @example
+     * ```ts
+     * const url = `${truth.apiBaseUrl}/api/ehr/elation/patients/123`;
+     * ```
+     */
+    get apiBaseUrl(): string;
+    /**
+     * Track an event. Fire-and-forget -- the event is buffered internally
+     * and flushed in batches to the Truth API.
+     *
+     * @example
+     * ```ts
+     * truth.track('conversation.message_sent.v1', {
+     *   channel: 'sms',
+     *   direction: 'outbound',
+     *   message_chars: 140,
+     *   has_attachment: false,
+     *   provider_system: 'dialpad',
+     * });
+     * ```
+     */
+    track<T extends EventType>(eventType: T, payload: EventPayloadMap[T], options?: TrackOptions): void;
+    /**
+     * Set the default actor context for all subsequent tracked events.
+     * Can be overridden per-event via TrackOptions.
+     *
+     * @example
+     * ```ts
+     * truth.identify('user_123', 'user');
+     * ```
+     */
+    identify(actorId: string, actorType: ActorContext["actorType"]): void;
+    /**
+     * Flush all buffered events immediately. Returns a Promise that resolves
+     * when the flush completes. Use this for graceful shutdown.
+     *
+     * @example
+     * ```ts
+     * process.on('SIGTERM', async () => {
+     *   await truth.flush();
+     *   process.exit(0);
+     * });
+     * ```
+     */
+    flush(): Promise<void>;
+    /**
+     * Gracefully shut down the client. Flushes all pending events and
+     * releases resources.
+     */
+    destroy(): Promise<void>;
+}
+
+/**
+ * React hook for fetching an authenticated Dialpad voicemail URL.
+ *
+ * Provides an imperative `fetchUrl` callback that wraps
+ * `client.messages.getVoicemailUrl()` in React state so CommHub's
+ * `AudioPlayer` can replace its urql `useMutation` with a single hook
+ * call, without adding a query library dependency.
+ *
+ * The TruthClient instance is passed directly so the hook is testable
+ * and doesn't require a global singleton or React context.
+ *
+ * @example
+ * ```tsx
+ * import { useVoicemailUrl } from '@hipnation-truth/sdk/react/voicemail';
+ * import { getTruthClient } from '@/lib/truthClient';
+ *
+ * function AudioPlayer({ uri }: { uri: string }) {
+ *   const { fetchUrl, url, isLoading, error } = useVoicemailUrl(getTruthClient());
+ *
+ *   const handlePlay = async () => {
+ *     const authenticated = await fetchUrl(uri);
+ *     if (authenticated) { ... }
+ *   };
+ * }
+ * ```
+ */
+
+interface UseVoicemailUrlResult {
+    /** Trigger the URL fetch. Resolves with the clean playback URL or null on error. */
+    fetchUrl: (voicemailLink: string) => Promise<string | null>;
+    /** The most recently fetched URL (null until first successful fetch). */
+    url: string | null;
+    /** True while the fetch is in-flight. */
+    isLoading: boolean;
+    /** Error message from the last failed fetch, or null. */
+    error: string | null;
+}
+/**
+ * Provides an imperative `fetchUrl` callback that authenticates a Dialpad
+ * voicemail link via the Truth SDK `messages.getVoicemailUrl()` method.
+ *
+ * @param client  The TruthClient instance (e.g., from `getTruthClient()`).
+ */
+declare function useVoicemailUrl(client: TruthClient): UseVoicemailUrlResult;
+
+export { ACTIVE_CALL_STATES, type Appointment, type AppointmentListOptions, CONNECTED_CALL_STATES, type ConversationListItem, type ConversationMessage, type ConversationMessageRow, type ConversationNoteRow, type ConversationRow, type ConversationTaskForUserRow, type ConversationTaskRow, type DialpadCallLogRow, type DialpadCallRow, DialpadCallState, type EventPayloadMap, type EventType, type FamilyMemberRow, type Patient, type PatientListOptions, type PatientSearchResult, type PermissionStatus, type Physician$1 as Physician, RINGING_CALL_STATES, TERMINAL_CALL_STATES, type TrackOptions, TruthProvider, type TruthProviderProps, type TruthTrackingContextValue, TruthTrackingProvider, type TruthTrackingProviderProps, type UseActiveCallsOptions, type UseAppointmentListOptions, type UseConversationMessagesOptions, type UseConversationsFilters, type UseMessagesOptions, type UseNotificationsOptions, type UseNotificationsResult, type UsePatientBasicOptions, type UsePatientBasicResult, type UsePatientFamilyMembersInput, type UsePatientListOptions, type UsePatientMedicalOptions, type UsePatientPhotoOptions, type UsePatientSearchOptions, type UseQueryResult, useActiveCalls, useAppointment, useAppointmentByElationId, useAppointments, useConversationByPhonePair, useConversationMessages, useConversationNotes, useConversationNotesByPhonePair, useConversationTasks, useConversationTasksByPhonePair, useConversationTasksForUser, useConversations, useDialpadCallByCallId, useDialpadCallLog, useDialpadCallsForConversation, useMessages, useNotifications, usePatient, usePatientBasic, usePatientByElationId, usePatientByHintId, usePatientFamilyMembers, usePatientMedical, usePatientPhoto, usePatientSearch, usePatients, usePatientsByIds, usePharmacyByNcpdpId, usePhysicianByElationId, usePhysiciansByElationIds, useRemindersForConversations, useTruth, useUnreadCount, useUserSettings, useVoicemailUrl };