@gymspace/evolution 1.0.0

package/src/modules/messages/schemas/sticker.ts

@@ -0,0 +1,77 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import type { Media } from "@/schemas/common";
+import { Jid, MessageId } from "@/types/tags";
+import { phoneNumberFromJid } from "@/utils/phone-numer-from-jid";
+import { BaseMessageOptions } from "./base";
+
+// Raw response interface from API
+export interface StickerMessageResponseRaw {
+	key: {
+		remoteJid: string;
+		id: string;
+	};
+	message: {
+		stickerMessage: {
+			url: string;
+			fileSha256: string;
+			fileEncSha256: string;
+			mediaKey: string;
+			mimetype?: string;
+			directPath: string;
+			fileLength: number | string;
+			mediaKeyTimestamp: number | string;
+		};
+	};
+	messageTimestamp: string | Date;
+}
+
+// Request interfaces
+export interface StickerMessageOptions extends BaseMessageOptions {
+	/**
+	 * Image URL or file in base64
+	 */
+	sticker: Media;
+}
+
+// Response interfaces
+export interface StickerMessageResponse {
+	receiver: {
+		phoneNumber: string;
+		jid: Jid;
+	};
+	media: {
+		url: string;
+		mimetype?: string;
+		length: number;
+		sha256: string;
+		encryptedSha256: string;
+		directPath: string;
+		key: string;
+		keyTimestamp: Date;
+	};
+	id: MessageId;
+	timestamp: Date;
+}
+
+// Transform function
+export const StickerMessageResponseTransform = (data: StickerMessageResponseRaw): StickerMessageResponse => ({
+	receiver: {
+		phoneNumber: phoneNumberFromJid(data.key.remoteJid),
+		jid: Jid(data.key.remoteJid),
+	},
+	media: {
+		url: data.message.stickerMessage.url,
+		mimetype: data.message.stickerMessage.mimetype,
+		length: Number(data.message.stickerMessage.fileLength),
+		sha256: data.message.stickerMessage.fileSha256,
+		encryptedSha256: data.message.stickerMessage.fileEncSha256,
+		directPath: data.message.stickerMessage.directPath,
+		key: data.message.stickerMessage.mediaKey,
+		keyTimestamp: new Date(Number(data.message.stickerMessage.mediaKeyTimestamp)),
+	},
+	id: MessageId(data.key.id),
+	timestamp: new Date(data.messageTimestamp),
+});
+
+// Backward compatibility aliases
+export const ResponseSchema = { parse: StickerMessageResponseTransform };

package/src/modules/messages/schemas/template.ts

@@ -0,0 +1,39 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import type { ChatId, MessageId } from "@/types/tags";
+
+export interface ComponentParameter {
+  type: "text" | "image" | "document" | "video";
+  text?: string;
+  image?: { link: string };
+  document?: { link: string };
+  video?: { link: string };
+}
+
+export interface Component {
+  type: "body" | "header" | "button";
+  sub_type?: "text" | "url" | "quick_reply";
+  parameters: ComponentParameter[];
+}
+
+export interface TemplateMessageOptions {
+  number: ChatId;
+  name: string;
+  language: {
+    code: string;
+  };
+  components: Component[];
+  options?: {
+    delay?: number;
+    messageId?: MessageId;
+  };
+}
+
+export interface TemplateMessageResponse {
+  key: {
+    remoteJid: ChatId;
+    fromMe: boolean;
+    id: MessageId;
+  };
+  messageTimestamp: string;
+  status: string;
+} 

package/src/modules/messages/schemas/text.ts

@@ -0,0 +1,88 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { Jid, MessageId } from "@/types/tags";
+import { phoneNumberFromJid } from "@/utils/phone-numer-from-jid";
+import { BaseMessageOptions } from "./base";
+
+// Raw response interface from API
+export interface TextMessageResponseRaw {
+  key: {
+    remoteJid: string;
+    fromMe: boolean;
+    id: string;
+  };
+  pushName: string;
+  status: string;
+  message: {
+    conversation: string;
+  };
+  contextInfo: null;
+  messageType: string;
+  messageTimestamp: number;
+  instanceId: string;
+  source: string;
+}
+
+// Request interfaces
+export interface TextMessageOptions extends BaseMessageOptions {
+  /**
+   * Message text content
+   */
+  text: string;
+  /**
+   * Whether link preview should be shown
+   */
+  linkPreview?: boolean;
+}
+
+// Response interfaces
+export interface TextMessageResponse {
+  key: {
+    remoteJid: string;
+    fromMe: boolean;
+    id: string;
+  };
+  pushName: string;
+  status: string;
+  message: {
+    conversation: string;
+  };
+  contextInfo: null;
+  messageType: string;
+  messageTimestamp: number;
+  instanceId: string;
+  source: string;
+  receiver: {
+    phoneNumber: string;
+    jid: Jid;
+  };
+  messageId: MessageId;
+  timestamp: Date;
+}
+
+export interface TextMessageReceived {
+  conversation: string;
+  extendedTextMessage: {
+    text: string;
+  };
+}
+
+// Transform function
+export const TextMessageResponseTransform = (
+  data: TextMessageResponseRaw
+): TextMessageResponse => ({
+  receiver: {
+    phoneNumber: phoneNumberFromJid(data.key.remoteJid),
+    jid: Jid(data.key.remoteJid),
+  },
+  messageId: MessageId(data.key.id),
+  timestamp: new Date(data.messageTimestamp),
+  key: data.key,
+  pushName: data.pushName,
+  status: data.status,
+  message: data.message,
+  contextInfo: data.contextInfo,
+  messageType: data.messageType,
+  messageTimestamp: data.messageTimestamp,
+  instanceId: data.instanceId,
+  source: data.source,
+});

package/src/modules/messages/schemas/video.ts

@@ -0,0 +1,12 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import { MediaMessageOptions, MediaMessageResponse } from "./media";
+
+// Request interfaces
+export interface VideoMessageOptions extends MediaMessageOptions {}
+
+// Response interfaces
+export interface VideoMessageResponse extends MediaMessageResponse {
+  message: MediaMessageResponse["message"] & {
+    videoMessage: MediaMessageResponse["message"]["videoMessage"];
+  };
+}

package/src/modules/messages/schemas/voice.ts

@@ -0,0 +1,94 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import type { Media } from "@/schemas/common";
+import { Jid, MessageId } from "@/types/tags";
+import { phoneNumberFromJid } from "@/utils/phone-numer-from-jid";
+import { BaseMessageOptions } from "./base";
+
+// Raw response interface from API
+export interface VoiceMessageResponseRaw {
+	key: {
+		remoteJid: string;
+		id: string;
+	};
+	message: {
+		audioMessage: {
+			url: string;
+			mimetype: string;
+			fileSha256: string;
+			fileLength: number | string;
+			seconds: number;
+			ptt?: boolean;
+			mediaKey: string;
+			fileEncSha256: string;
+			directPath: string;
+			mediaKeyTimestamp: number | string;
+			waveform?: string | null;
+		};
+	};
+	messageTimestamp: string | Date;
+}
+
+// Request interfaces
+export interface VoiceMessageOptions extends BaseMessageOptions {
+	/**
+	 * Audio URL or file in base64
+	 */
+	audio: Media;
+	/**
+	 * Encode audio into WhatsApp default format (allows audio to be sped up)
+	 * @default true
+	 */
+	encoding?: boolean;
+}
+
+// Response interfaces
+export interface VoiceMessageResponse {
+	receiver: {
+		phoneNumber: string;
+		jid: Jid;
+	};
+	media: {
+		url: string;
+		mimetype: string;
+		length: number;
+		durationInSeconds: number;
+		sha256: string;
+		encryptedSha256: string;
+		directPath: string;
+		/**
+		 * Indicates whether the audio message is a push-to-talk (PTT) message
+		 */
+		isPtt?: boolean;
+		key: string;
+		keyTimestamp: Date;
+		waveform?: string | null;
+	};
+	messageId: MessageId;
+	timestamp: Date;
+}
+
+// Transform function
+export const VoiceMessageResponseTransform = (data: VoiceMessageResponseRaw): VoiceMessageResponse => ({
+	receiver: {
+		phoneNumber: phoneNumberFromJid(data.key.remoteJid),
+		jid: Jid(data.key.remoteJid),
+	},
+	media: {
+		url: data.message.audioMessage.url,
+		mimetype: data.message.audioMessage.mimetype,
+		length: Number(data.message.audioMessage.fileLength),
+		durationInSeconds: data.message.audioMessage.seconds,
+		sha256: data.message.audioMessage.fileSha256,
+		encryptedSha256: data.message.audioMessage.fileEncSha256,
+		directPath: data.message.audioMessage.directPath,
+		isPtt: data.message.audioMessage.ptt,
+		key: data.message.audioMessage.mediaKey,
+		keyTimestamp: new Date(Number(data.message.audioMessage.mediaKeyTimestamp)),
+		waveform: data.message.audioMessage.waveform,
+	},
+	messageId: MessageId(data.key.id),
+	timestamp: new Date(data.messageTimestamp),
+});
+
+// Backward compatibility aliases
+export const ResponseSchema = { parse: VoiceMessageResponseTransform };

package/src/modules/profile/index.ts

@@ -0,0 +1,110 @@
+import { Routes } from "@/api/routes";
+import type { ApiService } from "@/api/service";
+import type { MethodOptions } from "@/types/api";
+
+import type * as FetchBusinessProfile from "./schemas/fetch-business-profile";
+import type * as FetchPrivacySettings from "./schemas/fetch-privacy-settings";
+import type * as FetchProfile from "./schemas/fetch-profile";
+import type * as RemovePicture from "./schemas/remove-picture";
+import type * as UpdateName from "./schemas/update-name";
+import type * as UpdatePicture from "./schemas/update-picture";
+import type * as UpdatePrivacySettings from "./schemas/update-privacy-settings";
+import type * as UpdateStatus from "./schemas/update-status";
+
+export class ProfileModule {
+  constructor(private readonly api: ApiService) {}
+
+  async fetchBusinessProfile(
+    options: FetchBusinessProfile.FetchBusinessProfileRequest,
+    methodOptions?: MethodOptions
+  ): Promise<FetchBusinessProfile.FetchBusinessProfileResponse> {
+    const response = await this.api.post(Routes.Profile.FetchBusinessProfile, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as FetchBusinessProfile.FetchBusinessProfileResponse;
+  }
+
+  async fetchProfile(
+    options: FetchProfile.FetchProfileRequest,
+    methodOptions?: MethodOptions
+  ): Promise<FetchProfile.FetchProfileResponse> {
+    const response = await this.api.post(Routes.Profile.FetchProfile, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as FetchProfile.FetchProfileResponse;
+  }
+
+  async updateName(
+    options: UpdateName.UpdateNameRequest,
+    methodOptions?: MethodOptions
+  ): Promise<UpdateName.UpdateNameResponse> {
+    const response = await this.api.post(Routes.Profile.UpdateName, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as UpdateName.UpdateNameResponse;
+  }
+
+  async updateStatus(
+    options: UpdateStatus.UpdateStatusRequest,
+    methodOptions?: MethodOptions
+  ): Promise<UpdateStatus.UpdateStatusResponse> {
+    const response = await this.api.post(Routes.Profile.UpdateStatus, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as UpdateStatus.UpdateStatusResponse;
+  }
+
+  async updatePicture(
+    options: UpdatePicture.UpdatePictureRequest,
+    methodOptions?: MethodOptions
+  ): Promise<UpdatePicture.UpdatePictureResponse> {
+    const response = await this.api.post(Routes.Profile.UpdatePicture, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as UpdatePicture.UpdatePictureResponse;
+  }
+
+  async removePicture(
+    methodOptions?: MethodOptions
+  ): Promise<RemovePicture.RemovePictureResponse> {
+    const response = await this.api.delete(
+      Routes.Profile.RemovePicture,
+      methodOptions
+    );
+
+    return response as RemovePicture.RemovePictureResponse;
+  }
+
+  async fetchPrivacySettings(
+    methodOptions?: MethodOptions
+  ): Promise<FetchPrivacySettings.FetchPrivacySettingsResponse> {
+    const response = await this.api.get(
+      Routes.Profile.FetchPrivacySettings,
+      methodOptions
+    );
+
+    return response as FetchPrivacySettings.FetchPrivacySettingsResponse;
+  }
+
+  async updatePrivacySettings(
+    options: UpdatePrivacySettings.UpdatePrivacySettingsRequest,
+    methodOptions?: MethodOptions
+  ): Promise<UpdatePrivacySettings.UpdatePrivacySettingsResponse> {
+    const response = await this.api.put(Routes.Profile.UpdatePrivacySettings, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as UpdatePrivacySettings.UpdatePrivacySettingsResponse;
+  }
+}

package/src/modules/profile/schemas/fetch-business-profile.ts

@@ -0,0 +1,29 @@
+// Pure TypeScript interfaces for better IDE support and performance
+
+export interface FetchBusinessProfileRequest {
+  number: string;
+}
+
+export interface BusinessHoursConfig {
+  day_of_week: "sun" | "mon" | "tue" | "wed" | "thu" | "fri" | "sat";
+  mode: "open_24h" | "specific_hours" | "closed";
+  open_time?: string;
+  close_time?: string;
+}
+
+export interface BusinessHours {
+  timezone: string;
+  business_config: BusinessHoursConfig[];
+}
+
+export interface FetchBusinessProfileResponse {
+  isBusiness: boolean;
+  wid: string;
+  description: string;
+  website: string[];
+  category: string;
+  business_hours: BusinessHours;
+}
+
+// Backward compatibility aliases
+export type FetchBusinessProfileOptions = FetchBusinessProfileRequest; 

package/src/modules/profile/schemas/fetch-privacy-settings.ts

@@ -0,0 +1,11 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export type PrivacySetting = "all" | "contacts" | "contact_blacklist" | "none";
+
+export interface FetchPrivacySettingsResponse {
+  online: PrivacySetting;
+  profile: PrivacySetting;
+  status: PrivacySetting;
+  readreceipts: PrivacySetting;
+  last: PrivacySetting;
+  groupadd: PrivacySetting;
+} 

package/src/modules/profile/schemas/fetch-profile.ts

@@ -0,0 +1,23 @@
+// Pure TypeScript interfaces for better IDE support and performance
+
+export interface FetchProfileRequest {
+  number: string;
+}
+
+export interface ProfileStatus {
+  status: string;
+  setAt: string;
+}
+
+export interface FetchProfileResponse {
+  wuid: string;
+  name: string | null;
+  numberExists: boolean;
+  picture?: string;
+  status?: ProfileStatus;
+  isBusiness: boolean;
+  description?: string;
+}
+
+// Backward compatibility aliases
+export type FetchProfileOptions = FetchProfileRequest; 

package/src/modules/profile/schemas/index.ts

@@ -0,0 +1,8 @@
+export * from "./fetch-business-profile";
+export * from "./fetch-profile";
+export * from "./fetch-privacy-settings";
+export * from "./remove-picture";
+export * from "./update-name";
+export { type UpdatePictureOptions as UpdateProfilePictureOptions, type UpdatePictureResponse as UpdateProfilePictureResponse } from "./update-picture";
+export * from "./update-privacy-settings";
+export * from "./update-status"; 

package/src/modules/profile/schemas/remove-picture.ts

@@ -0,0 +1,4 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface RemovePictureResponse {
+  status: string;
+} 

package/src/modules/profile/schemas/update-name.ts

@@ -0,0 +1,11 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface UpdateNameRequest {
+  name: string;
+}
+
+export interface UpdateNameResponse {
+  update: "success" | "error";
+}
+
+// Backward compatibility aliases
+export type UpdateNameOptions = UpdateNameRequest; 

package/src/modules/profile/schemas/update-picture.ts

@@ -0,0 +1,11 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface UpdatePictureRequest {
+  picture: string;
+}
+
+export interface UpdatePictureResponse {
+  update: "success" | "error";
+}
+
+// Backward compatibility aliases
+export type UpdatePictureOptions = UpdatePictureRequest; 

package/src/modules/profile/schemas/update-privacy-settings.ts

@@ -0,0 +1,18 @@
+// Pure TypeScript interfaces for better IDE support and performance
+import type { PrivacySetting } from "./fetch-privacy-settings";
+
+export interface UpdatePrivacySettingsRequest {
+	online?: PrivacySetting;
+	profile?: PrivacySetting;
+	status?: PrivacySetting;
+	readreceipts?: PrivacySetting;
+	last?: PrivacySetting;
+	groupadd?: PrivacySetting;
+}
+
+export interface UpdatePrivacySettingsResponse {
+  status: string;
+}
+
+// Backward compatibility aliases
+export type UpdatePrivacySettingsOptions = UpdatePrivacySettingsRequest; 

package/src/modules/profile/schemas/update-status.ts

@@ -0,0 +1,11 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface UpdateStatusRequest {
+  status: string;
+}
+
+export interface UpdateStatusResponse {
+  status: string;
+}
+
+// Backward compatibility aliases
+export type UpdateStatusOptions = UpdateStatusRequest; 

package/src/modules/settings/index.ts

@@ -0,0 +1,28 @@
+import { Routes } from "@/api/routes";
+import type { ApiService } from "@/api/service";
+import type { MethodOptions } from "@/types/api";
+
+import type * as Find from "./schemas/find";
+import type * as Set from "./schemas/set";
+
+export class SettingsModule {
+  constructor(private readonly api: ApiService) {}
+
+  async set(
+    options: Set.SetRequest,
+    methodOptions?: MethodOptions
+  ): Promise<Set.SetResponse> {
+    const response = await this.api.post(Routes.Settings.Set, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Set.SetResponse;
+  }
+
+  async find(methodOptions?: MethodOptions): Promise<Find.FindResponse> {
+    const response = await this.api.get(Routes.Settings.Find, methodOptions);
+
+    return response as Find.FindResponse;
+  }
+}

package/src/modules/settings/schemas/find.ts

@@ -0,0 +1,11 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface FindResponse {
+  rejectCall: boolean;
+  msgCall: string;
+  groupsIgnore: boolean;
+  alwaysOnline: boolean;
+  readMessages: boolean;
+  readStatus: boolean;
+  syncFullHistory: boolean;
+  wavoipToken: string;
+}

package/src/modules/settings/schemas/index.ts

@@ -0,0 +1,2 @@
+export { type FindResponse as FindSettingsResponse } from "./find";
+export { type SetOptions as SetSettingsOptions, type SetResponse as SetSettingsResponse } from "./set"; 

package/src/modules/settings/schemas/set.ts

@@ -0,0 +1,18 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface SetRequest {
+  rejectCall?: boolean;
+  msgCall?: string;
+  groupsIgnore: boolean; // Required by API
+  alwaysOnline: boolean; // Required by API
+  readMessages: boolean; // Required by API
+  readStatus: boolean; // Required by API
+  syncFullHistory: boolean; // Required by API
+  wavoipToken?: string;
+}
+
+export interface SetResponse {
+  message: string;
+}
+
+// Backward compatibility aliases
+export type SetOptions = SetRequest;

package/src/modules/webhook/index.ts

@@ -0,0 +1,28 @@
+import { Routes } from "@/api/routes";
+import type { ApiService } from "@/api/service";
+import type { MethodOptions } from "@/types/api";
+
+import type * as Find from "./schemas/find";
+import type * as Set from "./schemas/set";
+
+export class WebhookModule {
+  constructor(private readonly api: ApiService) {}
+
+  async set(
+    options: Set.SetRequest,
+    methodOptions?: MethodOptions
+  ): Promise<Set.SetResponse> {
+    const response = await this.api.post(Routes.Webhook.Set, {
+      body: options,
+      ...methodOptions,
+    });
+
+    return response as Set.SetResponse;
+  }
+
+  async find(methodOptions?: MethodOptions): Promise<Find.FindResponse> {
+    const response = await this.api.get(Routes.Webhook.Find, methodOptions);
+
+    return response as Find.FindResponse;
+  }
+}

package/src/modules/webhook/schemas/find.ts

@@ -0,0 +1,7 @@
+// Pure TypeScript interfaces for better IDE support and performance
+export interface FindResponse {
+  webhook: string;
+  enabled: boolean;
+  webhook_by_events: boolean;
+  events: string[];
+} 

package/src/modules/webhook/schemas/index.ts

@@ -0,0 +1,2 @@
+export { type FindResponse as FindWebhookResponse } from "./find";
+export { type SetOptions as SetWebhookOptions, type SetResponse as SetWebhookResponse } from "./set"; 

package/src/modules/webhook/schemas/set.ts

@@ -0,0 +1,16 @@
+import { WebhookEventSetup } from "@/types/events";
+// Pure TypeScript interfaces for better IDE support and performance
+export interface SetRequest {
+  enabled: boolean;
+  url: string;
+  webhookByEvents: boolean;
+  webhookBase64: boolean;
+  events: WebhookEventSetup[];
+}
+
+export interface SetResponse {
+  message: string;
+}
+
+// Backward compatibility aliases
+export type SetOptions = SetRequest;