@typecall/admin-sdk 0.1.0 → 0.2.0

package/dist/index.cjs

@@ -1,5 +1,12 @@
 'use strict';
 
+var MiniSearch = require('minisearch');
+var nanostores = require('nanostores');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var MiniSearch__default = /*#__PURE__*/_interopDefault(MiniSearch);
+
 // src/errors.ts
 var AdminSdkError = class extends Error {
   constructor(message) {
@@ -42,36 +49,1355 @@ var RateLimitError = class extends ApiError {
   }
 };
 
+// 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 NotFoundError2 = 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 NotFoundError2) {
+    return true;
+  }
+  if (error instanceof RestError && error.status === 404) {
+    return true;
+  }
+  if (typeof error === "object" && error !== null && error.status === 404) {
+    return true;
+  }
+  return false;
+}
+
+// src/fabric/services/account/client.ts
+var AccountClient = class {
+  baseUrl;
+  accessToken;
+  fetchFn;
+  refreshPromise = null;
+  constructor(config) {
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.accessToken = config.accessToken;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  getToken() {
+    return this.accessToken;
+  }
+  async refreshToken() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = (async () => {
+      try {
+        const res = await this.fetchFn(`${this.baseUrl}/api/tokens`, {
+          method: "POST",
+          headers: {
+            Accept: "application/json"
+          },
+          credentials: "include"
+        });
+        if (!res.ok) {
+          const errorText = await res.text().catch(() => "");
+          throw new Error(
+            `Token refresh failed: HTTP ${res.status} ${res.statusText}: ${errorText}`
+          );
+        }
+        const body = await res.json();
+        this.accessToken = body.data.access_token;
+        return this.accessToken;
+      } finally {
+        this.refreshPromise = null;
+      }
+    })();
+    return this.refreshPromise;
+  }
+  async revokeToken() {
+    await this.fetchFn(`${this.baseUrl}/api/tokens`, {
+      method: "DELETE",
+      credentials: "include"
+    });
+    this.accessToken = "";
+  }
+  /**
+   * GET /api/account
+   * Fetches the currently authenticated account and associated workspaces.
+   * Automatically refreshes and retries once if a 401 Unauthorized is encountered.
+   */
+  async getAccount() {
+    const doFetch = (token) => this.fetchFn(`${this.baseUrl}/api/account`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json",
+        Authorization: `Bearer ${token}`
+      }
+    });
+    let res = await doFetch(this.accessToken);
+    if (res.status === 401) {
+      const newToken = await this.refreshToken();
+      res = await doFetch(newToken);
+    }
+    if (!res.ok) {
+      const errorText = await res.text().catch(() => "");
+      if (res.status === 404) {
+        throw new NotFoundError2(res.statusText, errorText);
+      }
+      throw new RestError(res.status, res.statusText, errorText);
+    }
+    const json = await res.json();
+    return json.data;
+  }
+};
+var BaseResourceClient = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  transport;
+  items = /* @__PURE__ */ new Map();
+  isLoaded = false;
+  searchIndex;
+  _version = nanostores.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__default.default({
+        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 NotFoundError2(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();
+  }
+};
+
 // src/client.ts
-var DEFAULT_BASE_URL = "https://api.typecall.com/v1";
+var ENVIRONMENTS = {
+  production: {
+    api: "https://rest.typecall.com/",
+    account: "https://account.typecall.com"
+  },
+  development: {
+    api: "https://rest.typecall.dev/",
+    account: "https://account.typecall.dev"
+  }
+};
 var DEFAULT_TIMEOUT_MS = 3e4;
 var TypecallAdmin = class {
   apiKey;
+  accessToken;
+  activeWorkspaceId;
+  accountData;
   baseUrl;
+  accountUrl;
   fetchFn;
   timeoutMs;
   defaultHeaders;
-  constructor(options) {
-    if (!options?.apiKey) {
+  accountClient;
+  restClient;
+  constructor(options = {}) {
+    if (options.apiKey !== void 0 && !options.apiKey.trim()) {
       throw new AdminSdkError(
         "An `apiKey` must be provided to initialize TypecallAdmin."
       );
     }
+    const env = options.environment ?? "production";
+    const envDefaults = ENVIRONMENTS[env] ?? ENVIRONMENTS.production;
     this.apiKey = options.apiKey;
-    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
-    this.fetchFn = options.fetch ?? globalThis.fetch;
-    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-    this.defaultHeaders = options.headers ?? {};
-    if (!this.fetchFn) {
+    this.accessToken = options.accessToken || void 0;
+    this.baseUrl = (options.baseUrl ?? envDefaults.api).replace(/\/+$/, "");
+    this.accountUrl = (options.accountUrl ?? envDefaults.account).replace(
+      /\/+$/,
+      ""
+    );
+    const rawFetch = options.fetch ?? globalThis.fetch;
+    if (!rawFetch) {
       throw new AdminSdkError(
         "No global `fetch` found. Provide a custom `fetch` implementation in `AdminSdkOptions`."
       );
     }
+    this.fetchFn = rawFetch.bind(globalThis);
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.defaultHeaders = options.headers ?? {};
+    this.accountClient = new AccountClient({
+      baseUrl: this.accountUrl,
+      accessToken: this.accessToken ?? "",
+      fetch: this.fetchFn
+    });
+    this.restClient = new WorkspaceRestClient({
+      baseUrl: this.baseUrl,
+      getAccessToken: () => this.apiKey || this.accessToken || this.accountClient.getToken(),
+      getWorkspaceId: () => this.activeWorkspaceId,
+      refreshAccessToken: async () => {
+        if (this.apiKey) return;
+        const newToken = await this.accountClient.refreshToken();
+        this.accessToken = newToken;
+        return newToken;
+      },
+      fetch: this.fetchFn
+    });
+  }
+  /**
+   * Sets the active workspace ID for subsequent workspace-scoped requests.
+   */
+  setWorkspaceId(workspaceId) {
+    if (this.activeWorkspaceId !== workspaceId) {
+      this.activeWorkspaceId = workspaceId;
+      this.restClient.clearCaches();
+    }
+  }
+  /**
+   * Returns the active workspace ID, if set.
+   */
+  getWorkspaceId() {
+    return this.activeWorkspaceId;
+  }
+  get users() {
+    return this.restClient.users;
+  }
+  get channels() {
+    return this.restClient.channels;
+  }
+  get channelNumbers() {
+    return this.restClient.channelNumbers;
+  }
+  get phones() {
+    return this.restClient.phones;
+  }
+  get phoneNumbers() {
+    return this.restClient.phoneNumbers;
+  }
+  get businessHours() {
+    return this.restClient.businessHours;
+  }
+  get tags() {
+    return this.restClient.tags;
+  }
+  get domains() {
+    return this.restClient.domains;
+  }
+  get workspace() {
+    return this.restClient.workspace;
+  }
+  get files() {
+    return this.restClient.files;
+  }
+  get prompts() {
+    return this.restClient.prompts;
+  }
+  get voices() {
+    return this.restClient.voices;
+  }
+  get invoices() {
+    return this.restClient.invoices;
+  }
+  get paymentMethods() {
+    return this.restClient.paymentMethods;
+  }
+  get subscriptions() {
+    return this.restClient.subscriptions;
+  }
+  get billing() {
+    return {
+      invoices: this.restClient.invoices,
+      paymentMethods: this.restClient.paymentMethods,
+      subscriptions: this.restClient.subscriptions
+    };
+  }
+  get analytics() {
+    return this.restClient.analytics;
+  }
+  /**
+   * Returns the currently cached Account, if loaded.
+   */
+  get account() {
+    return this.accountData;
+  }
+  /**
+   * Updates the active access token and re-syncs the internal Account client.
+   */
+  setAccessToken(token) {
+    this.accessToken = token;
+    this.accountClient = new AccountClient({
+      baseUrl: this.accountUrl,
+      accessToken: token,
+      fetch: this.fetchFn
+    });
+  }
+  /**
+   * Returns the active access token.
+   */
+  getAccessToken() {
+    return this.accessToken || this.accountClient.getToken() || void 0;
+  }
+  async getAccount() {
+    try {
+      let account;
+      if (this.accessToken) {
+        try {
+          account = await this.accountClient.getAccount();
+        } catch (fetchErr) {
+          const newToken = await this.accountClient.refreshToken();
+          this.accessToken = newToken;
+          account = await this.accountClient.getAccount();
+        }
+      } else {
+        const newToken = await this.accountClient.refreshToken();
+        this.accessToken = newToken;
+        account = await this.accountClient.getAccount();
+      }
+      this.accountData = account;
+      this.accessToken = this.accountClient.getToken();
+      return account;
+    } catch (err) {
+      throw new AuthenticationError(
+        "Authentication failed: unable to fetch account or refresh token",
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  /**
+   * Signs out by revoking the current session and clearing internal state.
+   */
+  async logout() {
+    try {
+      await this.accountClient.revokeToken();
+    } finally {
+      this.accessToken = void 0;
+      this.accountData = void 0;
+    }
   }
   /**
    * Helper to perform authenticated HTTP requests against the Typecall Admin API.
    */
   async request(path, options = {}) {
+    const authHeader = this.apiKey ? `Bearer ${this.apiKey}` : this.accessToken ? `Bearer ${this.accessToken}` : null;
+    if (!authHeader) {
+      throw new AdminSdkError(
+        "No authentication credentials available for this request."
+      );
+    }
     const { query, headers = {}, ...init } = options;
     const normalizedPath = path.startsWith("/") ? path : `/${path}`;
     const url = new URL(`${this.baseUrl}${normalizedPath}`);
@@ -88,7 +1414,7 @@ var TypecallAdmin = class {
       const response = await this.fetchFn(url.toString(), {
         ...init,
         headers: {
-          Authorization: `Bearer ${this.apiKey}`,
+          Authorization: authHeader,
           "Content-Type": "application/json",
           Accept: "application/json",
           ...this.defaultHeaders,
@@ -118,11 +1444,7 @@ var TypecallAdmin = class {
             );
           }
           default:
-            throw new ApiError(
-              response.status,
-              response.statusText,
-              errorBody
-            );
+            throw new ApiError(response.status, response.statusText, errorBody);
         }
       }
       if (response.status === 204) {