@solufy/evolution-sdk
Version:
Unofficial SDK for the Evolution Whatsapp API v2
1,258 lines (1,218 loc) • 38.5 kB
JavaScript
Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
//#region \0rolldown/runtime.js
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
key = keys[i];
if (!__hasOwnProp.call(to, key) && key !== except) {
__defProp(to, key, {
get: ((k) => from[k]).bind(null, key),
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
});
}
}
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
value: mod,
enumerable: true
}) : target, mod));
//#endregion
let zod_mini = require("zod/mini");
zod_mini = __toESM(zod_mini);
let libphonenumber_js_min = require("libphonenumber-js/min");
//#region src/api/errors.ts
var EvolutionApiError = class EvolutionApiError extends Error {
code;
instance;
constructor(message, options) {
const error = getError(options?.cause);
super(message, error ? void 0 : { cause: options?.cause });
this.name = EvolutionApiError.name;
this.message = error?.message ?? message;
this.code = error?.code ?? options?.code;
this.instance = options?.instance;
}
};
const Errors = [
defineError(zod_mini.literal("Unauthorized"), "unauthorized", "Unauthorized"),
defineError(zod_mini.array(zod_mini.object({
exists: zod_mini.literal(false),
jid: zod_mini.string(),
number: zod_mini.string()
})), "invalid_whatsapp_number", "Provided number is not a valid WhatsApp number"),
defineError(zod_mini.array(zod_mini.string().check(zod_mini.includes("Media upload failed on all hosts"))), "media_upload_failed", "Media upload failed on all hosts"),
defineError(zod_mini.array(zod_mini.string().check(zod_mini.includes("AxiosError"))), "generic", (r) => r.message[0]),
defineError(zod_mini.array(zod_mini.string().check(zod_mini.includes("No session"))), "no_session_found", "No session found, try restarting your instance"),
defineError(zod_mini.array(zod_mini.string().check(zod_mini.includes("AggregateError"))), "aggregate_error", "AggregateError"),
defineError(zod_mini.array(zod_mini.string().check(zod_mini.includes("instance does not exist"))), "instance_not_found", "Instance not found")
];
function getError(response) {
const error = Errors.find((message) => message.schema.safeParse(response).success);
return error ? {
code: error.code,
message: typeof error.message === "string" ? error.message : error.message(response)
} : void 0;
}
function defineError(schema, code, message) {
return {
schema: zod_mini.object({ message: schema }),
code,
message
};
}
//#endregion
//#region src/api/index.ts
var EvolutionApi = class {
constructor(options) {
this.options = options;
}
async get(path, options = {}) {
return this.request(path, {
...options,
method: "GET"
});
}
async post(path, options = {}) {
return this.request(path, {
...options,
method: "POST"
});
}
async put(path, options = {}) {
return this.request(path, {
...options,
method: "PUT"
});
}
async patch(path, options = {}) {
return this.request(path, {
...options,
method: "PATCH"
});
}
async delete(path, options = {}) {
return this.request(path, {
...options,
method: "DELETE"
});
}
async request(path, options = {}) {
const { init, params } = this.makeInit(options);
const url = new URL(`/${path}/?${params}`, this.options.serverUrl);
const response = await fetch(url, init);
const data = await response.json();
if (!response.ok || "error" in data) throw new EvolutionApiError(data.error ?? "Unknown Error", { cause: data.response });
return data;
}
makeInit(options) {
const { params: _, headers, body, ...rest } = options;
const paramsInit = options.params && Object.entries(options.params).filter(([, value]) => Boolean(value)).map(([key, value]) => [key, String(value)]);
const params = new URLSearchParams(paramsInit);
const init = {
...rest,
headers: {
...headers || {},
apikey: this.options.token
}
};
if (body) {
init.headers["Content-Type"] = body instanceof FormData ? "multipart/form-data" : "application/json";
init.body = body instanceof FormData ? body : JSON.stringify(body);
}
return {
init,
params
};
}
};
//#endregion
//#region src/api/routes.ts
const Routes = {
Message: {
SendText: "message/sendText",
SendMedia: "message/sendMedia",
SendVoice: "message/sendWhatsAppAudio",
SendSticker: "message/sendSticker",
SendLocation: "message/sendLocation",
SendContact: "message/sendContact",
SendPoll: "message/sendPoll"
},
Chats: {
Check: "chat/whatsappNumbers",
FindAll: "chat/findChats",
SendPresence: "chat/sendPresence"
},
Groups: {
FindAll: "group/fetchAllGroups",
FindByJid: "group/findGroupInfos",
FindByInviteCode: "group/inviteInfo"
},
Instances: {
Create: "instance/create",
Find: "instance/fetchInstances",
Connect: (instance) => `instance/connect/${instance}`,
Restart: (instance) => `instance/restart/${instance}`,
Presence: (instance) => `instance/setPresence/${instance}`,
Status: (instance) => `instance/connectionState/${instance}`,
Logout: (instance) => `instance/logout/${instance}`,
Delete: (instance) => `instance/delete/${instance}`
}
};
//#endregion
//#region src/modules/instances/schemas/connect.ts
const ResponseSchema$18 = zod_mini.object({
pairingCode: zod_mini.nullish(zod_mini.string()),
code: zod_mini.nullish(zod_mini.string()),
base64: zod_mini.nullish(zod_mini.string())
});
const Response$18 = (response) => {
const { pairingCode, code, base64 } = ResponseSchema$18.parse(response);
return {
pairingCode: pairingCode ?? void 0,
code: code ?? void 0,
base64: base64 ?? void 0
};
};
//#endregion
//#region src/schemas/common.ts
const PhoneNumberSchema = zod_mini.string().check(zod_mini.refine((value) => (0, libphonenumber_js_min.isValidPhoneNumber)(value), "Invalid phone number"), zod_mini.overwrite((phoneNumber) => (0, libphonenumber_js_min.parsePhoneNumberFromString)(phoneNumber)?.number));
const JidSchema = zod_mini.pipe(zod_mini.string().check(zod_mini.endsWith("@s.whatsapp.net", "Invalid remote JID, should end with @s.whatsapp.net")), zod_mini.custom());
const GroupJidSchema = zod_mini.pipe(zod_mini.string().check(zod_mini.endsWith("@g.us", "Invalid group JID, should end with @g.us")), zod_mini.custom());
const GroupInviteCodeSchema = zod_mini.pipe(zod_mini.string().check(zod_mini.length(22), zod_mini.regex(/^[a-zA-Z0-9]{22}$/, "Invalid group invite code")), zod_mini.custom());
const ApiNumberSchema = zod_mini.union([
PhoneNumberSchema,
JidSchema,
GroupJidSchema
]);
const MediaSchema = zod_mini.union([zod_mini.url(), zod_mini.base64()]);
//#endregion
//#region src/modules/instances/schemas/common.ts
const IntegrationMap = {
baileys: "WHATSAPP-BAILEYS",
business: "WHATSAPP-BUSINESS",
evolution: "EVOLUTION",
"WHATSAPP-BAILEYS": "baileys",
"WHATSAPP-BUSINESS": "business",
EVOLUTION: "evolution"
};
const IntegrationSchema = {
Raw: zod_mini.union([
zod_mini.literal("WHATSAPP-BAILEYS"),
zod_mini.literal("WHATSAPP-BUSINESS"),
zod_mini.literal("EVOLUTION")
]),
Map: zod_mini.union([
zod_mini.literal("baileys"),
zod_mini.literal("business"),
zod_mini.literal("evolution")
])
};
const StatusSchema = zod_mini.union([
zod_mini.literal("connecting"),
zod_mini.literal("close"),
zod_mini.literal("open")
]);
const InstanceSchema = zod_mini.object({
id: zod_mini.string(),
name: zod_mini.string(),
connectionStatus: StatusSchema,
ownerJid: zod_mini.nullable(zod_mini.string()),
profileName: zod_mini.nullable(zod_mini.string()),
profilePicUrl: zod_mini.nullable(zod_mini.string()),
integration: IntegrationSchema.Raw,
number: zod_mini.nullable(zod_mini.string()),
token: zod_mini.string(),
businessId: zod_mini.nullable(zod_mini.string()),
clientName: zod_mini.string(),
disconnectionReasonCode: zod_mini.nullable(zod_mini.number()),
disconnectionObject: zod_mini.nullable(zod_mini.string()),
disconnectionAt: zod_mini.nullable(zod_mini.string()),
createdAt: zod_mini.string(),
updatedAt: zod_mini.string(),
_count: zod_mini.object({
Message: zod_mini.number(),
Contact: zod_mini.number(),
Chat: zod_mini.number()
})
});
const InstanceResponse = (instance) => ({
id: instance.id,
name: instance.name,
status: instance.connectionStatus,
integration: IntegrationMap[instance.integration],
number: instance.number ?? void 0,
token: instance.token,
businessId: instance.businessId ?? void 0,
clientName: instance.clientName,
createdAt: new Date(instance.createdAt),
updatedAt: new Date(instance.updatedAt),
profile: instance.ownerJid && instance.profileName ? {
jid: instance.ownerJid,
name: instance.profileName,
pictureUrl: instance.profilePicUrl ?? void 0
} : void 0,
disconnection: instance.disconnectionAt && instance.disconnectionObject && instance.disconnectionReasonCode ? {
reasonCode: instance.disconnectionReasonCode,
object: instance.disconnectionObject,
at: new Date(instance.disconnectionAt)
} : void 0,
count: {
messages: instance._count.Message,
contacts: instance._count.Contact,
chats: instance._count.Chat
}
});
//#endregion
//#region src/modules/instances/schemas/create.ts
const OptionsSchema$11 = zod_mini.object({
name: zod_mini.string(),
integration: zod_mini.optional(IntegrationSchema.Map),
token: zod_mini.optional(zod_mini.string()),
number: zod_mini.optional(PhoneNumberSchema)
});
const Body$11 = (options) => {
const data = OptionsSchema$11.parse(options);
return {
instanceName: data.name,
integration: IntegrationMap[data.integration ?? "baileys"],
number: data.number,
token: data.token
};
};
const ResponseSchema$17 = zod_mini.object({
instance: zod_mini.object({
instanceName: zod_mini.string(),
instanceId: zod_mini.string(),
integration: IntegrationSchema.Raw,
status: StatusSchema
}),
hash: zod_mini.string()
});
const Response$17 = (response) => {
const data = ResponseSchema$17.parse(response);
const { instance } = data;
return {
id: instance.instanceId,
name: instance.instanceName,
integration: IntegrationMap[instance.integration],
status: instance.status,
token: data.hash
};
};
//#endregion
//#region src/modules/instances/schemas/find-all.ts
const ResponseSchema$16 = zod_mini.array(InstanceSchema);
const Response$16 = (response) => {
return ResponseSchema$16.parse(response).map(InstanceResponse);
};
//#endregion
//#region src/modules/instances/schemas/find-one.ts
const ResponseSchema$15 = zod_mini.array(InstanceSchema);
const Response$15 = (response) => {
return InstanceResponse(ResponseSchema$15.parse(response)[0]);
};
//#endregion
//#region src/modules/instances/schemas/status.ts
const ResponseSchema$14 = zod_mini.object({ instance: zod_mini.object({
instanceName: zod_mini.string(),
state: StatusSchema
}) });
const Response$14 = (response) => {
const { instance } = ResponseSchema$14.parse(response);
return instance.state;
};
//#endregion
//#region src/modules/instances/index.ts
var InstancesModule = class {
constructor(api) {
this.api = api;
}
/**
* Creates an instance
* @param options - Instance options
*/
async create(options) {
const body = Body$11(options);
const response = await this.api.post(Routes.Instances.Create, { body });
return Response$17(response);
}
/**
* Finds all instances
*/
async findAll() {
const response = await this.api.get(Routes.Instances.Find);
return Response$16(response);
}
/**
* Finds one instance by id
*/
async findById(id) {
const response = await this.api.get(Routes.Instances.Find, { params: { instanceId: id } });
return Response$15(response);
}
/**
* Finds one instance by name
*/
async findByName(name) {
const response = await this.api.get(Routes.Instances.Find, { params: { instanceName: name } });
return Response$15(response);
}
/**
* Returns the QRCode and/or pairing code
*/
async connect(instance) {
const response = await this.api.get(Routes.Instances.Connect(instance));
return Response$18(response);
}
/**
* Restarts the instance and returns the QRCode and/or pairing code
*/
async restart(instance) {
const response = await this.api.post(Routes.Instances.Restart(instance));
return Response$18(response);
}
/**
* Returns the instance connection status
*/
async status(instance) {
const response = await this.api.get(Routes.Instances.Status(instance));
return Response$14(response);
}
/**
* Logs out the instance
*/
async logout(instance) {
await this.api.delete(Routes.Instances.Logout(instance));
}
/**
* Deletes the instance
*/
async delete(instance) {
await this.api.delete(Routes.Instances.Delete(instance));
}
};
//#endregion
//#region src/schemas/client.ts
const ClientOptionsSchema = zod_mini.object({
serverUrl: zod_mini.url(),
token: zod_mini.string()
});
//#endregion
//#region src/api/instance.ts
var InstanceApi = class extends EvolutionApi {
constructor(instance, options) {
super(options);
this.instance = instance;
this.options = options;
}
async request(path, options = {}) {
const { init, params } = this.makeInit(options);
const url = new URL(`/${path}/${this.instance}/?${params}`, this.options.serverUrl);
const response = await fetch(url, init);
const data = await response.json();
if (!response.ok || "error" in data) throw new EvolutionApiError(data.error || "Unknown Error", {
cause: data.response,
instance: this.instance
});
return data;
}
};
//#endregion
//#region src/types/tags.ts
const Jid = (jid) => jid;
const GroupJid = (jid) => jid;
const MessageId = (id) => id;
const ChatId = (id) => id;
//#endregion
//#region src/modules/chats/schemas/check.ts
const OptionsSchema$10 = zod_mini.array(PhoneNumberSchema);
const Body$10 = (options) => {
const data = OptionsSchema$10.parse(options);
return { numbers: Array.isArray(data) ? data : [data] };
};
const ResponseSchema$13 = zod_mini.array(zod_mini.object({
exists: zod_mini.boolean(),
jid: zod_mini.string(),
number: zod_mini.string()
}));
const Response$13 = (response) => {
return ResponseSchema$13.parse(response).map((number) => ({
exists: number.exists,
jid: Jid(number.jid),
number: (0, libphonenumber_js_min.parsePhoneNumberWithError)(number.number).number
}));
};
//#endregion
//#region src/utils/phone-numer-from-jid.ts
/**
* Get phone number from JID
* @param jid - JID (remote JID)
*/
function phoneNumberFromJid(jid) {
return (0, libphonenumber_js_min.parsePhoneNumberWithError)(`+${jid.split("@")[0]}`).number;
}
//#endregion
//#region src/modules/chats/schemas/find-all.ts
const ResponseSchema$12 = zod_mini.array(zod_mini.object({
id: zod_mini.string(),
remoteJid: zod_mini.string(),
name: zod_mini.nullish(zod_mini.string()),
labels: zod_mini.nullish(zod_mini.array(zod_mini.string())),
createdAt: zod_mini.coerce.date(),
updatedAt: zod_mini.coerce.date(),
pushName: zod_mini.nullish(zod_mini.string()),
profilePicUrl: zod_mini.nullish(zod_mini.url())
}));
const Response$12 = (response) => {
return ResponseSchema$12.parse(response).map((chat) => ({
id: ChatId(chat.id),
jid: chat.remoteJid.endsWith("@g.us") ? GroupJid(chat.remoteJid) : Jid(chat.remoteJid),
phoneNumber: phoneNumberFromJid(chat.remoteJid),
name: chat.name || void 0,
labels: chat.labels || void 0,
createdAt: chat.createdAt,
updatedAt: chat.updatedAt,
pushName: chat.pushName || void 0,
pictureUrl: chat.profilePicUrl || void 0
}));
};
//#endregion
//#region src/modules/chats/schemas/presence.ts
const OptionsSchema$9 = zod_mini.object({
number: ApiNumberSchema,
duration: zod_mini.number(),
presence: zod_mini.enum(["composing", "recording"]),
waitUntilFinish: zod_mini.optional(zod_mini.boolean())
});
const Body$9 = (options) => {
const { waitUntilFinish, duration, ...data } = OptionsSchema$9.parse(options);
return {
...data,
delay: duration
};
};
//#endregion
//#region src/modules/chats/index.ts
var ChatsModule = class {
constructor(api) {
this.api = api;
}
/**
* Checks if a number has WhatsApp
* @param numbers - Number(s) (with country code) to check
*/
async check(...numbers) {
const body = Body$10(numbers.flat());
const response = await this.api.post(Routes.Chats.Check, { body });
return Response$13(response);
}
/**
* Gets all chats
*/
async findAll() {
const response = await this.api.post(Routes.Chats.FindAll);
return Response$12(response);
}
/**
* Sends a presence to a certain chat
* @param options - Presence options
*/
async sendPresence(options) {
const body = Body$9(options);
if (options.waitUntilFinish) await this.api.post(Routes.Chats.SendPresence, { body });
else this.api.post(Routes.Chats.SendPresence, { body });
}
};
//#endregion
//#region src/modules/groups/schemas/common.ts
const GroupSchema = zod_mini.object({
id: zod_mini.string(),
subject: zod_mini.string(),
subjectOwner: zod_mini.string(),
subjectTime: zod_mini.coerce.date(),
pictureUrl: zod_mini.nullish(zod_mini.url()),
size: zod_mini.number(),
creation: zod_mini.coerce.date(),
owner: zod_mini.string(),
restrict: zod_mini.boolean(),
announce: zod_mini.boolean()
});
const ParticipantSchema = zod_mini.object({
id: zod_mini.string(),
admin: zod_mini.nullish(zod_mini.enum(["admin", "superadmin"]))
});
const GroupWithParticipantsSchema = zod_mini.extend(GroupSchema, { participants: zod_mini.array(ParticipantSchema) });
const GroupResponse = (group) => ({
jid: GroupJid(group.id),
name: group.subject,
pictureUrl: group.pictureUrl || void 0,
size: group.size,
subject: {
owner: Jid(group.subjectOwner),
time: group.subjectTime
},
owner: {
jid: Jid(group.owner),
phoneNumber: phoneNumberFromJid(group.owner)
},
createdAt: group.creation,
restrict: group.restrict,
announce: group.announce
});
const ParticipantResponse = (participant) => ({
id: participant.id,
role: participant.admin ?? "member"
});
const GroupWithParticipantsResponse = (group) => ({
...GroupResponse(group),
participants: group.participants.map(ParticipantResponse)
});
//#endregion
//#region src/modules/groups/schemas/find-all.ts
const ResponseSchema$11 = zod_mini.array(GroupSchema);
const ResponseWithParticipantsSchema = zod_mini.array(GroupWithParticipantsSchema);
const Response$11 = (response) => {
return ResponseSchema$11.parse(response).map(GroupResponse);
};
const ResponseWithParticipants = (response) => {
return ResponseWithParticipantsSchema.parse(response).map(GroupWithParticipantsResponse);
};
//#endregion
//#region src/modules/groups/schemas/find-by-invite-code.ts
const ResponseSchema$10 = zod_mini.omit(zod_mini.extend(GroupWithParticipantsSchema, {
isCommunity: zod_mini.boolean(),
isCommunityAnnounce: zod_mini.boolean(),
joinApprovalMode: zod_mini.boolean(),
memberAddMode: zod_mini.boolean()
}), { pictureUrl: true });
const Response$10 = (response) => {
const data = ResponseSchema$10.parse(response);
return {
...GroupWithParticipantsResponse({
...data,
pictureUrl: null
}),
isCommunity: data.isCommunity,
isCommunityAnnounce: data.isCommunityAnnounce,
joinApprovalMode: data.joinApprovalMode,
memberAddMode: data.memberAddMode
};
};
//#endregion
//#region src/modules/groups/schemas/find-by-jid.ts
const ResponseSchema$9 = GroupWithParticipantsSchema;
const Response$9 = (response) => {
return GroupWithParticipantsResponse(ResponseSchema$9.parse(response));
};
//#endregion
//#region src/modules/groups/index.ts
var GroupsModule = class {
constructor(api) {
this.api = api;
}
async findAll(participants = false) {
const response = await this.api.get(Routes.Groups.FindAll, { params: { getParticipants: zod_mini.boolean().parse(participants) } });
if (participants) return ResponseWithParticipants(response);
return Response$11(response);
}
/**
* Gets a group by invite code
* @param inviteCode - The group invite code (not the URL)
*/
async findByInviteCode(inviteCode) {
const response = await this.api.get(Routes.Groups.FindByInviteCode, { params: { inviteCode: GroupInviteCodeSchema.parse(inviteCode) } });
return Response$10(response);
}
/**
* Gets a group by JID
* @param groupJid - The group JID terminated with \@g.us
*/
async findByJid(groupJid) {
const response = await this.api.get(Routes.Groups.FindByJid, { params: { groupJid: GroupJidSchema.parse(groupJid) } });
return Response$9(response);
}
};
//#endregion
//#region src/modules/messages/schemas/base.ts
const BaseMessageOptionsSchema = zod_mini.object({
number: ApiNumberSchema,
delay: zod_mini.optional(zod_mini.number())
});
const KeyResponseSchema = zod_mini.object({
remoteJid: zod_mini.string(),
id: zod_mini.string()
});
const ReceiverResponse = (remoteJid) => {
return {
phoneNumber: phoneNumberFromJid(remoteJid),
jid: Jid(remoteJid)
};
};
//#endregion
//#region src/modules/messages/schemas/audio.ts
const OptionsSchema$8 = zod_mini.extend(BaseMessageOptionsSchema, {
audio: MediaSchema,
mimetype: zod_mini.optional(zod_mini.string())
});
const Body$8 = (options) => {
const { audio, ...data } = OptionsSchema$8.parse(options);
return {
...data,
media: audio,
mediatype: "audio"
};
};
const ResponseSchema$8 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ audioMessage: zod_mini.object({
url: zod_mini.url(),
mimetype: zod_mini.optional(zod_mini.string()),
fileSha256: zod_mini.base64(),
fileLength: zod_mini.coerce.number(),
seconds: zod_mini.number(),
mediaKey: zod_mini.base64(),
fileEncSha256: zod_mini.base64(),
directPath: zod_mini.string(),
mediaKeyTimestamp: zod_mini.coerce.date()
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response$8 = (response) => {
const data = ResponseSchema$8.parse(response);
const { audioMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
media: {
url: audioMessage.url,
mimetype: audioMessage.mimetype,
length: audioMessage.fileLength,
durationInSeconds: audioMessage.seconds,
sha256: audioMessage.fileSha256,
encryptedSha256: audioMessage.fileEncSha256,
directPath: audioMessage.directPath,
key: audioMessage.mediaKey,
keyTimestamp: audioMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/contact.ts
const OptionsSchema$7 = zod_mini.extend(BaseMessageOptionsSchema, { contacts: zod_mini.array(zod_mini.object({
fullName: zod_mini.string(),
phoneNumber: PhoneNumberSchema,
organization: zod_mini.optional(zod_mini.string()),
email: zod_mini.optional(zod_mini.email()),
url: zod_mini.optional(zod_mini.url())
})) });
const Body$7 = (options) => {
const { contacts, ...data } = OptionsSchema$7.parse(options);
return {
...data,
contact: contacts.map((contact) => ({
...contact,
phoneNumber: (0, libphonenumber_js_min.parsePhoneNumberWithError)(contact.phoneNumber).formatInternational(),
wuid: contact.phoneNumber.replace(/\D/g, "")
}))
};
};
const ResponseSchema$7 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.union([zod_mini.object({ contactMessage: zod_mini.object({
displayName: zod_mini.string(),
vcard: zod_mini.string()
}) }), zod_mini.object({ contactsArrayMessage: zod_mini.object({ contacts: zod_mini.array(zod_mini.object({
displayName: zod_mini.string(),
vcard: zod_mini.string()
})) }) })]),
messageTimestamp: zod_mini.coerce.date()
});
const Response$7 = (response) => {
const data = ResponseSchema$7.parse(response);
return {
receiver: ReceiverResponse(data.key.remoteJid),
contacts: "contactMessage" in data.message ? [data.message.contactMessage] : data.message.contactsArrayMessage.contacts,
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/utils/greeting.ts
function getGreeting(date = /* @__PURE__ */ new Date(), timeZone = "America/Sao_Paulo") {
const hours = new Date(date.toLocaleString("en-US", { timeZone })).getHours();
if (hours >= 5 && hours < 12) return "Bom dia";
if (hours >= 12 && hours < 18) return "Boa tarde";
return "Boa noite";
}
function replaceWithGreeting(value) {
return value?.replaceAll("{{greeting}}", getGreeting());
}
//#endregion
//#region src/modules/messages/schemas/document.ts
const OptionsSchema$6 = zod_mini.extend(BaseMessageOptionsSchema, {
document: MediaSchema,
caption: zod_mini.optional(zod_mini.string().check(zod_mini.overwrite(replaceWithGreeting))),
mimetype: zod_mini.optional(zod_mini.string()),
fileName: zod_mini.optional(zod_mini.string())
}).check(zod_mini.refine((data) => URL.canParse(data.document) ? true : Boolean(data.fileName), {
message: "fileName must be provided when document is not an URL",
path: ["fileName"]
}));
const Body$6 = (options) => {
const { document, ...data } = OptionsSchema$6.parse(options);
return {
...data,
media: document,
mediatype: "document"
};
};
const ResponseSchema$6 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ documentMessage: zod_mini.object({
url: zod_mini.url(),
mimetype: zod_mini.optional(zod_mini.string()),
fileSha256: zod_mini.base64(),
fileLength: zod_mini.coerce.number(),
mediaKey: zod_mini.base64(),
caption: zod_mini.optional(zod_mini.string()),
fileName: zod_mini.string(),
fileEncSha256: zod_mini.base64(),
directPath: zod_mini.string(),
mediaKeyTimestamp: zod_mini.coerce.date()
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response$6 = (response) => {
const data = ResponseSchema$6.parse(response);
const { documentMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
media: {
url: documentMessage.url,
caption: documentMessage.caption,
mimetype: documentMessage.mimetype,
length: documentMessage.fileLength,
sha256: documentMessage.fileSha256,
fileName: documentMessage.fileName,
encryptedSha256: documentMessage.fileEncSha256,
directPath: documentMessage.directPath,
key: documentMessage.mediaKey,
keyTimestamp: documentMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/image.ts
const OptionsSchema$5 = zod_mini.extend(BaseMessageOptionsSchema, {
image: MediaSchema,
caption: zod_mini.optional(zod_mini.string()).check(zod_mini.overwrite(replaceWithGreeting)),
mimetype: zod_mini.optional(zod_mini.string())
});
const Body$5 = (options) => {
const { image, ...data } = OptionsSchema$5.parse(options);
return {
...data,
media: image,
mediatype: "image"
};
};
const ResponseSchema$5 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ imageMessage: zod_mini.object({
url: zod_mini.url(),
mimetype: zod_mini.optional(zod_mini.string()),
fileSha256: zod_mini.base64(),
fileLength: zod_mini.coerce.number(),
height: zod_mini.number(),
width: zod_mini.number(),
mediaKey: zod_mini.base64(),
caption: zod_mini.optional(zod_mini.string()),
fileEncSha256: zod_mini.base64(),
directPath: zod_mini.string(),
mediaKeyTimestamp: zod_mini.coerce.date()
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response$5 = (response) => {
const data = ResponseSchema$5.parse(response);
const { imageMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
media: {
url: imageMessage.url,
caption: imageMessage.caption,
mimetype: imageMessage.mimetype,
length: imageMessage.fileLength,
height: imageMessage.height,
width: imageMessage.width,
sha256: imageMessage.fileSha256,
encryptedSha256: imageMessage.fileEncSha256,
directPath: imageMessage.directPath,
key: imageMessage.mediaKey,
keyTimestamp: imageMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/location.ts
const OptionsSchema$4 = zod_mini.extend(BaseMessageOptionsSchema, {
name: zod_mini.string(),
address: zod_mini.string(),
latitude: zod_mini.number(),
longitude: zod_mini.number()
});
const Body$4 = (options) => {
return OptionsSchema$4.parse(options);
};
const ResponseSchema$4 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ locationMessage: zod_mini.object({
degreesLatitude: zod_mini.number(),
degreesLongitude: zod_mini.number(),
name: zod_mini.string(),
address: zod_mini.string()
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response$4 = (response) => {
const data = ResponseSchema$4.parse(response);
const { locationMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
location: {
latitude: locationMessage.degreesLatitude,
longitude: locationMessage.degreesLongitude,
name: locationMessage.name,
address: locationMessage.address
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/sticker.ts
const OptionsSchema$3 = zod_mini.extend(BaseMessageOptionsSchema, { sticker: MediaSchema });
const Body$3 = (options) => {
return OptionsSchema$3.parse(options);
};
const ResponseSchema$3 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ stickerMessage: zod_mini.object({
url: zod_mini.url(),
fileSha256: zod_mini.base64(),
fileEncSha256: zod_mini.base64(),
mediaKey: zod_mini.base64(),
mimetype: zod_mini.optional(zod_mini.string()),
directPath: zod_mini.string(),
fileLength: zod_mini.coerce.number(),
mediaKeyTimestamp: zod_mini.coerce.date()
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response$3 = (response) => {
const data = ResponseSchema$3.parse(response);
const { stickerMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
media: {
url: stickerMessage.url,
mimetype: stickerMessage.mimetype,
length: stickerMessage.fileLength,
sha256: stickerMessage.fileSha256,
encryptedSha256: stickerMessage.fileEncSha256,
directPath: stickerMessage.directPath,
key: stickerMessage.mediaKey,
keyTimestamp: stickerMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/text.ts
const OptionsSchema$2 = zod_mini.extend(BaseMessageOptionsSchema, {
text: zod_mini.string().check(zod_mini.overwrite(replaceWithGreeting)),
linkPreview: zod_mini.optional(zod_mini.boolean())
});
const Body$2 = (options) => {
return OptionsSchema$2.parse(options);
};
const ResponseSchema$2 = zod_mini.object({
key: KeyResponseSchema,
messageTimestamp: zod_mini.coerce.date()
});
const Response$2 = (response) => {
const data = ResponseSchema$2.parse(response);
return {
receiver: ReceiverResponse(data.key.remoteJid),
messageId: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/video.ts
const OptionsSchema$1 = zod_mini.extend(BaseMessageOptionsSchema, {
video: MediaSchema,
caption: zod_mini.optional(zod_mini.string()).check(zod_mini.overwrite(replaceWithGreeting)),
mimetype: zod_mini.optional(zod_mini.string())
});
const Body$1 = (options) => {
const { video, ...data } = OptionsSchema$1.parse(options);
return {
...data,
media: video,
mediatype: "video"
};
};
const ResponseSchema$1 = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ videoMessage: zod_mini.object({
url: zod_mini.url(),
mimetype: zod_mini.optional(zod_mini.string()),
fileSha256: zod_mini.base64(),
fileLength: zod_mini.coerce.number(),
mediaKey: zod_mini.base64(),
caption: zod_mini.optional(zod_mini.string()),
gifPlayback: zod_mini.boolean(),
fileEncSha256: zod_mini.base64(),
directPath: zod_mini.string(),
mediaKeyTimestamp: zod_mini.coerce.date()
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response$1 = (response) => {
const data = ResponseSchema$1.parse(response);
const { videoMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
media: {
url: videoMessage.url,
caption: videoMessage.caption,
mimetype: videoMessage.mimetype,
gifPlayback: videoMessage.gifPlayback,
length: videoMessage.fileLength,
sha256: videoMessage.fileSha256,
encryptedSha256: videoMessage.fileEncSha256,
directPath: videoMessage.directPath,
key: videoMessage.mediaKey,
keyTimestamp: videoMessage.mediaKeyTimestamp
},
id: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/schemas/voice.ts
const OptionsSchema = zod_mini.extend(BaseMessageOptionsSchema, {
audio: MediaSchema,
encoding: zod_mini._default(zod_mini.optional(zod_mini.boolean()), true)
});
const Body = (options) => {
return OptionsSchema.parse(options);
};
const ResponseSchema = zod_mini.object({
key: KeyResponseSchema,
message: zod_mini.object({ audioMessage: zod_mini.object({
url: zod_mini.url(),
mimetype: zod_mini.string(),
fileSha256: zod_mini.base64(),
fileLength: zod_mini.coerce.number(),
seconds: zod_mini.number(),
ptt: zod_mini.optional(zod_mini.boolean()),
mediaKey: zod_mini.base64(),
fileEncSha256: zod_mini.base64(),
directPath: zod_mini.string(),
mediaKeyTimestamp: zod_mini.coerce.date(),
waveform: zod_mini.nullish(zod_mini.base64())
}) }),
messageTimestamp: zod_mini.coerce.date()
});
const Response = (response) => {
const data = ResponseSchema.parse(response);
const { audioMessage } = data.message;
return {
receiver: ReceiverResponse(data.key.remoteJid),
media: {
url: audioMessage.url,
mimetype: audioMessage.mimetype,
length: audioMessage.fileLength,
durationInSeconds: audioMessage.seconds,
sha256: audioMessage.fileSha256,
encryptedSha256: audioMessage.fileEncSha256,
directPath: audioMessage.directPath,
isPtt: audioMessage.ptt,
key: audioMessage.mediaKey,
keyTimestamp: audioMessage.mediaKeyTimestamp,
waveform: audioMessage.waveform
},
messageId: MessageId(data.key.id),
timestamp: data.messageTimestamp
};
};
//#endregion
//#region src/modules/messages/index.ts
var MessagesModule = class {
constructor(api) {
this.api = api;
}
/**
* Sends a text message
* @param options - Text message options
*/
async sendText(options) {
const body = Body$2(options);
const response = await this.api.post(Routes.Message.SendText, { body });
return Response$2(response);
}
/**
* Sends an image
* @param options - Image message options
*/
async sendImage(options) {
const body = Body$5(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return Response$5(response);
}
/**
* Sends a video
* @param options - Video message options
*/
async sendVideo(options) {
const body = Body$1(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return Response$1(response);
}
/**
* Sends a document
* @param options - Document message options
*/
async sendDocument(options) {
const body = Body$6(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return Response$6(response);
}
/**
* Sends an audio
* @param options - Audio message options
*/
async sendAudio(options) {
const body = Body$8(options);
const response = await this.api.post(Routes.Message.SendMedia, { body });
return Response$8(response);
}
/**
* Sends a voice message
* @param options - Voice message options
*/
async sendVoice(options) {
const body = Body(options);
const response = await this.api.post(Routes.Message.SendVoice, { body });
return Response(response);
}
/**
* Sends a sticker
* @param options - Sticker message options
*/
async sendSticker(options) {
const body = Body$3(options);
const response = await this.api.post(Routes.Message.SendSticker, { body });
return Response$3(response);
}
/**
* Sends a location
* @param options - Location message options
*/
async sendLocation(options) {
const body = Body$4(options);
const response = await this.api.post(Routes.Message.SendLocation, { body });
return Response$4(response);
}
/**
* Sends a contact
* @param options - Contact message options
*/
async sendContact(options) {
const body = Body$7(options);
const response = await this.api.post(Routes.Message.SendContact, { body });
return Response$7(response);
}
};
//#endregion
//#region src/instance.ts
var EvolutionInstance = class {
/**
* API service for directly interacting with the Evolution API
*/
api;
/**
* Find and manage chats, send presences and check numbers
*/
chats;
/**
* Find and manage groups
*/
groups;
/**
* Send messages
*/
messages;
/**
* Evolution Instance - API client for interacting with the Evolution API for instance routes
* @param instance - Instance name
* @param options - Client options
*/
constructor(instance, options) {
this.instance = instance;
this.options = options;
zod_mini.string().parse(instance);
ClientOptionsSchema.parse(options);
this.api = new InstanceApi(instance, options);
this.chats = new ChatsModule(this.api);
this.groups = new GroupsModule(this.api);
this.messages = new MessagesModule(this.api);
}
};
//#endregion
//#region src/index.ts
var EvolutionClient = class {
/**
* API service for directly interacting with the Evolution API (no specific typings)
*/
api;
/**
* Find and manage instances
*/
instances;
/**
* Evolution Client - API client for interacting with the Evolution API
* @param options - Client options
*/
constructor(options) {
this.options = options;
ClientOptionsSchema.parse(options);
this.api = new EvolutionApi(options);
this.instances = new InstancesModule(this.api);
}
};
//#endregion
exports.ChatId = ChatId;
exports.EvolutionApiError = EvolutionApiError;
exports.EvolutionClient = EvolutionClient;
exports.EvolutionInstance = EvolutionInstance;
exports.GroupJid = GroupJid;
exports.Jid = Jid;
exports.MessageId = MessageId;
exports.phoneNumberFromJid = phoneNumberFromJid;