@hipnation-truth/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,927 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __pow = Math.pow;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AUTH_EVENTS: () => AUTH_EVENTS,
+  AppointmentResource: () => AppointmentResource,
+  CALL_EVENTS: () => CALL_EVENTS,
+  CONVERSATION_EVENTS: () => CONVERSATION_EVENTS,
+  DialpadProxyError: () => DialpadProxyError,
+  DialpadResource: () => DialpadResource,
+  ENVIRONMENTS: () => ENVIRONMENTS,
+  EVENT_TYPES: () => EVENT_TYPES,
+  EhrProviderProxy: () => EhrProviderProxy,
+  EhrProxyError: () => EhrProxyError,
+  EhrResource: () => EhrResource,
+  MessagesResource: () => MessagesResource,
+  NOTIFICATION_EVENTS: () => NOTIFICATION_EVENTS,
+  PROVIDER_EVENTS: () => PROVIDER_EVENTS,
+  PatientResource: () => PatientResource,
+  REMINDER_EVENTS: () => REMINDER_EVENTS,
+  SECURITY_EVENTS: () => SECURITY_EVENTS,
+  TASK_EVENTS: () => TASK_EVENTS,
+  TRANSLATION_EVENTS: () => TRANSLATION_EVENTS,
+  Tracker: () => Tracker,
+  TruthClient: () => TruthClient,
+  generateUuidV7: () => generateUuidV7
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client.ts
+var import_browser = require("convex/browser");
+
+// src/resources/appointments.ts
+var AppointmentResource = class {
+  constructor(convexClient) {
+    this.convex = convexClient;
+  }
+  /**
+   * Get an appointment by its Truth platform ID.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "appointments:getById",
+          { id }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * List appointments with optional filters, pagination, and limit.
+   */
+  list(options) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "appointments:list",
+          {
+            patientId: options == null ? void 0 : options.patientId,
+            startDate: options == null ? void 0 : options.startDate,
+            endDate: options == null ? void 0 : options.endDate,
+            status: options == null ? void 0 : options.status,
+            limit: options == null ? void 0 : options.limit,
+            cursor: options == null ? void 0 : options.cursor
+          }
+        );
+        const typed = result;
+        return typed != null ? typed : { data: [], cursor: null, hasMore: false };
+      } catch (e) {
+        return { data: [], cursor: null, hasMore: false };
+      }
+    });
+  }
+};
+
+// src/resources/dialpad.ts
+var DialpadResource = class {
+  constructor(apiBaseUrl) {
+    this.baseUrl = apiBaseUrl;
+  }
+  /**
+   * Send an SMS or MMS message via Dialpad.
+   */
+  sendSms(params) {
+    return __async(this, null, function* () {
+      const body = __spreadValues(__spreadValues({
+        to_numbers: [params.to_number],
+        from_number: params.from_number,
+        infer_country_code: false
+      }, params.message ? { text: params.message } : {}), params.media ? { media: params.media } : {});
+      return this.post("/sms", body);
+    });
+  }
+  /**
+   * Initiate an outbound call from a Dialpad user to a phone number.
+   */
+  initiateCall(userId, phoneNumber) {
+    return __async(this, null, function* () {
+      return this.post(`/users/${userId}/initiate_call`, {
+        phone_number: phoneNumber
+      });
+    });
+  }
+  /**
+   * Hang up an active call.
+   */
+  hangupCall(callId) {
+    return __async(this, null, function* () {
+      yield this.put(`/call/${callId}/actions/hangup`);
+    });
+  }
+  /**
+   * Get the status of a call.
+   */
+  getCallStatus(callId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(`/call/${callId}`);
+      } catch (error) {
+        if (error instanceof DialpadProxyError && error.status === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Get a Dialpad user by their user ID.
+   */
+  getUser(userId) {
+    return __async(this, null, function* () {
+      try {
+        return yield this.get(`/users/${userId}`);
+      } catch (error) {
+        if (error instanceof DialpadProxyError && error.status === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Find a Dialpad user by email.
+   */
+  getUserByEmail(email) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const result = yield this.get("/users", {
+        email
+      });
+      return (_b = (_a = result.items) == null ? void 0 : _a[0]) != null ? _b : null;
+    });
+  }
+  /**
+   * Find a Dialpad user by phone number.
+   */
+  getUserByPhoneNumber(phoneNumber) {
+    return __async(this, null, function* () {
+      var _a, _b;
+      const result = yield this.get("/users", {
+        number: phoneNumber
+      });
+      return (_b = (_a = result.items) == null ? void 0 : _a[0]) != null ? _b : null;
+    });
+  }
+  /**
+   * Get information about a Dialpad phone number.
+   */
+  getNumberInfo(phoneNumber) {
+    return __async(this, null, function* () {
+      try {
+        const cleanNumber = phoneNumber.replace(/[^\d+]/g, "");
+        return yield this.get(
+          `/numbers/${encodeURIComponent(cleanNumber)}`
+        );
+      } catch (error) {
+        if (error instanceof DialpadProxyError && error.status === 404) {
+          return null;
+        }
+        throw error;
+      }
+    });
+  }
+  /**
+   * Authenticate a voicemail download URL. Truth appends the Dialpad API key,
+   * follows redirects, and returns the clean URL for client-side playback.
+   */
+  authenticateVoicemail(voicemailLink) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/messages/dialpad/voicemail/authenticate`;
+      const response = yield fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ voicemail_link: voicemailLink })
+      });
+      const result = yield response.json();
+      if (!response.ok || !result.success) {
+        return null;
+      }
+      return result.authenticated_url;
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Internal HTTP helpers
+  // -----------------------------------------------------------------------
+  get(path, params) {
+    return __async(this, null, function* () {
+      const url = new URL(`/api/messages/dialpad${path}`, this.baseUrl);
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          if (value !== void 0) {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      }
+      const response = yield fetch(url.toString(), {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new DialpadProxyError("GET", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  post(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/messages/dialpad${path}`;
+      const response = yield fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new DialpadProxyError("POST", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  put(path, body) {
+    return __async(this, null, function* () {
+      var _a;
+      const url = `${this.baseUrl}/api/messages/dialpad${path}`;
+      const response = yield fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new DialpadProxyError("PUT", path, response.status);
+      }
+      if ((_a = response.headers.get("content-type")) == null ? void 0 : _a.includes("json")) {
+        return yield response.json();
+      }
+      return void 0;
+    });
+  }
+};
+var MessagesResource = class {
+  constructor(apiBaseUrl) {
+    this.dialpad = new DialpadResource(apiBaseUrl);
+  }
+};
+var DialpadProxyError = class extends Error {
+  constructor(method, path, status) {
+    super(
+      `Dialpad proxy error: ${method} /api/messages/dialpad${path} returned ${status}`
+    );
+    this.name = "DialpadProxyError";
+    this.method = method;
+    this.path = path;
+    this.status = status;
+  }
+};
+
+// src/resources/ehr.ts
+var EhrProviderProxy = class {
+  constructor(apiBaseUrl, provider) {
+    this.baseUrl = apiBaseUrl;
+    this.provider = provider;
+  }
+  /**
+   * GET request to the EHR proxy.
+   * @param path — path relative to the provider root (e.g., "/patients/123/")
+   * @param params — optional query parameters
+   */
+  get(path, params) {
+    return __async(this, null, function* () {
+      const url = new URL(`/api/ehr/${this.provider}${path}`, this.baseUrl);
+      if (params) {
+        for (const [key, value] of Object.entries(params)) {
+          if (value !== void 0) {
+            url.searchParams.set(key, String(value));
+          }
+        }
+      }
+      const response = yield fetch(url.toString(), {
+        method: "GET",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "GET", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * POST request to the EHR proxy.
+   */
+  post(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "POST", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * PUT request to the EHR proxy.
+   */
+  put(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "PUT",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "PUT", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * PATCH request to the EHR proxy.
+   */
+  patch(path, body) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "PATCH", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+  /**
+   * DELETE request to the EHR proxy.
+   */
+  delete(path) {
+    return __async(this, null, function* () {
+      const url = `${this.baseUrl}/api/ehr/${this.provider}${path}`;
+      const response = yield fetch(url, {
+        method: "DELETE",
+        headers: { Accept: "application/json" }
+      });
+      if (!response.ok) {
+        throw new EhrProxyError(this.provider, "DELETE", path, response.status);
+      }
+      return yield response.json();
+    });
+  }
+};
+var EhrResource = class {
+  constructor(apiBaseUrl) {
+    this.elation = new EhrProviderProxy(apiBaseUrl, "elation");
+    this.hint = new EhrProviderProxy(apiBaseUrl, "hint");
+  }
+};
+var EhrProxyError = class extends Error {
+  constructor(provider, method, path, status) {
+    super(
+      `EHR proxy error: ${method} /api/ehr/${provider}${path} returned ${status}`
+    );
+    this.name = "EhrProxyError";
+    this.provider = provider;
+    this.method = method;
+    this.path = path;
+    this.status = status;
+  }
+};
+
+// src/resources/patients.ts
+var PatientResource = class {
+  constructor(convexClient) {
+    this.convex = convexClient;
+  }
+  /**
+   * Get a patient by their Truth platform ID.
+   */
+  get(id) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:getById",
+          {
+            id
+          }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * Get a patient by their Elation EHR ID.
+   */
+  getByElationId(elationId) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:getByElationId",
+          { elationId }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * Get a patient by their Hint EHR ID.
+   */
+  getByHintId(hintId) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:getByHintId",
+          {
+            hintId
+          }
+        );
+        return result != null ? result : null;
+      } catch (e) {
+        return null;
+      }
+    });
+  }
+  /**
+   * List patients with optional search, pagination, and limit.
+   */
+  list(options) {
+    return __async(this, null, function* () {
+      try {
+        const result = yield this.convex.query(
+          "patients:list",
+          {
+            search: options == null ? void 0 : options.search,
+            limit: options == null ? void 0 : options.limit,
+            cursor: options == null ? void 0 : options.cursor
+          }
+        );
+        const typed = result;
+        return typed != null ? typed : { data: [], cursor: null, hasMore: false };
+      } catch (e) {
+        return { data: [], cursor: null, hasMore: false };
+      }
+    });
+  }
+};
+
+// src/tracking/tracker.ts
+function generateUuidV7() {
+  const now = Date.now();
+  const timeBytes = new Uint8Array(6);
+  let ts = now;
+  for (let i = 5; i >= 0; i--) {
+    timeBytes[i] = ts & 255;
+    ts = Math.floor(ts / 256);
+  }
+  const randomBytes = new Uint8Array(10);
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
+    globalThis.crypto.getRandomValues(randomBytes);
+  } else {
+    for (let i = 0; i < 10; i++) {
+      randomBytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  const bytes = new Uint8Array(16);
+  bytes.set(timeBytes, 0);
+  bytes.set(randomBytes, 6);
+  bytes[6] = bytes[6] & 15 | 112;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return [
+    hex.slice(0, 8),
+    hex.slice(8, 12),
+    hex.slice(12, 16),
+    hex.slice(16, 20),
+    hex.slice(20, 32)
+  ].join("-");
+}
+var API_URLS = {
+  local: "http://localhost:3000",
+  staging: "https://app.sandbox.communication-hub.com",
+  sandbox: "https://app.sandbox.communication-hub.com",
+  uat: "https://app.sandbox.communication-hub.com",
+  production: "https://app.truth.communication-hub.com"
+};
+var DEFAULT_BATCH_SIZE = 25;
+var DEFAULT_FLUSH_INTERVAL_MS = 5e3;
+var MAX_RETRIES = 3;
+var BASE_RETRY_DELAY_MS = 500;
+var Tracker = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isFlushing = false;
+    this.isShutdown = false;
+    var _a, _b;
+    this.config = config;
+    this.apiUrl = (_b = (_a = config.apiBaseUrl) != null ? _a : API_URLS[config.environment]) != null ? _b : API_URLS.local;
+    this.startFlushInterval();
+    this.registerShutdownHooks();
+  }
+  /**
+   * Set the default actor context for subsequent events.
+   */
+  setActor(actor) {
+    this.defaultActor = actor;
+  }
+  /**
+   * Enqueue a typed event for delivery. This is fire-and-forget from
+   * the caller's perspective -- events are buffered and flushed in batches.
+   */
+  track(eventType, payload, options) {
+    var _a, _b, _c;
+    if (this.isShutdown) {
+      return;
+    }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const envelope = {
+      event_id: generateUuidV7(),
+      event_type: eventType,
+      schema_version: 1,
+      occurred_at: (_a = options == null ? void 0 : options.occurredAt) != null ? _a : now,
+      received_at: now,
+      source: this.config.source,
+      source_version: this.config.sourceVersion,
+      tenant_id: (_b = options == null ? void 0 : options.tenantId) != null ? _b : this.config.tenantId,
+      actor: (_c = options == null ? void 0 : options.actor) != null ? _c : this.defaultActor ? {
+        actor_id: this.defaultActor.actorId,
+        actor_type: this.defaultActor.actorType
+      } : void 0,
+      subject: options == null ? void 0 : options.subject,
+      compliance: options == null ? void 0 : options.compliance,
+      payload
+    };
+    this.queue.push(envelope);
+    if (this.queue.length >= this.config.batchSize) {
+      void this.flush();
+    }
+  }
+  /**
+   * Force an immediate flush of all buffered events.
+   * Returns a promise that resolves when the flush completes.
+   */
+  flush() {
+    return __async(this, null, function* () {
+      if (this.queue.length === 0 || this.isFlushing) {
+        return;
+      }
+      this.isFlushing = true;
+      const batch = this.queue.splice(0, this.config.batchSize);
+      try {
+        yield this.sendBatch(batch);
+      } catch (e) {
+        this.queue.unshift(...batch);
+      } finally {
+        this.isFlushing = false;
+      }
+      if (this.queue.length >= this.config.batchSize) {
+        yield this.flush();
+      }
+    });
+  }
+  /**
+   * Gracefully shut down the tracker. Flushes remaining events and
+   * clears the flush interval.
+   */
+  shutdown() {
+    return __async(this, null, function* () {
+      this.isShutdown = true;
+      this.stopFlushInterval();
+      yield this.flush();
+    });
+  }
+  /**
+   * Send a batch of events to the Truth API with exponential backoff retry.
+   */
+  sendBatch(batch) {
+    return __async(this, null, function* () {
+      let lastError;
+      for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          const response = yield fetch(`${this.apiUrl}/api/events/ingest`, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${this.config.apiKey}`
+            },
+            body: JSON.stringify({ events: batch })
+          });
+          if (response.ok) {
+            return;
+          }
+          if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+            return;
+          }
+          lastError = new Error(
+            `HTTP ${response.status}: ${response.statusText}`
+          );
+        } catch (error) {
+          lastError = error;
+        }
+        if (attempt < MAX_RETRIES) {
+          const delay = BASE_RETRY_DELAY_MS * __pow(2, attempt);
+          const jitter = Math.random() * delay * 0.5;
+          yield sleep(delay + jitter);
+        }
+      }
+      throw lastError;
+    });
+  }
+  startFlushInterval() {
+    if (this.config.flushIntervalMs > 0) {
+      this.flushTimer = setInterval(() => {
+        void this.flush();
+      }, this.config.flushIntervalMs);
+      if (typeof this.flushTimer === "object" && "unref" in this.flushTimer) {
+        this.flushTimer.unref();
+      }
+    }
+  }
+  stopFlushInterval() {
+    if (this.flushTimer !== null) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  registerShutdownHooks() {
+    if (typeof globalThis.process !== "undefined" && globalThis.process.on) {
+      const shutdownHandler = () => {
+        void this.shutdown();
+      };
+      globalThis.process.on("beforeExit", shutdownHandler);
+      globalThis.process.on("SIGTERM", shutdownHandler);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/client.ts
+var CONVEX_URLS = {
+  local: "http://localhost:3210",
+  staging: "https://staging-truth.convex.cloud",
+  uat: "https://uat-truth.convex.cloud",
+  production: "https://truth.convex.cloud"
+};
+var TruthClient = class {
+  constructor(config) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const convexUrl = (_b = (_a = config.convexUrl) != null ? _a : CONVEX_URLS[config.environment]) != null ? _b : CONVEX_URLS.local;
+    this.convex = new import_browser.ConvexHttpClient(convexUrl);
+    this.tracker = new Tracker({
+      apiKey: config.apiKey,
+      environment: config.environment,
+      source: (_c = config.source) != null ? _c : "unknown",
+      sourceVersion: (_d = config.sourceVersion) != null ? _d : "unknown",
+      tenantId: (_e = config.tenantId) != null ? _e : "",
+      batchSize: (_f = config.batchSize) != null ? _f : DEFAULT_BATCH_SIZE,
+      flushIntervalMs: (_g = config.flushIntervalMs) != null ? _g : DEFAULT_FLUSH_INTERVAL_MS,
+      apiBaseUrl: config.apiBaseUrl
+    });
+    const apiUrl = this.tracker.apiUrl;
+    this.patients = new PatientResource(this.convex);
+    this.appointments = new AppointmentResource(this.convex);
+    this.ehr = new EhrResource(apiUrl);
+    this.messages = new MessagesResource(apiUrl);
+  }
+  /**
+   * 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() {
+    return this.tracker.apiUrl;
+  }
+  /**
+   * 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(eventType, payload, options) {
+    this.tracker.track(eventType, payload, options);
+  }
+  /**
+   * 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, actorType) {
+    this.tracker.setActor({ actorId, actorType });
+  }
+  /**
+   * 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() {
+    return __async(this, null, function* () {
+      yield this.tracker.flush();
+    });
+  }
+  /**
+   * Gracefully shut down the client. Flushes all pending events and
+   * releases resources.
+   */
+  destroy() {
+    return __async(this, null, function* () {
+      yield this.tracker.shutdown();
+    });
+  }
+};
+
+// src/tracking/events.ts
+var CONVERSATION_EVENTS = {
+  created: "conversation.created.v1",
+  messageSent: "conversation.message_sent.v1",
+  messageReceived: "conversation.message_received.v1",
+  markedRead: "conversation.marked_read.v1",
+  attachmentUploaded: "conversation.attachment_uploaded.v1",
+  attachmentDownloaded: "conversation.attachment_downloaded.v1"
+};
+var CALL_EVENTS = {
+  initiated: "call.initiated.v1",
+  connected: "call.connected.v1",
+  ended: "call.ended.v1",
+  missed: "call.missed.v1"
+};
+var TASK_EVENTS = {
+  created: "task.created.v1",
+  assigned: "task.assigned.v1",
+  statusChanged: "task.status_changed.v1"
+};
+var REMINDER_EVENTS = {
+  scheduled: "reminder.scheduled.v1",
+  triggered: "reminder.triggered.v1"
+};
+var TRANSLATION_EVENTS = {
+  requested: "translation.requested.v1",
+  completed: "translation.completed.v1"
+};
+var NOTIFICATION_EVENTS = {
+  sent: "notification.sent.v1",
+  delivered: "notification.delivered.v1",
+  opened: "notification.opened.v1"
+};
+var PROVIDER_EVENTS = {
+  syncStarted: "provider.sync_started.v1",
+  syncSucceeded: "provider.sync_succeeded.v1",
+  syncFailed: "provider.sync_failed.v1"
+};
+var AUTH_EVENTS = {
+  loginSucceeded: "auth.login_succeeded.v1",
+  loginFailed: "auth.login_failed.v1"
+};
+var SECURITY_EVENTS = {
+  accessDenied: "security.access_denied.v1"
+};
+var EVENT_TYPES = {
+  conversation: CONVERSATION_EVENTS,
+  call: CALL_EVENTS,
+  task: TASK_EVENTS,
+  reminder: REMINDER_EVENTS,
+  translation: TRANSLATION_EVENTS,
+  notification: NOTIFICATION_EVENTS,
+  provider: PROVIDER_EVENTS,
+  auth: AUTH_EVENTS,
+  security: SECURITY_EVENTS
+};
+
+// src/types/config.ts
+var ENVIRONMENTS = {
+  local: "local",
+  staging: "staging",
+  uat: "uat",
+  production: "production"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTH_EVENTS,
+  AppointmentResource,
+  CALL_EVENTS,
+  CONVERSATION_EVENTS,
+  DialpadProxyError,
+  DialpadResource,
+  ENVIRONMENTS,
+  EVENT_TYPES,
+  EhrProviderProxy,
+  EhrProxyError,
+  EhrResource,
+  MessagesResource,
+  NOTIFICATION_EVENTS,
+  PROVIDER_EVENTS,
+  PatientResource,
+  REMINDER_EVENTS,
+  SECURITY_EVENTS,
+  TASK_EVENTS,
+  TRANSLATION_EVENTS,
+  Tracker,
+  TruthClient,
+  generateUuidV7
+});
+//# sourceMappingURL=index.js.map