@vzaps/sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,992 @@
+// src/events.ts
+import WebSocket from "ws";
+var EventsResource = class {
+  constructor(http, webSocketFactory) {
+    this.http = http;
+    this.webSocketFactory = webSocketFactory;
+  }
+  http;
+  webSocketFactory;
+  async subscribe(request) {
+    const subscription = new EventSubscription(this.http, request, this.webSocketFactory);
+    await subscription.open();
+    return subscription;
+  }
+};
+var EventSubscription = class {
+  constructor(http, request, webSocketFactory) {
+    this.http = http;
+    this.request = request;
+    this.webSocketFactory = webSocketFactory;
+  }
+  http;
+  request;
+  webSocketFactory;
+  handlers = /* @__PURE__ */ new Map();
+  errorHandlers = /* @__PURE__ */ new Set();
+  lifecycleHandlers = /* @__PURE__ */ new Map();
+  socket;
+  closed = false;
+  retryCount = 0;
+  async open() {
+    const token = await this.http.getAccessToken(this.request.signal);
+    const url = this.http.buildRealtimeUrl("/events/ws", {
+      instance_id: this.request.instanceId,
+      events: this.request.events?.join(","),
+      access_token: token,
+      client_token: this.http.clientToken,
+      instance_token: this.request.instanceToken,
+      last_event_id: this.request.lastEventId
+    });
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      "X-Client-Token": this.http.clientToken
+    };
+    headers["X-Instance-Token"] = this.request.instanceToken;
+    this.socket = this.createSocket(url, headers);
+    this.bindSocket(this.socket);
+  }
+  on(event, handler) {
+    if (event === "error") {
+      this.errorHandlers.add(handler);
+      return this;
+    }
+    if (event === "open" || event === "close") {
+      this.addLifecycleHandler(event, handler);
+      return this;
+    }
+    const handlers = this.handlers.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.handlers.set(event, handlers);
+    return this;
+  }
+  off(event, handler) {
+    if (event === "error") {
+      this.errorHandlers.delete(handler);
+      return this;
+    }
+    if (event === "open" || event === "close") {
+      this.lifecycleHandlers.get(event)?.delete(handler);
+      return this;
+    }
+    this.handlers.get(event)?.delete(handler);
+    return this;
+  }
+  async close(code = 1e3, reason = "Client closed subscription") {
+    this.closed = true;
+    this.socket?.close(code, reason);
+  }
+  createSocket(url, headers) {
+    if (this.webSocketFactory) {
+      return this.webSocketFactory(url, headers);
+    }
+    if (typeof globalThis.WebSocket !== "undefined") {
+      return new globalThis.WebSocket(url);
+    }
+    return new WebSocket(url, { headers });
+  }
+  bindSocket(socket) {
+    listen(socket, "open", () => {
+      this.retryCount = 0;
+      this.emitLifecycle("open");
+    });
+    listen(socket, "message", (eventOrData) => {
+      const raw = readMessageData(eventOrData);
+      if (raw !== void 0) {
+        void this.dispatch(raw);
+      }
+    });
+    listen(socket, "error", (error) => {
+      this.emitError(error);
+    });
+    listen(socket, "close", () => {
+      this.emitLifecycle("close");
+      void this.reconnectIfNeeded();
+    });
+    this.request.signal?.addEventListener("abort", () => {
+      void this.close(1e3, "Subscription aborted");
+    }, { once: true });
+  }
+  async dispatch(raw) {
+    try {
+      const event = parseEvent(raw);
+      const handlers = /* @__PURE__ */ new Set([
+        ...this.handlers.get(event.type) ?? [],
+        ...this.handlers.get("All") ?? []
+      ]);
+      await Promise.all([...handlers].map((handler) => handler(event)));
+      this.ack(event.id);
+    } catch (error) {
+      this.emitError(error);
+    }
+  }
+  ack(eventId) {
+    if (!eventId || !this.socket) {
+      return;
+    }
+    this.socket.send(JSON.stringify({ type: "ack", event_id: eventId }));
+  }
+  async reconnectIfNeeded() {
+    if (this.closed || this.request.reconnect === false) {
+      return;
+    }
+    const maxRetries = this.request.maxRetries ?? Number.POSITIVE_INFINITY;
+    if (this.retryCount >= maxRetries) {
+      return;
+    }
+    this.retryCount += 1;
+    await delay(this.request.retryDelayMs ?? Math.min(3e4, 1e3 * this.retryCount));
+    await this.open();
+  }
+  addLifecycleHandler(event, handler) {
+    const handlers = this.lifecycleHandlers.get(event) ?? /* @__PURE__ */ new Set();
+    handlers.add(handler);
+    this.lifecycleHandlers.set(event, handlers);
+  }
+  emitLifecycle(event, ...args) {
+    for (const handler of this.lifecycleHandlers.get(event) ?? []) {
+      handler(...args);
+    }
+  }
+  emitError(error) {
+    if (this.errorHandlers.size === 0) {
+      return;
+    }
+    for (const handler of this.errorHandlers) {
+      handler(error);
+    }
+  }
+};
+function listen(socket, type, listener) {
+  if (socket.addEventListener) {
+    socket.addEventListener(type, listener);
+    return;
+  }
+  socket.on?.(type, listener);
+}
+function readMessageData(eventOrData) {
+  if (isRecord(eventOrData) && "data" in eventOrData) {
+    return eventOrData.data;
+  }
+  return eventOrData;
+}
+function parseEvent(raw) {
+  const text = typeof raw === "string" ? raw : Buffer.isBuffer(raw) ? raw.toString("utf8") : String(raw);
+  return JSON.parse(text);
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/errors.ts
+var VZapsError = class extends Error {
+  status;
+  code;
+  details;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "VZapsError";
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+  }
+};
+var VZapsAuthenticationError = class extends VZapsError {
+  constructor(message = "Invalid VZaps client credentials", details) {
+    super(message, { status: 401, code: "AUTHENTICATION_FAILED", details });
+    this.name = "VZapsAuthenticationError";
+  }
+};
+var VZapsTimeoutError = class extends VZapsError {
+  constructor(message = "VZaps request timed out") {
+    super(message, { code: "REQUEST_TIMEOUT" });
+    this.name = "VZapsTimeoutError";
+  }
+};
+
+// src/casing.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toSnakeCaseKey(key) {
+  return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").toLowerCase();
+}
+function toCamelCaseKey(key) {
+  return key.replace(/_([a-z0-9])/g, (_, char) => char.toUpperCase());
+}
+function keysToSnakeCase(value) {
+  return transformKeys(value, toSnakeCaseKey);
+}
+function keysToCamelCase(value) {
+  return transformKeys(value, toCamelCaseKey);
+}
+function transformKeys(value, transformKey) {
+  if (Array.isArray(value)) {
+    return value.map((item) => transformKeys(item, transformKey));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const result = {};
+  for (const [key, nested] of Object.entries(value)) {
+    result[transformKey(key)] = transformKeys(nested, transformKey);
+  }
+  return result;
+}
+
+// src/http.ts
+var DEFAULT_BASE_URL = "https://api.vzaps.com";
+var DEFAULT_REALTIME_URL = "wss://realtime.vzaps.com";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_TOKEN_SKEW_MS = 6e4;
+var HttpClient = class {
+  baseUrl;
+  realtimeUrl;
+  clientToken;
+  clientSecret;
+  fetchImpl;
+  timeoutMs;
+  tokenSkewMs;
+  userAgent;
+  cachedToken;
+  pendingToken;
+  constructor(options) {
+    this.clientToken = requireNonEmpty(options.clientToken, "clientToken");
+    this.clientSecret = requireNonEmpty(options.clientSecret, "clientSecret");
+    this.baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+    this.realtimeUrl = normalizeBaseUrl(options.realtimeUrl ?? DEFAULT_REALTIME_URL);
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.tokenSkewMs = options.tokenSkewMs ?? DEFAULT_TOKEN_SKEW_MS;
+    this.userAgent = options.userAgent;
+    this.fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!this.fetchImpl) {
+      throw new VZapsError("No fetch implementation available. Use Node.js 18+ or pass options.fetch.");
+    }
+  }
+  async getAccessToken(signal) {
+    if (this.cachedToken && this.cachedToken.expiresAt > Date.now()) {
+      return this.cachedToken.accessToken;
+    }
+    this.pendingToken ??= this.requestToken(signal).finally(() => {
+      this.pendingToken = void 0;
+    });
+    return this.pendingToken;
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    const headers = new Headers();
+    headers.set("Accept", "application/json");
+    if (options.body !== void 0) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (this.userAgent) {
+      headers.set("User-Agent", this.userAgent);
+    }
+    for (const [key, value] of Object.entries(options.headers ?? {})) {
+      if (value !== void 0) {
+        headers.set(key, value);
+      }
+    }
+    if (options.auth !== false) {
+      headers.set("Authorization", `Bearer ${await this.getAccessToken(options.signal)}`);
+      headers.set("X-Client-Token", this.clientToken);
+    }
+    if (options.instanceToken) {
+      headers.set("X-Instance-Token", options.instanceToken);
+    }
+    const body = options.body === void 0 ? void 0 : JSON.stringify(keysToSnakeCase(options.body));
+    const response = await this.fetchWithTimeout(url, {
+      method,
+      headers,
+      body,
+      signal: options.signal
+    });
+    return parseResponse(response);
+  }
+  buildRealtimeUrl(path, query) {
+    return buildUrl(this.realtimeUrl, path, query);
+  }
+  async requestToken(signal) {
+    const response = await this.request("POST", "/token", {
+      auth: false,
+      signal,
+      body: {
+        clientToken: this.clientToken,
+        clientSecret: this.clientSecret
+      }
+    });
+    if (!response.accessToken || !response.expiresIn) {
+      throw new VZapsAuthenticationError("VZaps token response is missing accessToken or expiresIn", response);
+    }
+    this.cachedToken = {
+      accessToken: response.accessToken,
+      expiresAt: Date.now() + response.expiresIn * 1e3 - this.tokenSkewMs
+    };
+    return response.accessToken;
+  }
+  buildUrl(path, query) {
+    return buildUrl(this.baseUrl, path, query);
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const signal = mergeSignals(controller.signal, init.signal ?? void 0);
+    try {
+      return await this.fetchImpl(url, { ...init, signal });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new VZapsTimeoutError();
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+function requireNonEmpty(value, name) {
+  if (!value || value.trim() === "") {
+    throw new VZapsError(`VZaps ${name} is required`);
+  }
+  return value;
+}
+function normalizeBaseUrl(value) {
+  return value.replace(/\/+$/, "");
+}
+function buildUrl(baseUrl, path, query) {
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${normalizeBaseUrl(baseUrl)}${cleanPath}`);
+  for (const [key, value] of Object.entries(query ?? {})) {
+    if (value !== void 0) {
+      url.searchParams.set(toSnakeCaseKey(key), String(value));
+    }
+  }
+  return url.toString();
+}
+async function parseResponse(response) {
+  const text = await response.text();
+  const data = text ? safeJsonParse(text) : void 0;
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new VZapsAuthenticationError(readErrorMessage(data, response.statusText), data);
+    }
+    throw new VZapsError(readErrorMessage(data, response.statusText), {
+      status: response.status,
+      details: data
+    });
+  }
+  return keysToCamelCase(data);
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function readErrorMessage(data, fallback) {
+  if (isRecord2(data)) {
+    if (typeof data.error === "string") return data.error;
+    if (typeof data.message === "string") return data.message;
+  }
+  return fallback || "VZaps request failed";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function mergeSignals(primary, secondary) {
+  if (!secondary) {
+    return primary;
+  }
+  if (secondary.aborted) {
+    return secondary;
+  }
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  primary.addEventListener("abort", abort, { once: true });
+  secondary.addEventListener("abort", abort, { once: true });
+  return controller.signal;
+}
+
+// src/resources.ts
+var AuthResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  getAccessToken(signal) {
+    return this.http.getAccessToken(signal);
+  }
+};
+var InstancesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  create(data, options = {}) {
+    return this.http.request("PUT", "/instances/create", {
+      body: data,
+      signal: options.signal
+    });
+  }
+  list(data = {}, options = {}) {
+    return this.http.request("POST", "/instances/list", {
+      body: data,
+      signal: options.signal
+    });
+  }
+  get(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  update(instanceId, data, options = {}) {
+    return this.http.request("PATCH", `/instances/${encodeURIComponent(instanceId)}`, {
+      body: data,
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  restart(instanceId, options = {}) {
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/restart`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  delete(instanceId, options = {}) {
+    return this.http.request("DELETE", `/instances/${encodeURIComponent(instanceId)}`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  provision(data, options = {}) {
+    return this.http.request("PUT", "/instances/provision", {
+      body: data,
+      signal: options.signal
+    });
+  }
+  search(data, options = {}) {
+    return this.http.request("POST", "/instances/search", {
+      body: data,
+      signal: options.signal
+    });
+  }
+  subscribe(instanceId, data = {}, options = {}) {
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/subscribe`, {
+      body: data,
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  resumeSubscription(instanceId, options = {}) {
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/resume-subscription`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  cancel(instanceId, options = {}) {
+    return this.http.request("PUT", `/instances/${encodeURIComponent(instanceId)}/cancel`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+};
+var MessagesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  sendText(request, options = {}) {
+    return this.post("/chat/send/text", request, options);
+  }
+  sendImage(request, options = {}) {
+    return this.post("/chat/send/image", request, options);
+  }
+  sendAudio(request, options = {}) {
+    return this.post("/chat/send/audio", request, options);
+  }
+  sendDocument(request, options = {}) {
+    return this.post("/chat/send/document", request, options);
+  }
+  sendVideo(request, options = {}) {
+    return this.post("/chat/send/video", request, options);
+  }
+  sendSticker(request, options = {}) {
+    return this.post("/chat/send/sticker", request, options);
+  }
+  sendGif(request, options = {}) {
+    return this.post("/chat/send/gif", request, options);
+  }
+  sendLocation(request, options = {}) {
+    return this.post("/chat/send/location", request, options);
+  }
+  sendContact(request, options = {}) {
+    return this.post("/chat/send/contact", request, options);
+  }
+  sendButtons(request, options = {}) {
+    return this.post("/chat/send/buttons", request, options);
+  }
+  sendList(request, options = {}) {
+    return this.post("/chat/send/list", request, options);
+  }
+  sendLink(request, options = {}) {
+    return this.post("/chat/send/link", request, options);
+  }
+  sendPoll(request, options = {}) {
+    return this.post("/chat/send/poll", request, options);
+  }
+  pollVote(request, options = {}) {
+    return this.post("/chat/poll/vote", request, options);
+  }
+  react(request, options = {}) {
+    return this.post("/chat/react", request, options);
+  }
+  removeReaction(request, options = {}) {
+    return this.sendRequest("DELETE", "/chat/react", request, options);
+  }
+  presence(request, options = {}) {
+    return this.post("/chat/presence", request, options);
+  }
+  markRead(request, options = {}) {
+    return this.post("/chat/markread", request, options);
+  }
+  downloadImage(request, options = {}) {
+    return this.post("/chat/downloadimage", request, options);
+  }
+  downloadVideo(request, options = {}) {
+    return this.post("/chat/downloadvideo", request, options);
+  }
+  downloadAudio(request, options = {}) {
+    return this.post("/chat/downloadaudio", request, options);
+  }
+  downloadDocument(request, options = {}) {
+    return this.post("/chat/downloaddocument", request, options);
+  }
+  edit(request, options = {}) {
+    const { messageId, ...rest } = request;
+    return this.sendRequest("PATCH", `/chat/messages/${encodeURIComponent(messageId)}`, rest, options);
+  }
+  delete(request, options = {}) {
+    const { messageId, ...rest } = request;
+    return this.sendRequest("DELETE", `/chat/messages/${encodeURIComponent(messageId)}`, rest, options);
+  }
+  send(instanceId, path, body, options = {}) {
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/chat/${path.replace(/^\/+/, "")}`, {
+      body,
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  post(path, request, options) {
+    return this.sendRequest("POST", path, request, options);
+  }
+  sendRequest(method, path, request, options) {
+    const { instanceId, instanceToken, ...body } = request;
+    return this.http.request(method, `/instances/${encodeURIComponent(instanceId)}${path}`, {
+      body,
+      signal: options.signal,
+      instanceToken
+    });
+  }
+};
+var WebhooksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  get(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/webhook`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  set(request, options = {}) {
+    const { instanceId, instanceToken, ...body } = request;
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/webhook`, {
+      body,
+      signal: options.signal,
+      instanceToken
+    });
+  }
+  searchLogs(request, options = {}) {
+    const { instanceId, instanceToken, ...body } = request;
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/webhook/logs/search`, {
+      body,
+      signal: options.signal,
+      instanceToken
+    });
+  }
+  getLog(request, options = {}) {
+    return this.http.request(
+      "GET",
+      `/instances/${encodeURIComponent(request.instanceId)}/webhook/logs/${encodeURIComponent(request.logId)}`,
+      {
+        signal: options.signal,
+        instanceToken: request.instanceToken
+      }
+    );
+  }
+  retryLog(request, options = {}) {
+    return this.http.request(
+      "POST",
+      `/instances/${encodeURIComponent(request.instanceId)}/webhook/logs/${encodeURIComponent(request.logId)}/retry`,
+      {
+        signal: options.signal,
+        instanceToken: request.instanceToken
+      }
+    );
+  }
+};
+var ContactsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/contact/list`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  add(request, options = {}) {
+    const { instanceId, instanceToken, ...body } = request;
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/contact/add`, {
+      body,
+      signal: options.signal,
+      instanceToken
+    });
+  }
+};
+var GroupsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(request, options = {}) {
+    const { instanceId, instanceToken, page, pageSize } = request;
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/group/list`, {
+      query: { page, pageSize },
+      signal: options.signal,
+      instanceToken
+    });
+  }
+  get(request, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(request.instanceId)}/group/info`, {
+      query: { groupId: request.groupId },
+      signal: options.signal,
+      instanceToken: request.instanceToken
+    });
+  }
+  inviteLink(request, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(request.instanceId)}/group/invitelink`, {
+      query: { groupId: request.groupId, reset: request.reset },
+      signal: options.signal,
+      instanceToken: request.instanceToken
+    });
+  }
+  setPhoto(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/photo", options);
+  }
+  setName(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/name", options);
+  }
+  setDescription(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/description", options);
+  }
+  setSettings(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/settings", options);
+  }
+  create(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/create", options);
+  }
+  addAdmin(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/add-admin", options);
+  }
+  removeAdmin(request, options = {}) {
+    return postInstancePath(this.http, request, "/group/remove-admin", options);
+  }
+};
+var SessionsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  status(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/session/status`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  qr(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/session/qr`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  pairCode(instanceId, phone, options = {}) {
+    return this.http.request(
+      "GET",
+      `/instances/${encodeURIComponent(instanceId)}/session/paircode/${encodeURIComponent(phone)}`,
+      {
+        signal: options.signal,
+        instanceToken: options.instanceToken
+      }
+    );
+  }
+  disconnect(instanceId, options = {}) {
+    return this.http.request("POST", `/instances/${encodeURIComponent(instanceId)}/session/disconnect`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+};
+var UsersResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  info(request, options = {}) {
+    return postInstancePath(this.http, request, "/user/info", options);
+  }
+  check(request, options = {}) {
+    return postInstancePath(this.http, request, "/user/check", options);
+  }
+  avatar(request, options = {}) {
+    return postInstancePath(this.http, request, "/user/avatar", options);
+  }
+  contacts(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/user/contacts`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+};
+var QueuesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  listMessages(request, options = {}) {
+    return getInstancePath(this.http, request, "/queue/messages", options);
+  }
+  purgeMessages(request, options = {}) {
+    return deleteInstancePath(this.http, request, "/queue/messages", options);
+  }
+  removeMessage(request, options = {}) {
+    const { messageId, ...rest } = request;
+    return deleteInstancePath(this.http, rest, `/queue/messages/${encodeURIComponent(messageId)}`, options);
+  }
+  listOperations(request, options = {}) {
+    return getInstancePath(this.http, request, "/queue/operations", options);
+  }
+  purgeOperations(request, options = {}) {
+    return deleteInstancePath(this.http, request, "/queue/operations", options);
+  }
+  removeOperation(request, options = {}) {
+    const { messageId, ...rest } = request;
+    return deleteInstancePath(this.http, rest, `/queue/operations/${encodeURIComponent(messageId)}`, options);
+  }
+};
+var TypebotsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/typebots`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  create(request, options = {}) {
+    return postInstancePath(this.http, request, "/typebots", options);
+  }
+  update(request, options = {}) {
+    const { typebotId, ...rest } = request;
+    return requestInstancePath(this.http, "PATCH", rest, `/typebots/${encodeURIComponent(typebotId)}`, options);
+  }
+  delete(request, options = {}) {
+    const { typebotId, ...rest } = request;
+    return deleteInstancePath(this.http, rest, `/typebots/${encodeURIComponent(typebotId)}`, options);
+  }
+  listSessions(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/typebots/sessions`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  startSession(request, options = {}) {
+    const { typebotId, ...rest } = request;
+    const path = typebotId ? `/typebots/${encodeURIComponent(typebotId)}/sessions/start` : "/typebots/sessions/start";
+    return postInstancePath(this.http, rest, path, options);
+  }
+  closeSession(request, options = {}) {
+    const { session, ...rest } = request;
+    return postInstancePath(this.http, rest, `/typebots/sessions/${encodeURIComponent(session)}/close`, options);
+  }
+  pauseSession(request, options = {}) {
+    const { session, ...rest } = request;
+    return postInstancePath(this.http, rest, `/typebots/sessions/${encodeURIComponent(session)}/pause`, options);
+  }
+};
+var ChatwootResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  get(instanceId, options = {}) {
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/chatwoot`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  set(request, options = {}) {
+    return postInstancePath(this.http, request, "/chatwoot", options);
+  }
+  delete(instanceId, options = {}) {
+    return this.http.request("DELETE", `/instances/${encodeURIComponent(instanceId)}/chatwoot`, {
+      signal: options.signal,
+      instanceToken: options.instanceToken
+    });
+  }
+  triggerImport(request, options = {}) {
+    const { what, ...rest } = request;
+    return postInstancePath(this.http, rest, `/chatwoot/import/${encodeURIComponent(what)}`, options);
+  }
+};
+var ChatsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  list(request, options = {}) {
+    const { instanceId, instanceToken, page, pageSize } = request;
+    return this.http.request("GET", `/instances/${encodeURIComponent(instanceId)}/chats`, {
+      query: { page, pageSize },
+      signal: options.signal,
+      instanceToken
+    });
+  }
+  get(request, options = {}) {
+    return this.chatAction("GET", request, "", options);
+  }
+  archive(request, options = {}) {
+    return this.chatAction("POST", request, "/archive", options);
+  }
+  unarchive(request, options = {}) {
+    return this.chatAction("POST", request, "/unarchive", options);
+  }
+  mute(request, options = {}) {
+    return this.chatAction("POST", request, "/mute", options);
+  }
+  unmute(request, options = {}) {
+    return this.chatAction("POST", request, "/unmute", options);
+  }
+  pin(request, options = {}) {
+    return this.chatAction("POST", request, "/pin", options);
+  }
+  unpin(request, options = {}) {
+    return this.chatAction("POST", request, "/unpin", options);
+  }
+  read(request, options = {}) {
+    return this.chatAction("POST", request, "/read", options);
+  }
+  unread(request, options = {}) {
+    return this.chatAction("POST", request, "/unread", options);
+  }
+  clear(request, options = {}) {
+    return this.chatAction("POST", request, "/clear", options);
+  }
+  delete(request, options = {}) {
+    return this.chatAction("DELETE", request, "", options);
+  }
+  setExpiration(request, options = {}) {
+    return this.chatAction("PUT", request, "/expiration", options);
+  }
+  chatAction(method, request, suffix, options) {
+    const { instanceId, instanceToken, phone, ...body } = request;
+    return this.http.request(method, `/instances/${encodeURIComponent(instanceId)}/chats/${encodeURIComponent(phone)}${suffix}`, {
+      body: Object.keys(body).length > 0 ? body : void 0,
+      signal: options.signal,
+      instanceToken
+    });
+  }
+};
+function getInstancePath(http, request, path, options) {
+  return requestInstancePath(http, "GET", request, path, options);
+}
+function postInstancePath(http, request, path, options) {
+  return requestInstancePath(http, "POST", request, path, options);
+}
+function deleteInstancePath(http, request, path, options) {
+  return requestInstancePath(http, "DELETE", request, path, options);
+}
+function requestInstancePath(http, method, request, path, options) {
+  const { instanceId, instanceToken, ...body } = request;
+  return http.request(method, `/instances/${encodeURIComponent(instanceId)}${path}`, {
+    body: Object.keys(body).length > 0 ? body : void 0,
+    signal: options.signal,
+    instanceToken
+  });
+}
+
+// src/client.ts
+var VZapsClient = class {
+  auth;
+  instances;
+  sessions;
+  messages;
+  webhooks;
+  contacts;
+  groups;
+  users;
+  queues;
+  typebots;
+  chatwoot;
+  chats;
+  events;
+  http;
+  constructor(options) {
+    this.http = new HttpClient(options);
+    this.auth = new AuthResource(this.http);
+    this.instances = new InstancesResource(this.http);
+    this.sessions = new SessionsResource(this.http);
+    this.messages = new MessagesResource(this.http);
+    this.webhooks = new WebhooksResource(this.http);
+    this.contacts = new ContactsResource(this.http);
+    this.groups = new GroupsResource(this.http);
+    this.users = new UsersResource(this.http);
+    this.queues = new QueuesResource(this.http);
+    this.typebots = new TypebotsResource(this.http);
+    this.chatwoot = new ChatwootResource(this.http);
+    this.chats = new ChatsResource(this.http);
+    this.events = new EventsResource(this.http, options.webSocketFactory);
+  }
+  request(method, path, options = {}) {
+    return this.http.request(method, path, options);
+  }
+};
+export {
+  AuthResource,
+  ChatsResource,
+  ChatwootResource,
+  ContactsResource,
+  EventSubscription,
+  EventsResource,
+  GroupsResource,
+  InstancesResource,
+  MessagesResource,
+  QueuesResource,
+  SessionsResource,
+  TypebotsResource,
+  UsersResource,
+  VZapsAuthenticationError,
+  VZapsClient,
+  VZapsError,
+  VZapsTimeoutError,
+  WebhooksResource
+};
+//# sourceMappingURL=index.js.map