@wazzapi/wazzapi 0.2.0

package/dist/index.js

@@ -0,0 +1,1461 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/errors.ts
+var WazzapiError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WazzapiError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WazzapiAPIError = class _WazzapiAPIError extends WazzapiError {
+  constructor(statusCode, message, options) {
+    super(`WazzAPI API error ${statusCode}: ${message}`);
+    this.name = "WazzapiAPIError";
+    this.statusCode = statusCode;
+    this.message = message;
+    this.details = options?.details;
+    this.responseText = options?.responseText;
+  }
+  static fromResponseParts(statusCode, reasonPhrase, responseText, payload) {
+    let details;
+    let message = reasonPhrase || "Request failed";
+    if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+      const normalizedPayload = payload;
+      details = normalizedPayload.detail === void 0 ? payload : normalizedPayload.detail;
+      if (typeof details === "string") {
+        message = details;
+      } else if (Array.isArray(details) && details.length > 0) {
+        const firstItem = details[0];
+        if (firstItem && typeof firstItem === "object" && "msg" in firstItem && typeof firstItem.msg === "string") {
+          message = firstItem.msg;
+        } else {
+          message = formatErrorMessage(firstItem);
+        }
+      } else if (normalizedPayload.message !== void 0) {
+        message = formatErrorMessage(normalizedPayload.message);
+      }
+    } else if (payload !== void 0) {
+      details = payload;
+      message = formatErrorMessage(payload);
+    }
+    return new _WazzapiAPIError(statusCode, message, {
+      details,
+      responseText
+    });
+  }
+};
+function formatErrorMessage(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0 || value === null) {
+    return "Request failed";
+  }
+  try {
+    const serialized = JSON.stringify(value);
+    return serialized ?? "Request failed";
+  } catch {
+    return "Request failed";
+  }
+}
+var WazzapiMediaError = class extends WazzapiError {
+  constructor(message) {
+    super(message);
+    this.name = "WazzapiMediaError";
+  }
+};
+
+// src/models/base.ts
+function cloneObject(input) {
+  if (!input || typeof input !== "object") {
+    return {};
+  }
+  const output = {};
+  Object.entries(input).forEach(([key, value]) => {
+    output[key] = value;
+  });
+  return output;
+}
+function withDateFields(input, fields) {
+  const output = cloneObject(input);
+  const mutableOutput = output;
+  fields.forEach((field) => {
+    if (mutableOutput[field] !== void 0 && mutableOutput[field] !== null) {
+      mutableOutput[field] = new Date(
+        mutableOutput[field]
+      );
+    }
+  });
+  return output;
+}
+function mapArray(value, parser) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((item) => parser(item));
+}
+function serializeData(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeData(item)).filter((item) => item !== void 0);
+  }
+  if (typeof value === "object") {
+    const output = {};
+    Object.entries(value).forEach(([key, rawValue]) => {
+      const serialized = serializeData(rawValue);
+      if (serialized !== void 0) {
+        output[key] = serialized;
+      }
+    });
+    return output;
+  }
+  return value;
+}
+function filterNone(data) {
+  if (!data) {
+    return void 0;
+  }
+  const output = {};
+  Object.entries(data).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) {
+      output[key] = value;
+    }
+  });
+  return output;
+}
+
+// src/resources/base.ts
+var BaseResource = class {
+  constructor(client) {
+    this._client = client;
+  }
+};
+
+// src/models/index.ts
+var models_exports = {};
+__export(models_exports, {
+  parseAddToGroupResponse: () => parseAddToGroupResponse,
+  parseBuiltinVariableInfo: () => parseBuiltinVariableInfo,
+  parseBuiltinVariablesResponse: () => parseBuiltinVariablesResponse,
+  parseBulkDeleteResponse: () => parseBulkDeleteResponse,
+  parseCSVExportResponse: () => parseCSVExportResponse,
+  parseCSVImportResponse: () => parseCSVImportResponse,
+  parseCancelMessageResponse: () => parseCancelMessageResponse,
+  parseContactGroupItem: () => parseContactGroupItem,
+  parseContactGroupListResponse: () => parseContactGroupListResponse,
+  parseContactGroupMembersResponse: () => parseContactGroupMembersResponse,
+  parseContactItem: () => parseContactItem,
+  parseContactListResponse: () => parseContactListResponse,
+  parseContactResponse: () => parseContactResponse,
+  parseContactSyncHistoryItem: () => parseContactSyncHistoryItem,
+  parseContactSyncHistoryResponse: () => parseContactSyncHistoryResponse,
+  parseContactSyncResponse: () => parseContactSyncResponse,
+  parseContactSyncStatusResponse: () => parseContactSyncStatusResponse,
+  parseContactSyncStatusResponseList: () => parseContactSyncStatusResponseList,
+  parseCreateGroupResponseModel: () => parseCreateGroupResponseModel,
+  parseGroupDetailResponse: () => parseGroupDetailResponse,
+  parseGroupInviteInfoResponseModel: () => parseGroupInviteInfoResponseModel,
+  parseGroupInviteLinkResponseModel: () => parseGroupInviteLinkResponseModel,
+  parseGroupListItem: () => parseGroupListItem,
+  parseGroupListResponse: () => parseGroupListResponse,
+  parseGroupOperationResponseModel: () => parseGroupOperationResponseModel,
+  parseGroupParticipantItem: () => parseGroupParticipantItem,
+  parseGroupParticipantsResponse: () => parseGroupParticipantsResponse,
+  parseInteractiveButton: () => parseInteractiveButton,
+  parseInteractiveMessageResponse: () => parseInteractiveMessageResponse,
+  parseInteractiveRow: () => parseInteractiveRow,
+  parseInteractiveSection: () => parseInteractiveSection,
+  parseMediaDownloadResult: () => parseMediaDownloadResult,
+  parseMessageItem: () => parseMessageItem,
+  parseMessageListResponse: () => parseMessageListResponse,
+  parseMessageResponse: () => parseMessageResponse,
+  parseMessageStatsResponse: () => parseMessageStatsResponse,
+  parsePublicDeviceWebhook: () => parsePublicDeviceWebhook,
+  parsePublicMessageWebhook: () => parsePublicMessageWebhook,
+  parsePublicWebhookDeviceData: () => parsePublicWebhookDeviceData,
+  parsePublicWebhookMessageData: () => parsePublicWebhookMessageData,
+  parseRetryMessageResponse: () => parseRetryMessageResponse,
+  parseSendGroupResponse: () => parseSendGroupResponse,
+  parseSendMessageResponse: () => parseSendMessageResponse,
+  parseTemplateItem: () => parseTemplateItem,
+  parseTemplateListResponse: () => parseTemplateListResponse,
+  parseTemplatePreviewResponse: () => parseTemplatePreviewResponse,
+  parseTemplateResponse: () => parseTemplateResponse,
+  parseWebhookPayload: () => parseWebhookPayload
+});
+
+// src/models/contacts.ts
+function parseAddToGroupResponse(input) {
+  return cloneObject(input);
+}
+function parseBulkDeleteResponse(input) {
+  return cloneObject(input);
+}
+function parseCSVExportResponse(input) {
+  return cloneObject(input);
+}
+function parseCSVImportResponse(input) {
+  const output = cloneObject(input);
+  if (!Array.isArray(output.errors)) {
+    output.errors = [];
+  }
+  return output;
+}
+function parseContactGroupItem(input) {
+  return withDateFields(input, ["created_at"]);
+}
+function parseContactGroupListResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.groups = mapArray(typedInput?.groups, parseContactGroupItem);
+  return output;
+}
+function parseContactItem(input) {
+  const output = withDateFields(input, [
+    "last_message_at",
+    "created_at"
+  ]);
+  if (!Array.isArray(output.tags)) {
+    output.tags = [];
+  }
+  return output;
+}
+function parseContactGroupMembersResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.group = parseContactGroupItem(typedInput?.group);
+  output.contacts = mapArray(typedInput?.contacts, parseContactItem);
+  return output;
+}
+function parseContactListResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.contacts = mapArray(typedInput?.contacts, parseContactItem);
+  return output;
+}
+function parseContactResponse(input) {
+  const output = withDateFields(input, [
+    "opted_out_at",
+    "last_message_at",
+    "created_at",
+    "updated_at"
+  ]);
+  if (!Array.isArray(output.tags)) {
+    output.tags = [];
+  }
+  return output;
+}
+function parseContactSyncHistoryItem(input) {
+  return withDateFields(input, [
+    "started_at",
+    "completed_at"
+  ]);
+}
+function parseContactSyncHistoryResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.history = mapArray(typedInput?.history, parseContactSyncHistoryItem);
+  return output;
+}
+function parseContactSyncResponse(input) {
+  return cloneObject(input);
+}
+function parseContactSyncStatusResponse(input) {
+  return withDateFields(input, ["last_sync_at"]);
+}
+function parseContactSyncStatusResponseList(input) {
+  return mapArray(input, parseContactSyncStatusResponse);
+}
+
+// src/models/groups.ts
+function parseGroupListItem(input) {
+  const output = cloneObject(input);
+  output.participants_count ?? (output.participants_count = 0);
+  return output;
+}
+function parseGroupListResponse(input) {
+  const output = cloneObject(input);
+  output.groups = mapArray(
+    input?.groups,
+    parseGroupListItem
+  );
+  return output;
+}
+function parseGroupDetailResponse(input) {
+  const output = cloneObject(input);
+  output.participants_count ?? (output.participants_count = 0);
+  return output;
+}
+function parseGroupParticipantItem(input) {
+  const output = cloneObject(input);
+  output.is_admin ?? (output.is_admin = false);
+  output.is_super_admin ?? (output.is_super_admin = false);
+  return output;
+}
+function parseGroupParticipantsResponse(input) {
+  const output = cloneObject(input);
+  output.participants = mapArray(
+    input?.participants,
+    parseGroupParticipantItem
+  );
+  return output;
+}
+function parseGroupOperationResponseModel(input) {
+  return cloneObject(input);
+}
+function parseCreateGroupResponseModel(input) {
+  return cloneObject(input);
+}
+function parseSendGroupResponse(input) {
+  return cloneObject(input);
+}
+function parseGroupInviteLinkResponseModel(input) {
+  return cloneObject(input);
+}
+function parseGroupInviteInfoResponseModel(input) {
+  const output = cloneObject(input);
+  output.participants ?? (output.participants = 0);
+  return output;
+}
+
+// src/models/media.ts
+function parseMediaDownloadResult(input) {
+  return cloneObject(input);
+}
+
+// src/models/messages.ts
+function parseInteractiveButton(input) {
+  return cloneObject(input);
+}
+function parseCancelMessageResponse(input) {
+  return cloneObject(input);
+}
+function parseInteractiveMessageResponse(input) {
+  return cloneObject(input);
+}
+function parseInteractiveRow(input) {
+  return cloneObject(input);
+}
+function parseInteractiveSection(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.rows = mapArray(typedInput?.rows, parseInteractiveRow);
+  return output;
+}
+function parseMessageItem(input) {
+  const output = withDateFields(input, [
+    "scheduled_for",
+    "created_at",
+    "sent_at",
+    "delivered_at",
+    "read_at"
+  ]);
+  output.message_type ?? (output.message_type = "text");
+  return output;
+}
+function parseMessageListResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.messages = mapArray(typedInput?.messages, parseMessageItem);
+  return output;
+}
+function parseMessageResponse(input) {
+  const output = withDateFields(input, [
+    "scheduled_for",
+    "queued_at",
+    "sent_at",
+    "delivered_at",
+    "read_at",
+    "failed_at",
+    "created_at",
+    "updated_at"
+  ]);
+  output.message_type ?? (output.message_type = "text");
+  return output;
+}
+function parseMessageStatsResponse(input) {
+  return cloneObject(input);
+}
+function parseRetryMessageResponse(input) {
+  return cloneObject(input);
+}
+function parseSendMessageResponse(input) {
+  return cloneObject(input);
+}
+
+// src/models/templates.ts
+function parseBuiltinVariableInfo(input) {
+  return cloneObject(input);
+}
+function parseBuiltinVariablesResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.variables = mapArray(typedInput?.variables, parseBuiltinVariableInfo);
+  return output;
+}
+function parseTemplateItem(input) {
+  const output = withDateFields(input, [
+    "last_used_at",
+    "created_at"
+  ]);
+  if (!Array.isArray(output.variables)) {
+    output.variables = [];
+  }
+  if (!Array.isArray(output.builtin_variables)) {
+    output.builtin_variables = [];
+  }
+  if (!Array.isArray(output.custom_variables)) {
+    output.custom_variables = [];
+  }
+  return output;
+}
+function parseTemplateListResponse(input) {
+  const output = cloneObject(input);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.data = mapArray(typedInput?.data, parseTemplateItem);
+  return output;
+}
+function parseTemplatePreviewResponse(input) {
+  const output = cloneObject(input);
+  if (!Array.isArray(output.all_variables)) {
+    output.all_variables = [];
+  }
+  if (!Array.isArray(output.builtin_variables)) {
+    output.builtin_variables = [];
+  }
+  if (!Array.isArray(output.custom_variables)) {
+    output.custom_variables = [];
+  }
+  if (!Array.isArray(output.missing_variables)) {
+    output.missing_variables = [];
+  }
+  return output;
+}
+function parseTemplateResponse(input) {
+  const output = withDateFields(input, [
+    "last_used_at",
+    "created_at",
+    "updated_at"
+  ]);
+  if (!Array.isArray(output.variables)) {
+    output.variables = [];
+  }
+  if (!Array.isArray(output.builtin_variables)) {
+    output.builtin_variables = [];
+  }
+  if (!Array.isArray(output.custom_variables)) {
+    output.custom_variables = [];
+  }
+  return output;
+}
+
+// src/models/webhooks.ts
+function parsePublicWebhookMessageData(input) {
+  return withDateFields(input, [
+    "sent_at",
+    "delivered_at",
+    "read_at",
+    "failed_at"
+  ]);
+}
+function parsePublicWebhookDeviceData(input) {
+  return withDateFields(input, [
+    "sent_at",
+    "delivered_at",
+    "read_at",
+    "failed_at"
+  ]);
+}
+function parsePublicMessageWebhook(input) {
+  const output = withDateFields(input, ["timestamp"]);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.data = parsePublicWebhookMessageData(typedInput?.data);
+  return output;
+}
+function parsePublicDeviceWebhook(input) {
+  const output = withDateFields(input, ["timestamp"]);
+  const typedInput = typeof input === "object" && input ? input : void 0;
+  output.data = parsePublicWebhookDeviceData(typedInput?.data);
+  return output;
+}
+function parseWebhookPayload(input) {
+  const output = cloneObject(input);
+  if (typeof output.event_type !== "string") {
+    const error = new TypeError("Webhook payload is missing event_type");
+    throw error;
+  }
+  if (output.event_type.startsWith("message.")) {
+    return parsePublicMessageWebhook(output);
+  }
+  if (output.event_type.startsWith("device.")) {
+    return parsePublicDeviceWebhook(output);
+  }
+  throw new TypeError(`Unsupported webhook event type: ${output.event_type}`);
+}
+
+// src/resources/contacts.ts
+var ContactsResource = class extends BaseResource {
+  async list(options) {
+    return this._client._request("GET", "/api/v1/contacts", {
+      params: options,
+      responseParser: parseContactListResponse
+    });
+  }
+  async create(payload) {
+    return this._client._request("POST", "/api/v1/contacts", {
+      jsonBody: payload,
+      responseParser: parseContactResponse
+    });
+  }
+  async bulkDelete(payload) {
+    return this._client._request("POST", "/api/v1/contacts/bulk-delete", {
+      jsonBody: payload,
+      responseParser: parseBulkDeleteResponse
+    });
+  }
+  async bulk_delete(payload) {
+    return this.bulkDelete(payload);
+  }
+  async listGroups(options) {
+    return this._client._request("GET", "/api/v1/contacts/groups", {
+      params: options,
+      responseParser: parseContactGroupListResponse
+    });
+  }
+  async list_groups(options) {
+    return this.listGroups(options);
+  }
+  async createGroup(payload) {
+    return this._client._request("POST", "/api/v1/contacts/groups", {
+      jsonBody: payload,
+      responseParser: parseContactGroupItem
+    });
+  }
+  async create_group(payload) {
+    return this.createGroup(payload);
+  }
+  async getGroup(groupId, options) {
+    return this._client._request("GET", `/api/v1/contacts/groups/${groupId}`, {
+      params: options,
+      responseParser: parseContactGroupMembersResponse
+    });
+  }
+  async get_group(groupId, options) {
+    return this.getGroup(groupId, options);
+  }
+  async updateGroup(groupId, payload) {
+    return this._client._request(
+      "PATCH",
+      `/api/v1/contacts/groups/${groupId}`,
+      {
+        jsonBody: payload,
+        responseParser: parseContactGroupItem
+      }
+    );
+  }
+  async update_group(groupId, payload) {
+    return this.updateGroup(groupId, payload);
+  }
+  async deleteGroup(groupId) {
+    await this._client._request("DELETE", `/api/v1/contacts/groups/${groupId}`);
+  }
+  async delete_group(groupId) {
+    return this.deleteGroup(groupId);
+  }
+  async addToGroup(groupId, payload) {
+    return this._client._request(
+      "POST",
+      `/api/v1/contacts/groups/${groupId}/members`,
+      {
+        jsonBody: payload,
+        responseParser: parseAddToGroupResponse
+      }
+    );
+  }
+  async add_to_group(groupId, payload) {
+    return this.addToGroup(groupId, payload);
+  }
+  async removeFromGroup(groupId, payload) {
+    return this._client._request(
+      "DELETE",
+      `/api/v1/contacts/groups/${groupId}/members`,
+      {
+        jsonBody: payload,
+        responseParser: parseAddToGroupResponse
+      }
+    );
+  }
+  async remove_from_group(groupId, payload) {
+    return this.removeFromGroup(groupId, payload);
+  }
+  async importCsv(payload) {
+    return this._client._request("POST", "/api/v1/contacts/import/csv", {
+      jsonBody: payload,
+      responseParser: parseCSVImportResponse
+    });
+  }
+  async import_csv(payload) {
+    return this.importCsv(payload);
+  }
+  async exportCsv(options) {
+    return this._client._request("GET", "/api/v1/contacts/export/csv", {
+      params: options,
+      responseParser: parseCSVExportResponse
+    });
+  }
+  async export_csv(options) {
+    return this.exportCsv(options);
+  }
+  async sync(payload) {
+    return this._client._request("POST", "/api/v1/contacts/sync", {
+      jsonBody: payload,
+      responseParser: parseContactSyncResponse
+    });
+  }
+  async syncStatus() {
+    return this._client._request("GET", "/api/v1/contacts/sync/status", {
+      responseParser: parseContactSyncStatusResponseList
+    });
+  }
+  async sync_status() {
+    return this.syncStatus();
+  }
+  async syncHistory(options) {
+    return this._client._request("GET", "/api/v1/contacts/sync/history", {
+      params: options,
+      responseParser: parseContactSyncHistoryResponse
+    });
+  }
+  async sync_history(options) {
+    return this.syncHistory(options);
+  }
+  async importTemplate() {
+    return this._client._request(
+      "GET",
+      "/api/v1/contacts/import/template"
+    );
+  }
+  async import_template() {
+    return this.importTemplate();
+  }
+  async get(contactId) {
+    return this._client._request("GET", `/api/v1/contacts/${contactId}`, {
+      responseParser: parseContactResponse
+    });
+  }
+  async update(contactId, payload) {
+    return this._client._request("PATCH", `/api/v1/contacts/${contactId}`, {
+      jsonBody: payload,
+      responseParser: parseContactResponse
+    });
+  }
+  async delete(contactId) {
+    await this._client._request("DELETE", `/api/v1/contacts/${contactId}`);
+  }
+};
+
+// src/resources/groups.ts
+var GroupsResource = class extends BaseResource {
+  async list(options) {
+    return this._client._request("GET", "/api/v1/groups", {
+      params: options,
+      responseParser: parseGroupListResponse
+    });
+  }
+  async get(groupJid, options) {
+    return this._client._request("GET", `/api/v1/groups/${groupJid}`, {
+      params: options,
+      responseParser: parseGroupDetailResponse
+    });
+  }
+  async getParticipants(groupJid, options) {
+    return this._client._request(
+      "GET",
+      `/api/v1/groups/${groupJid}/participants`,
+      {
+        params: options,
+        responseParser: parseGroupParticipantsResponse
+      }
+    );
+  }
+  async get_participants(groupJid, options) {
+    return this.getParticipants(groupJid, options);
+  }
+  async create(payload) {
+    return this._client._request("POST", "/api/v1/groups/create", {
+      jsonBody: payload,
+      responseParser: parseCreateGroupResponseModel
+    });
+  }
+  async sendText(payload) {
+    return this._client._request("POST", "/api/v1/groups/send", {
+      jsonBody: payload,
+      responseParser: parseSendGroupResponse
+    });
+  }
+  async send_text(payload) {
+    return this.sendText(payload);
+  }
+  async sendMedia(payload) {
+    return this._client._request("POST", "/api/v1/groups/send/media", {
+      jsonBody: payload,
+      responseParser: parseSendGroupResponse
+    });
+  }
+  async send_media(payload) {
+    return this.sendMedia(payload);
+  }
+  async updateParticipants(payload) {
+    return this._client._request("POST", "/api/v1/groups/participants", {
+      jsonBody: payload,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async update_participants(payload) {
+    return this.updateParticipants(payload);
+  }
+  async addParticipant(groupJid, options) {
+    return this._client._request(
+      "POST",
+      `/api/v1/groups/${groupJid}/participants/add`,
+      {
+        params: options,
+        responseParser: parseGroupOperationResponseModel
+      }
+    );
+  }
+  async add_participant(groupJid, options) {
+    return this.addParticipant(groupJid, options);
+  }
+  async removeParticipant(groupJid, options) {
+    return this._client._request(
+      "POST",
+      `/api/v1/groups/${groupJid}/participants/remove`,
+      {
+        params: options,
+        responseParser: parseGroupOperationResponseModel
+      }
+    );
+  }
+  async remove_participant(groupJid, options) {
+    return this.removeParticipant(groupJid, options);
+  }
+  async getInviteLink(groupJid, options) {
+    return this._client._request(
+      "POST",
+      `/api/v1/groups/${groupJid}/invite-link`,
+      {
+        params: options,
+        responseParser: parseGroupInviteLinkResponseModel
+      }
+    );
+  }
+  async get_invite_link(groupJid, options) {
+    return this.getInviteLink(groupJid, options);
+  }
+  async getInviteInfo(payload) {
+    return this._client._request("POST", "/api/v1/groups/invite-info", {
+      jsonBody: payload,
+      responseParser: parseGroupInviteInfoResponseModel
+    });
+  }
+  async get_invite_info(payload) {
+    return this.getInviteInfo(payload);
+  }
+  async join(payload) {
+    return this._client._request("POST", "/api/v1/groups/join", {
+      jsonBody: payload,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async leave(groupJid, options) {
+    return this._client._request("POST", `/api/v1/groups/${groupJid}/leave`, {
+      params: options,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async setName(groupJid, payload) {
+    return this._client._request("POST", `/api/v1/groups/${groupJid}/name`, {
+      jsonBody: payload,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async set_name(groupJid, payload) {
+    return this.setName(groupJid, payload);
+  }
+  async setTopic(groupJid, payload) {
+    return this._client._request("POST", `/api/v1/groups/${groupJid}/topic`, {
+      jsonBody: payload,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async set_topic(groupJid, payload) {
+    return this.setTopic(groupJid, payload);
+  }
+  async setPhoto(groupJid, payload) {
+    return this._client._request("POST", `/api/v1/groups/${groupJid}/photo`, {
+      jsonBody: payload,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async set_photo(groupJid, payload) {
+    return this.setPhoto(groupJid, payload);
+  }
+  async removePhoto(groupJid, options) {
+    return this._client._request("DELETE", `/api/v1/groups/${groupJid}/photo`, {
+      params: options,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async remove_photo(groupJid, options) {
+    return this.removePhoto(groupJid, options);
+  }
+  async setAnnounce(groupJid, payload) {
+    return this._client._request(
+      "POST",
+      `/api/v1/groups/${groupJid}/announce`,
+      {
+        jsonBody: payload,
+        responseParser: parseGroupOperationResponseModel
+      }
+    );
+  }
+  async set_announce(groupJid, payload) {
+    return this.setAnnounce(groupJid, payload);
+  }
+  async setLocked(groupJid, payload) {
+    return this._client._request("POST", `/api/v1/groups/${groupJid}/locked`, {
+      jsonBody: payload,
+      responseParser: parseGroupOperationResponseModel
+    });
+  }
+  async set_locked(groupJid, payload) {
+    return this.setLocked(groupJid, payload);
+  }
+  async setEphemeral(groupJid, payload) {
+    return this._client._request(
+      "POST",
+      `/api/v1/groups/${groupJid}/ephemeral`,
+      {
+        jsonBody: payload,
+        responseParser: parseGroupOperationResponseModel
+      }
+    );
+  }
+  async set_ephemeral(groupJid, payload) {
+    return this.setEphemeral(groupJid, payload);
+  }
+};
+
+// src/resources/messages.ts
+var MessagesResource = class extends BaseResource {
+  async lookup(whatsappMessageId) {
+    return this._client._request("GET", "/api/v1/messages/lookup", {
+      params: { whatsapp_message_id: whatsappMessageId },
+      responseParser: parseMessageResponse
+    });
+  }
+  async list(options) {
+    return this._client._request("GET", "/api/v1/messages", {
+      params: options,
+      responseParser: parseMessageListResponse
+    });
+  }
+  async get(messageId) {
+    return this._client._request("GET", `/api/v1/messages/${messageId}`, {
+      responseParser: parseMessageResponse
+    });
+  }
+  async stats() {
+    return this._client._request("GET", "/api/v1/messages/stats/summary", {
+      responseParser: parseMessageStatsResponse
+    });
+  }
+  async send(payload) {
+    return this._client._request("POST", "/api/v1/messages/send", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async sendImage(payload) {
+    return this._client._request("POST", "/api/v1/messages/send/image", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async send_image(payload) {
+    return this.sendImage(payload);
+  }
+  async sendVideo(payload) {
+    return this._client._request("POST", "/api/v1/messages/send/video", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async send_video(payload) {
+    return this.sendVideo(payload);
+  }
+  async sendVoice(payload) {
+    return this._client._request("POST", "/api/v1/messages/send/voice", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async send_voice(payload) {
+    return this.sendVoice(payload);
+  }
+  async sendDocument(payload) {
+    return this._client._request("POST", "/api/v1/messages/send/document", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async send_document(payload) {
+    return this.sendDocument(payload);
+  }
+  async sendLocation(payload) {
+    return this._client._request("POST", "/api/v1/messages/send/location", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async send_location(payload) {
+    return this.sendLocation(payload);
+  }
+  async sendContact(payload) {
+    return this._client._request("POST", "/api/v1/messages/send/contact", {
+      jsonBody: payload,
+      responseParser: parseSendMessageResponse
+    });
+  }
+  async send_contact(payload) {
+    return this.sendContact(payload);
+  }
+  async retry(messageId) {
+    return this._client._request(
+      "POST",
+      `/api/v1/messages/${messageId}/retry`,
+      {
+        responseParser: parseRetryMessageResponse
+      }
+    );
+  }
+  async cancel(messageId) {
+    return this._client._request(
+      "POST",
+      `/api/v1/messages/${messageId}/cancel`,
+      {
+        responseParser: parseCancelMessageResponse
+      }
+    );
+  }
+  async sendButtons(payload) {
+    return this._client._request(
+      "POST",
+      "/api/v1/messages/send/interactive/buttons",
+      {
+        jsonBody: payload,
+        responseParser: parseInteractiveMessageResponse
+      }
+    );
+  }
+  async send_buttons(payload) {
+    return this.sendButtons(payload);
+  }
+  async sendList(payload) {
+    return this._client._request(
+      "POST",
+      "/api/v1/messages/send/interactive/list",
+      {
+        jsonBody: payload,
+        responseParser: parseInteractiveMessageResponse
+      }
+    );
+  }
+  async send_list(payload) {
+    return this.sendList(payload);
+  }
+};
+
+// src/resources/templates.ts
+var TemplatesResource = class extends BaseResource {
+  async builtinVariables() {
+    return this._client._request("GET", "/api/v1/templates/builtin-variables", {
+      responseParser: parseBuiltinVariablesResponse
+    });
+  }
+  async builtin_variables() {
+    return this.builtinVariables();
+  }
+  async list(options) {
+    return this._client._request("GET", "/api/v1/templates", {
+      params: options,
+      responseParser: parseTemplateListResponse
+    });
+  }
+  async create(payload) {
+    return this._client._request("POST", "/api/v1/templates", {
+      jsonBody: payload,
+      responseParser: parseTemplateResponse
+    });
+  }
+  async get(templateId) {
+    return this._client._request("GET", `/api/v1/templates/${templateId}`, {
+      responseParser: parseTemplateResponse
+    });
+  }
+  async update(templateId, payload) {
+    return this._client._request("PATCH", `/api/v1/templates/${templateId}`, {
+      jsonBody: payload,
+      responseParser: parseTemplateResponse
+    });
+  }
+  async delete(templateId) {
+    await this._client._request("DELETE", `/api/v1/templates/${templateId}`);
+  }
+  async preview(payload) {
+    return this._client._request("POST", "/api/v1/templates/preview", {
+      jsonBody: payload,
+      responseParser: parseTemplatePreviewResponse
+    });
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.wazzapi.com";
+function buildHeaders(apiKey, headers) {
+  const merged = {
+    Accept: "application/json",
+    "Content-Type": "application/json"
+  };
+  if (headers) {
+    Object.entries(headers).forEach(([key, value]) => {
+      merged[key] = value;
+    });
+  }
+  if (apiKey) {
+    merged.Authorization = apiKey.toLowerCase().startsWith("bearer ") ? apiKey : `Bearer ${apiKey}`;
+  }
+  return merged;
+}
+function parseJson(text) {
+  if (!text) {
+    return void 0;
+  }
+  return JSON.parse(text);
+}
+function normalizeBaseUrl(baseUrl) {
+  return baseUrl.replace(/\/+$/, "");
+}
+var WazzapiClient = class {
+  constructor(options = {}) {
+    const baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    const timeout = options.timeout ?? 3e4;
+    const fetcher = options.fetch ?? fetch;
+    this.http = {
+      baseUrl: normalizeBaseUrl(baseUrl),
+      headers: buildHeaders(options.apiKey, options.headers),
+      timeout,
+      fetch: fetcher
+    };
+    this.contacts = new ContactsResource(this);
+    this.groups = new GroupsResource(this);
+    this.messages = new MessagesResource(this);
+    this.templates = new TemplatesResource(this);
+  }
+  get base_url() {
+    return this.http.baseUrl;
+  }
+  async close() {
+    return;
+  }
+  async _request(method, path, options = {}) {
+    const url = new URL(path, `${this.http.baseUrl}/`);
+    const params = filterNone(options.params);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        url.searchParams.set(key, String(value));
+      });
+    }
+    const body = options.jsonBody ? JSON.stringify(serializeData(options.jsonBody)) : void 0;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, this.http.timeout);
+    try {
+      const response = await this.http.fetch(url.toString(), {
+        method,
+        headers: this.http.headers,
+        body,
+        signal: controller.signal
+      });
+      const responseText = await response.text();
+      const payload = responseText.length > 0 ? parseJson(responseText) : void 0;
+      if (response.status >= 400) {
+        throw WazzapiAPIError.fromResponseParts(
+          response.status,
+          response.statusText,
+          responseText,
+          payload
+        );
+      }
+      if (response.status === 204 || responseText.length === 0) {
+        return void 0;
+      }
+      if (options.responseParser) {
+        return options.responseParser(payload);
+      }
+      return payload ?? responseText;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/media.ts
+import {
+  createDecipheriv,
+  createHash,
+  createHmac,
+  hkdfSync
+} from "crypto";
+var WA_MEDIA_INFO = {
+  image: Buffer.from("WhatsApp Image Keys", "utf8"),
+  video: Buffer.from("WhatsApp Video Keys", "utf8"),
+  audio: Buffer.from("WhatsApp Audio Keys", "utf8"),
+  ptt: Buffer.from("WhatsApp Audio Keys", "utf8"),
+  document: Buffer.from("WhatsApp Document Keys", "utf8"),
+  sticker: Buffer.from("WhatsApp Image Keys", "utf8"),
+  history: Buffer.from("WhatsApp History Keys", "utf8")
+};
+function _mediaInfoBytes(mimetype) {
+  const mt = mimetype.toLowerCase();
+  if (mt.startsWith("image/")) {
+    return WA_MEDIA_INFO.image;
+  }
+  if (mt.startsWith("video/")) {
+    return WA_MEDIA_INFO.video;
+  }
+  if (mt.startsWith("audio/")) {
+    return WA_MEDIA_INFO.audio;
+  }
+  return WA_MEDIA_INFO.document;
+}
+function _decryptWaMedia(mediaKeyBase64, encryptedData, mimetype) {
+  if (encryptedData.length < 10) {
+    throw new WazzapiMediaError("Encrypted data too short");
+  }
+  let mediaKey;
+  try {
+    mediaKey = Buffer.from(mediaKeyBase64, "base64");
+  } catch {
+    throw new WazzapiMediaError("Invalid media_key base64");
+  }
+  if (mediaKey.length === 0) {
+    throw new WazzapiMediaError("Invalid media_key base64");
+  }
+  const expanded = Buffer.from(
+    hkdfSync(
+      "sha256",
+      mediaKey,
+      Buffer.alloc(0),
+      _mediaInfoBytes(mimetype),
+      112
+    )
+  );
+  const iv = expanded.subarray(0, 16);
+  const aesKey = expanded.subarray(16, 48);
+  const macKey = expanded.subarray(48, 80);
+  const ciphertext = encryptedData.subarray(0, -10);
+  const mac = encryptedData.subarray(-10);
+  const computedMac = createHmac("sha256", macKey).update(Buffer.concat([iv, ciphertext])).digest().subarray(0, 10);
+  if (!computedMac.equals(mac)) {
+    throw new WazzapiMediaError(
+      "MAC verification failed \u2014 media may be corrupted or mediaKey is wrong"
+    );
+  }
+  const decipher = createDecipheriv("aes-256-cbc", aesKey, iv);
+  decipher.setAutoPadding(false);
+  const paddedPlaintext = Buffer.concat([
+    decipher.update(ciphertext),
+    decipher.final()
+  ]);
+  if (paddedPlaintext.length === 0) {
+    throw new WazzapiMediaError("Decrypted plaintext is empty");
+  }
+  const padLen = paddedPlaintext[paddedPlaintext.length - 1];
+  if (padLen === 0 || padLen > 16 || padLen > paddedPlaintext.length) {
+    throw new WazzapiMediaError("Invalid PKCS7 padding");
+  }
+  for (let i = paddedPlaintext.length - padLen; i < paddedPlaintext.length; i += 1) {
+    if (paddedPlaintext[i] !== padLen) {
+      throw new WazzapiMediaError("Invalid PKCS7 padding");
+    }
+  }
+  return paddedPlaintext.subarray(0, paddedPlaintext.length - padLen);
+}
+async function downloadMedia(url, mediaKey, mimetype, options) {
+  const fetcher = options?.fetch ?? fetch;
+  let response;
+  try {
+    response = await fetcher(url);
+  } catch (error) {
+    throw new WazzapiMediaError(`CDN fetch error: ${String(error)}`);
+  }
+  if (!response.ok) {
+    throw new WazzapiMediaError(`CDN fetch failed: ${response.status}`);
+  }
+  const encryptedData = Buffer.from(await response.arrayBuffer());
+  if (options?.file_enc_sha256) {
+    const expectedEncrypted = Buffer.from(options.file_enc_sha256, "base64");
+    const actualEncrypted = createHash("sha256").update(encryptedData).digest();
+    if (!actualEncrypted.equals(expectedEncrypted)) {
+      throw new WazzapiMediaError(
+        `file_enc_sha256 mismatch: CDN returned wrong data (got ${encryptedData.length} bytes)`
+      );
+    }
+  }
+  const plaintext = _decryptWaMedia(mediaKey, encryptedData, mimetype);
+  if (options?.file_sha256) {
+    const expectedPlain = Buffer.from(options.file_sha256, "base64");
+    const actualPlain = createHash("sha256").update(plaintext).digest();
+    if (!actualPlain.equals(expectedPlain)) {
+      throw new WazzapiMediaError("file_sha256 mismatch after decryption");
+    }
+  }
+  return {
+    content: plaintext,
+    mimetype,
+    file_name: options?.file_name || "media",
+    file_size: plaintext.length
+  };
+}
+var download_media = downloadMedia;
+var _decrypt_wa_media = _decryptWaMedia;
+var _media_info_bytes = _mediaInfoBytes;
+
+// src/webhooks.ts
+import { createHmac as createHmac2, timingSafeEqual } from "crypto";
+var SIGNATURE_HEADER = "X-Wazzapi-Signature";
+var EVENT_HEADER = "X-Wazzapi-Event";
+var EVENT_ID_HEADER = "X-Wazzapi-Event-ID";
+var SIGNATURE_PREFIX = "sha256=";
+var WazzapiWebhookError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "WazzapiWebhookError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var WazzapiWebhookVerificationError = class extends WazzapiWebhookError {
+  constructor(message) {
+    super(message);
+    this.name = "WazzapiWebhookVerificationError";
+  }
+};
+var WazzapiWebhookParseError = class extends WazzapiWebhookError {
+  constructor(message) {
+    super(message);
+    this.name = "WazzapiWebhookParseError";
+  }
+};
+function toBuffer(payload) {
+  if (typeof payload === "string") {
+    return Buffer.from(payload, "utf8");
+  }
+  return Buffer.from(payload);
+}
+function getHeader(headers, name) {
+  const normalizedName = name.toLowerCase();
+  if (typeof Headers !== "undefined" && headers instanceof Headers) {
+    return headers.get(name) ?? void 0;
+  }
+  return Object.entries(headers).find(
+    ([key]) => key.toLowerCase() === normalizedName
+  )?.[1];
+}
+function generateWebhookSignature(payload, secret) {
+  const digest = createHmac2("sha256", Buffer.from(secret, "utf8")).update(toBuffer(payload)).digest("hex");
+  return `${SIGNATURE_PREFIX}${digest}`;
+}
+function verifyWebhookSignature(payload, signature, secret) {
+  const normalizedSignature = signature.trim();
+  const expected = Buffer.from(
+    generateWebhookSignature(payload, secret),
+    "utf8"
+  );
+  const actual = Buffer.from(normalizedSignature, "utf8");
+  if (expected.length !== actual.length) {
+    return false;
+  }
+  return timingSafeEqual(expected, actual);
+}
+var WebhookHandler = class {
+  constructor(secret) {
+    this.secret = secret;
+  }
+  generateSignature(payload) {
+    return generateWebhookSignature(payload, this.secret);
+  }
+  verifySignature(payload, signature) {
+    return verifyWebhookSignature(payload, signature, this.secret);
+  }
+  verifyHeaders(payload, headers) {
+    const signature = getHeader(headers, SIGNATURE_HEADER);
+    if (!signature) {
+      throw new WazzapiWebhookVerificationError(
+        `Missing required webhook header: ${SIGNATURE_HEADER}`
+      );
+    }
+    if (!this.verifySignature(payload, signature)) {
+      throw new WazzapiWebhookVerificationError("Invalid webhook signature");
+    }
+    if (!getHeader(headers, EVENT_HEADER)) {
+      throw new WazzapiWebhookVerificationError(
+        `Missing required webhook header: ${EVENT_HEADER}`
+      );
+    }
+    if (!getHeader(headers, EVENT_ID_HEADER)) {
+      throw new WazzapiWebhookVerificationError(
+        `Missing required webhook header: ${EVENT_ID_HEADER}`
+      );
+    }
+  }
+  parse(payload) {
+    let rawPayload;
+    try {
+      rawPayload = JSON.parse(toBuffer(payload).toString("utf8"));
+    } catch {
+      throw new WazzapiWebhookParseError("Webhook payload is not valid JSON");
+    }
+    if (!rawPayload || typeof rawPayload !== "object" || Array.isArray(rawPayload)) {
+      throw new WazzapiWebhookParseError(
+        "Webhook payload must be a JSON object"
+      );
+    }
+    const eventType = rawPayload.event_type;
+    if (typeof eventType !== "string") {
+      throw new WazzapiWebhookParseError(
+        "Webhook payload is missing event_type"
+      );
+    }
+    if (eventType.startsWith("message.")) {
+      return parsePublicMessageWebhook(rawPayload);
+    }
+    if (eventType.startsWith("device.")) {
+      return parsePublicDeviceWebhook(rawPayload);
+    }
+    throw new WazzapiWebhookParseError(
+      `Unsupported webhook event type: ${eventType}`
+    );
+  }
+  verifyAndParse(payload, headers) {
+    this.verifyHeaders(payload, headers);
+    const parsed = this.parse(payload);
+    const headerEvent = getHeader(headers, EVENT_HEADER);
+    if (headerEvent && headerEvent !== parsed.event_type) {
+      throw new WazzapiWebhookVerificationError(
+        "Webhook event header does not match payload event_type"
+      );
+    }
+    return parsed;
+  }
+};
+function parseWebhook(payload, headers, secret) {
+  return new WebhookHandler(secret).verifyAndParse(payload, headers);
+}
+var generate_webhook_signature = generateWebhookSignature;
+var verify_webhook_signature = verifyWebhookSignature;
+var parse_webhook = parseWebhook;
+
+// src/index.ts
+var __version__ = "0.2.0";
+export {
+  DEFAULT_BASE_URL,
+  EVENT_HEADER,
+  EVENT_ID_HEADER,
+  SIGNATURE_HEADER,
+  WazzapiAPIError,
+  WazzapiClient,
+  WazzapiError,
+  WazzapiMediaError,
+  WazzapiWebhookError,
+  WazzapiWebhookParseError,
+  WazzapiWebhookVerificationError,
+  WebhookHandler,
+  __version__,
+  _decryptWaMedia,
+  _decrypt_wa_media,
+  _mediaInfoBytes,
+  _media_info_bytes,
+  downloadMedia,
+  download_media,
+  generateWebhookSignature,
+  generate_webhook_signature,
+  models_exports as models,
+  parseAddToGroupResponse,
+  parseBuiltinVariableInfo,
+  parseBuiltinVariablesResponse,
+  parseBulkDeleteResponse,
+  parseCSVExportResponse,
+  parseCSVImportResponse,
+  parseCancelMessageResponse,
+  parseContactGroupItem,
+  parseContactGroupListResponse,
+  parseContactGroupMembersResponse,
+  parseContactItem,
+  parseContactListResponse,
+  parseContactResponse,
+  parseContactSyncHistoryItem,
+  parseContactSyncHistoryResponse,
+  parseContactSyncResponse,
+  parseContactSyncStatusResponse,
+  parseContactSyncStatusResponseList,
+  parseCreateGroupResponseModel,
+  parseGroupDetailResponse,
+  parseGroupInviteInfoResponseModel,
+  parseGroupInviteLinkResponseModel,
+  parseGroupListItem,
+  parseGroupListResponse,
+  parseGroupOperationResponseModel,
+  parseGroupParticipantItem,
+  parseGroupParticipantsResponse,
+  parseInteractiveButton,
+  parseInteractiveMessageResponse,
+  parseInteractiveRow,
+  parseInteractiveSection,
+  parseMediaDownloadResult,
+  parseMessageItem,
+  parseMessageListResponse,
+  parseMessageResponse,
+  parseMessageStatsResponse,
+  parsePublicDeviceWebhook,
+  parsePublicMessageWebhook,
+  parsePublicWebhookDeviceData,
+  parsePublicWebhookMessageData,
+  parseRetryMessageResponse,
+  parseSendGroupResponse,
+  parseSendMessageResponse,
+  parseTemplateItem,
+  parseTemplateListResponse,
+  parseTemplatePreviewResponse,
+  parseTemplateResponse,
+  parseWebhook,
+  parseWebhookPayload,
+  parse_webhook,
+  verifyWebhookSignature,
+  verify_webhook_signature
+};