@typecall/admin-sdk 0.1.3 → 0.2.0

package/dist/fabric/services/rest/client.js

@@ -0,0 +1,1070 @@
+import MiniSearch from 'minisearch';
+import { atom } from 'nanostores';
+
+// src/fabric/services/rest/errors.ts
+var RestError = class extends Error {
+  status;
+  statusText;
+  body;
+  constructor(status, statusText, body) {
+    super(`HTTP ${status} ${statusText}: ${body ?? ""}`);
+    this.name = "RestError";
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotFoundError = class extends RestError {
+  constructor(statusText = "Not Found", body) {
+    super(404, statusText, body);
+    this.name = "NotFoundError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function isNotFoundError(error) {
+  if (error instanceof NotFoundError) {
+    return true;
+  }
+  if (error instanceof RestError && error.status === 404) {
+    return true;
+  }
+  if (typeof error === "object" && error !== null && error.status === 404) {
+    return true;
+  }
+  return false;
+}
+var BaseResourceClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  items = /* @__PURE__ */ new Map();
+  isLoaded = false;
+  searchIndex;
+  _version = atom(1);
+  $version = this._version;
+  get version() {
+    return this._version.get();
+  }
+  get loaded() {
+    return this.isLoaded;
+  }
+  /**
+   * Returns all items currently stored in cache.
+   */
+  all() {
+    return Array.from(this.items.values());
+  }
+  /**
+   * Synchronously finds an item in cache by ID.
+   */
+  find(id) {
+    return this.items.get(id);
+  }
+  /**
+   * Synchronously finds multiple items in cache by ID.
+   */
+  getMany(...ids) {
+    const results = [];
+    for (const id of ids) {
+      const item = this.items.get(id);
+      if (item) results.push(item);
+    }
+    return results;
+  }
+  /**
+   * Searches cached items by search term using MiniSearch prefix matching.
+   * If search term is empty, returns all items.
+   */
+  search(term) {
+    const trimmed = term.trim();
+    if (!trimmed || !this.searchIndex) {
+      return this.all();
+    }
+    const results = this.searchIndex.search(trimmed, { prefix: true });
+    const matched = [];
+    for (const r of results) {
+      const item = this.items.get(r.id);
+      if (item) matched.push(item);
+    }
+    return matched;
+  }
+  /**
+   * Hook for subclasses to define what fields get indexed for search.
+   */
+  extractSearchTerms(item) {
+    return Object.values(item).filter((v) => typeof v === "string" || typeof v === "number").join(" ").toLowerCase();
+  }
+  /**
+   * Adds or replaces an item in the search index.
+   */
+  indexItem(item) {
+    if (!this.searchIndex) {
+      this.searchIndex = new MiniSearch({
+        fields: ["terms"],
+        storeFields: ["id"]
+      });
+    }
+    const doc = { id: item.id, terms: this.extractSearchTerms(item) };
+    if (this.searchIndex.has(item.id)) {
+      this.searchIndex.replace(doc);
+    } else {
+      this.searchIndex.add(doc);
+    }
+  }
+  /**
+   * Sets or updates a single item in cache and search index.
+   */
+  setItem(item) {
+    this.items.set(item.id, item);
+    this.indexItem(item);
+  }
+  /**
+   * Removes a single item from cache and search index.
+   */
+  removeItem(id) {
+    this.items.delete(id);
+    if (this.searchIndex?.has(id)) {
+      this.searchIndex.discard(id);
+    }
+  }
+  /**
+   * Populates cache and search index with all items, marking the client as loaded.
+   */
+  setAll(items) {
+    this.items.clear();
+    this.searchIndex?.removeAll();
+    for (const item of items) {
+      this.items.set(item.id, item);
+      this.indexItem(item);
+    }
+    this.isLoaded = true;
+    this.bump();
+  }
+  /**
+   * Clears the in-memory cache and search index.
+   */
+  clearCache() {
+    this.items.clear();
+    this.searchIndex?.removeAll();
+    this.isLoaded = false;
+    this.bump();
+  }
+  bump() {
+    this._version.set(this._version.get() + 1);
+  }
+};
+
+// src/fabric/services/rest/client/users.ts
+var UsersClient = class extends BaseResourceClient {
+  extractSearchTerms(user) {
+    return `${user.first_name} ${user.last_name} ${user.display_name ?? ""} ${user.email} ${user.extension ?? ""}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const users = await this.transport.requestData("/users");
+    this.setAll(users);
+    return users;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const user = await this.transport.requestData(`/users/${id}`);
+    this.setItem(user);
+    this.bump();
+    return user;
+  }
+  async create(data) {
+    const user = await this.transport.requestData("/users", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    this.setItem(user);
+    this.bump();
+    return user;
+  }
+  async update(id, data) {
+    const user = await this.transport.requestData(`/users/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    this.setItem(user);
+    this.bump();
+    return user;
+  }
+  async delete(id) {
+    await this.transport.request(`/users/${id}`, { method: "DELETE" });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/channels.ts
+var ChannelsClient = class extends BaseResourceClient {
+  extractSearchTerms(channel) {
+    return `${channel.name}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const channels = await this.transport.requestData("/channels");
+    this.setAll(channels);
+    return channels;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const channel = await this.transport.requestData(
+      `/channels/${id}`
+    );
+    this.setItem(channel);
+    this.bump();
+    return channel;
+  }
+  async create(data) {
+    const channel = await this.transport.requestData("/channels", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    this.setItem(channel);
+    this.bump();
+    return channel;
+  }
+  async update(id, data) {
+    const channel = await this.transport.requestData(
+      `/channels/${id}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setItem(channel);
+    this.bump();
+    return channel;
+  }
+  async delete(id) {
+    await this.transport.request(`/channels/${id}`, {
+      method: "DELETE"
+    });
+    this.removeItem(id);
+    this.bump();
+  }
+  publicChannels() {
+    return this.all().filter((c) => !c.is_private);
+  }
+};
+
+// src/fabric/services/rest/client/channel_numbers.ts
+var ChannelNumbersClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    const rawCid = item.cid || "";
+    const cleanCid = rawCid.replace(/^\+/, "");
+    return `${item.name || ""} ${rawCid} ${cleanCid} ${item.label || ""} ${item.country || ""}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/channel-numbers");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(
+      `/channel-numbers/${id}`
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async create(data) {
+    const channelNumber = await this.transport.requestData(
+      "/channel-numbers",
+      {
+        method: "POST",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setItem(channelNumber);
+    this.bump();
+    return channelNumber;
+  }
+  async update(id, data) {
+    const channelNumber = await this.transport.requestData(
+      `/channel-numbers/${id}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setItem(channelNumber);
+    this.bump();
+    return channelNumber;
+  }
+  async delete(id) {
+    await this.transport.request(`/channel-numbers/${id}`, {
+      method: "DELETE"
+    });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/phones.ts
+var PhonesClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    const rawMac = item.mac_address || "";
+    const cleanMac = rawMac.replace(/[:-]/g, "");
+    return `${item.name} ${item.model} ${item.serial_number || ""} ${rawMac} ${cleanMac} ${item.location}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/phones");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(`/phones/${id}`);
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  getConfig(id) {
+    return this.transport.request(`/phones/${id}/config`);
+  }
+  async create(data) {
+    const item = await this.transport.requestData("/phones", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async update(id, data) {
+    const item = await this.transport.requestData(`/phones/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async delete(id) {
+    await this.transport.request(`/phones/${id}`, { method: "DELETE" });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/phone_numbers.ts
+var PhoneNumbersClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    const rawStart = item.range_start || "";
+    const rawEnd = item.range_end || "";
+    const cleanStart = rawStart.replace(/^\+/, "");
+    const cleanEnd = rawEnd.replace(/^\+/, "");
+    return `${item.name} ${rawStart} ${cleanStart} ${rawEnd} ${cleanEnd} ${item.country}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/phone-numbers");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(
+      `/phone-numbers/${id}`
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async update(id, data) {
+    const item = await this.transport.requestData(
+      `/phone-numbers/${id}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+};
+
+// src/fabric/services/rest/client/business_hours.ts
+var BusinessHoursClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return `${item.name} ${item.timezone}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/business-hours");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(
+      `/business-hours/${id}`
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async create(data) {
+    const item = await this.transport.requestData(
+      "/business-hours",
+      {
+        method: "POST",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async update(id, data) {
+    const item = await this.transport.requestData(
+      `/business-hours/${id}`,
+      {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async delete(id) {
+    await this.transport.request(`/business-hours/${id}`, {
+      method: "DELETE"
+    });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/tags.ts
+var TagsClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return `${item.name} ${item.color} ${item.scopes.join(" ")}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/tags");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(`/tags/${id}`);
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async create(data) {
+    const tag = await this.transport.requestData("/tags", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    this.setItem(tag);
+    this.bump();
+    return tag;
+  }
+  async update(id, data) {
+    const tag = await this.transport.requestData(`/tags/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    this.setItem(tag);
+    this.bump();
+    return tag;
+  }
+  async delete(id) {
+    await this.transport.request(`/tags/${id}`, { method: "DELETE" });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/domains.ts
+var DomainsClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return item.domain.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/domains");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(`/domains/${id}`);
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async create(data) {
+    const domain = await this.transport.requestData("/domains", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    this.setItem(domain);
+    this.bump();
+    return domain;
+  }
+  async update(id, data) {
+    const domain = await this.transport.requestData(`/domains/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    this.setItem(domain);
+    this.bump();
+    return domain;
+  }
+  async delete(id) {
+    await this.transport.request(`/domains/${id}`, { method: "DELETE" });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/workspace.ts
+var WorkspaceClient = class extends BaseResourceClient {
+  cachedProfile = null;
+  async get(force = false) {
+    if (this.cachedProfile && !force) {
+      return this.cachedProfile;
+    }
+    const profile = await this.transport.requestData("/workspace");
+    this.cachedProfile = profile;
+    this.bump();
+    return profile;
+  }
+  async load(force = false) {
+    return this.get(force);
+  }
+  current() {
+    return this.cachedProfile;
+  }
+  async update(data) {
+    const profile = await this.transport.requestData(
+      "/workspace",
+      {
+        method: "PATCH",
+        body: JSON.stringify(data)
+      }
+    );
+    this.cachedProfile = profile;
+    this.bump();
+    return profile;
+  }
+  clearCache() {
+    super.clearCache();
+    this.cachedProfile = null;
+  }
+};
+
+// src/fabric/services/rest/client/files.ts
+var FilesClient = class extends BaseResourceClient {
+  getDownloadLink(path) {
+    return this.transport.requestData(
+      "/files/link/download",
+      {
+        headers: { "X-File-Path": path }
+      }
+    );
+  }
+  getUploadLink(category, entityId, extension) {
+    const params = new URLSearchParams({ category });
+    if (entityId) params.append("entity_id", entityId);
+    if (extension) params.append("extension", extension);
+    return this.transport.requestData(
+      `/files/link/upload?${params.toString()}`
+    );
+  }
+  async uploadToS3(data, url) {
+    const response = await fetch(url, {
+      method: "PUT",
+      body: data
+    });
+    if (!response.ok) {
+      throw new Error(`S3 Upload failed: ${response.statusText}`);
+    }
+  }
+  async uploadBlob(blob, entityId, category = "track", extension = "wav") {
+    const { url, path } = await this.getUploadLink(
+      category,
+      entityId,
+      extension
+    );
+    await this.uploadToS3(blob, url);
+    return path;
+  }
+  async uploadTrack(file, entityId) {
+    const extension = file.name.split(".").pop()?.toLowerCase() || "wav";
+    const { url, path } = await this.getUploadLink(
+      "track",
+      entityId,
+      extension
+    );
+    await this.uploadToS3(file, url);
+    return { path, name: file.name };
+  }
+};
+
+// src/fabric/services/rest/client/prompts.ts
+var PromptsClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return `${item.name} ${item.entity_id}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/prompts");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  listAllMy() {
+    return this.transport.requestData("/prompts/my");
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(`/prompts/${id}`);
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  async create(data) {
+    const prompt = await this.transport.requestData("/prompts", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+    this.setItem(prompt);
+    this.bump();
+    return prompt;
+  }
+  async update(id, data) {
+    const prompt = await this.transport.requestData(`/prompts/${id}`, {
+      method: "PATCH",
+      body: JSON.stringify(data)
+    });
+    this.setItem(prompt);
+    this.bump();
+    return prompt;
+  }
+  async delete(id) {
+    await this.transport.request(`/prompts/${id}`, { method: "DELETE" });
+    this.removeItem(id);
+    this.bump();
+  }
+};
+
+// src/fabric/services/rest/client/voices.ts
+var VoicesClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return `${item.name} ${item.language_code} ${item.gender} ${item.provider}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/voices");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(`/voices/${id}`);
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  voiceAgents() {
+    return this.all().filter(
+      (v) => v.scope.toLowerCase().replace(/[-_]/g, "") === "voiceagent"
+    );
+  }
+  synthesize(id, ssml) {
+    return this.transport.requestBlob(`/voices/${id}/tts/synthesize`, {
+      method: "POST",
+      body: JSON.stringify({ ssml })
+    });
+  }
+};
+
+// src/fabric/services/rest/client/invoices.ts
+var InvoicesClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return `${item.number} ${item.status}`.toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/invoices");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(`/invoices/${id}`);
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  getPaymentUrl(id) {
+    return this.transport.request(
+      `/invoices/${id}/payment-url`
+    );
+  }
+  download(id) {
+    return this.transport.requestBlob(`/invoices/${id}/download`);
+  }
+};
+
+// src/fabric/services/rest/client/payment_methods.ts
+var PaymentMethodsClient = class extends BaseResourceClient {
+  extractSearchTerms(item) {
+    return (item.last_four || item.last_four_digits || "").toLowerCase();
+  }
+  async listAll(force = false) {
+    if (this.isLoaded && !force) {
+      return this.all();
+    }
+    const items = await this.transport.requestData("/payment-methods");
+    this.setAll(items);
+    return items;
+  }
+  async load(force = false) {
+    return this.listAll(force);
+  }
+  async get(id, force = false) {
+    if (!force) {
+      const cached = this.find(id);
+      if (cached) return cached;
+    }
+    const item = await this.transport.requestData(
+      `/payment-methods/${id}`
+    );
+    this.setItem(item);
+    this.bump();
+    return item;
+  }
+  createUrl() {
+    return this.transport.request(
+      "/payment-methods/create-url"
+    );
+  }
+  async delete(id) {
+    await this.transport.request(`/payment-methods/${id}`, {
+      method: "DELETE"
+    });
+    this.removeItem(id);
+    this.bump();
+  }
+  async setAsPrimary(id) {
+    const paymentMethod = await this.transport.requestData(
+      `/payment-methods/${id}/set-as-primary`,
+      { method: "POST" }
+    );
+    for (const item of this.items.values()) {
+      item.is_primary = item.id === id;
+    }
+    this.setItem(paymentMethod);
+    this.bump();
+    return paymentMethod;
+  }
+};
+
+// src/fabric/services/rest/client/subscriptions.ts
+var SubscriptionsClient = class extends BaseResourceClient {
+  cachedSubscription = null;
+  async get(force = false) {
+    if (this.cachedSubscription && !force) {
+      return this.cachedSubscription;
+    }
+    const sub = await this.transport.requestData("/subscription");
+    this.cachedSubscription = sub;
+    this.bump();
+    return sub;
+  }
+  async load(force = false) {
+    return this.get(force);
+  }
+  current() {
+    return this.cachedSubscription;
+  }
+  clearCache() {
+    super.clearCache();
+    this.cachedSubscription = null;
+  }
+};
+
+// src/fabric/services/rest/client/analytics.ts
+var AnalyticsClient = class extends BaseResourceClient {
+  listCallLogs(params = {}) {
+    const query = new URLSearchParams();
+    if (params.from) query.append("from", params.from);
+    if (params.to) query.append("to", params.to);
+    if (params.page) query.append("page", String(params.page));
+    if (params.per_page) query.append("per_page", String(params.per_page));
+    if (params.status) {
+      params.status.forEach((s) => query.append("status[]", s));
+    }
+    if (params.category) {
+      params.category.forEach((c) => query.append("category[]", c));
+    }
+    if (params.user_id) {
+      params.user_id.forEach((u) => query.append("user_id[]", u));
+    }
+    const qs = query.toString();
+    const queryString = qs ? `?${qs}` : "";
+    return this.transport.request(`/analytics/call-logs${queryString}`).catch((err) => {
+      if (isNotFoundError(err)) {
+        return this.transport.request(
+          `/reports/call-logs${queryString}`
+        );
+      }
+      throw err;
+    });
+  }
+  async listCallEvents(callLogId) {
+    return this.transport.requestData(`/analytics/call-logs/${callLogId}/events`).catch((err) => {
+      if (isNotFoundError(err)) {
+        return this.transport.requestData(
+          `/reports/call-logs/${callLogId}/events`
+        );
+      }
+      throw err;
+    });
+  }
+  listCallUtterances(callLogId) {
+    return this.transport.requestData(
+      `/analytics/call-logs/${callLogId}/utterances`
+    );
+  }
+};
+
+// src/fabric/services/rest/client.ts
+var WorkspaceRestClient = class {
+  baseUrl;
+  getAccessToken;
+  getWorkspaceId;
+  refreshAccessToken;
+  fetchFn;
+  refreshPromise = null;
+  users;
+  channels;
+  channelNumbers;
+  phones;
+  phoneNumbers;
+  businessHours;
+  tags;
+  domains;
+  workspace;
+  files;
+  prompts;
+  voices;
+  invoices;
+  paymentMethods;
+  subscriptions;
+  analytics;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+    this.getAccessToken = config.getAccessToken;
+    this.getWorkspaceId = config.getWorkspaceId;
+    this.refreshAccessToken = config.refreshAccessToken;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.users = new UsersClient(this);
+    this.channels = new ChannelsClient(this);
+    this.channelNumbers = new ChannelNumbersClient(this);
+    this.phones = new PhonesClient(this);
+    this.phoneNumbers = new PhoneNumbersClient(this);
+    this.businessHours = new BusinessHoursClient(this);
+    this.tags = new TagsClient(this);
+    this.domains = new DomainsClient(this);
+    this.workspace = new WorkspaceClient(this);
+    this.files = new FilesClient(this);
+    this.prompts = new PromptsClient(this);
+    this.voices = new VoicesClient(this);
+    this.invoices = new InvoicesClient(this);
+    this.paymentMethods = new PaymentMethodsClient(this);
+    this.subscriptions = new SubscriptionsClient(this);
+    this.analytics = new AnalyticsClient(this);
+  }
+  clearCaches() {
+    this.users.clearCache();
+    this.channels.clearCache();
+    this.channelNumbers.clearCache();
+    this.phones.clearCache();
+    this.phoneNumbers.clearCache();
+    this.businessHours.clearCache();
+    this.tags.clearCache();
+    this.domains.clearCache();
+    this.workspace.clearCache();
+    this.files.clearCache();
+    this.prompts.clearCache();
+    this.voices.clearCache();
+    this.invoices.clearCache();
+    this.paymentMethods.clearCache();
+    this.subscriptions.clearCache();
+  }
+  async refreshToken() {
+    if (!this.refreshAccessToken) {
+      return void 0;
+    }
+    if (!this.refreshPromise) {
+      this.refreshPromise = (async () => {
+        try {
+          return await this.refreshAccessToken();
+        } finally {
+          this.refreshPromise = null;
+        }
+      })();
+    }
+    return this.refreshPromise;
+  }
+  async execute(path, init = {}, overrideToken, isRetry = false) {
+    const token = overrideToken ?? this.getAccessToken();
+    const workspaceId = this.getWorkspaceId();
+    const headers = {
+      ...init.body && typeof init.body === "string" ? { "Content-Type": "application/json" } : {},
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...workspaceId ? { "X-Workspace-ID": workspaceId } : {},
+      ...init.headers || {}
+    };
+    const res = await this.fetchFn(`${this.baseUrl}${path}`, {
+      ...init,
+      headers
+    });
+    if (res.status === 401 && !isRetry && this.refreshAccessToken) {
+      try {
+        const refreshedToken = await this.refreshToken();
+        const nextToken = typeof refreshedToken === "string" && refreshedToken.length > 0 ? refreshedToken : void 0;
+        return await this.execute(path, init, nextToken, true);
+      } catch (refreshErr) {
+        throw refreshErr;
+      }
+    }
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "");
+      if (res.status === 404) {
+        throw new NotFoundError(res.statusText, errorText);
+      }
+      throw new RestError(res.status, res.statusText, errorText);
+    }
+    return res;
+  }
+  async request(path, init = {}) {
+    const res = await this.execute(path, {
+      ...init,
+      headers: {
+        Accept: "application/json",
+        ...init.headers || {}
+      }
+    });
+    if (res.status === 204) {
+      return void 0;
+    }
+    return await res.json();
+  }
+  async requestData(path, init = {}) {
+    const res = await this.request(path, init);
+    return res.data;
+  }
+  async requestBlob(path, init = {}) {
+    const res = await this.execute(path, init);
+    return res.blob();
+  }
+};
+
+export { NotFoundError, RestError, WorkspaceRestClient, isNotFoundError };
+//# sourceMappingURL=client.js.map
+//# sourceMappingURL=client.js.map