@green-api/greenapi-integration 0.1.0

package/dist/core/base-adapter.d.ts

@@ -0,0 +1,23 @@
+import { GreenApiClient } from "./green-api.client";
+import { MessageTransformer } from "./message-transformer";
+import { BaseInstance, BaseUser, ForwardMessagesResponse, IncomingGreenApiWebhook, Instance, SendResponse, Settings } from "../types/types";
+import { StorageProvider } from "./storage-provider";
+export declare abstract class BaseAdapter<TPlatformWebhook, TPlatformMessage, TUser extends BaseUser = BaseUser, TInstance extends BaseInstance = Instance> {
+    protected transformer: MessageTransformer<TPlatformWebhook, TPlatformMessage>;
+    protected storage: StorageProvider<TUser, TInstance>;
+    constructor(transformer: MessageTransformer<TPlatformWebhook, TPlatformMessage>, storage: StorageProvider<TUser, TInstance>);
+    abstract sendToPlatform(message: TPlatformMessage, instance: TInstance): Promise<void>;
+    createGreenApiClient(instance: BaseInstance): GreenApiClient;
+    private handleError;
+    abstract createPlatformClient(params: any): Promise<any>;
+    handlePlatformWebhook(message: TPlatformWebhook, idInstance: number | bigint): Promise<SendResponse | ForwardMessagesResponse>;
+    handleGreenApiWebhook(webhook: IncomingGreenApiWebhook, allowedTypes: string[]): Promise<void>;
+    createInstance(instance: Instance, settings: Settings, userCred: any): Promise<TInstance>;
+    removeInstance(idInstance: number | bigint): Promise<TInstance>;
+    getInstance(idInstance: number | bigint): Promise<TInstance | null>;
+    updateUser(userCred: any, userUpdateData: any): Promise<{
+        status: string;
+        message: string;
+    }>;
+    createUser(userCred: any, data: any): Promise<TUser>;
+}

package/dist/core/base-adapter.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAdapter = void 0;
+const green_api_client_1 = require("./green-api.client");
+const errors_1 = require("./errors");
+class BaseAdapter {
+    constructor(transformer, storage) {
+        this.transformer = transformer;
+        this.storage = storage;
+    }
+    createGreenApiClient(instance) {
+        return new green_api_client_1.GreenApiClient({
+            idInstance: instance.idInstance,
+            apiTokenInstance: instance.apiTokenInstance,
+        });
+    }
+    handleError(context, error) {
+        if (error instanceof errors_1.IntegrationError) {
+            throw error;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        throw new errors_1.IntegrationError(`${context}: ${errorMessage}`, "UNEXPECTED_ERROR", 500, { originalError: error });
+    }
+    async handlePlatformWebhook(message, idInstance) {
+        try {
+            const instance = await this.storage.getInstance(idInstance);
+            if (!instance) {
+                throw new errors_1.IntegrationError("Instance not found", "INSTANCE_NOT_FOUND", 404);
+            }
+            const client = this.createGreenApiClient(instance);
+            const transformedMessage = this.transformer.toGreenApiMessage(message);
+            switch (transformedMessage.type) {
+                case "url-file":
+                    return client.sendFileByUrl(transformedMessage);
+                case "upload-file":
+                    return client.sendFileByUpload(transformedMessage);
+                case "text":
+                    return client.sendMessage(transformedMessage);
+                case "poll":
+                    return client.sendPoll(transformedMessage);
+                case "contact":
+                    return client.sendContact(transformedMessage);
+                case "location":
+                    return client.sendLocation(transformedMessage);
+                case "forward":
+                    return client.forwardMessages(transformedMessage);
+                default:
+                    throw new Error("Invalid file message format");
+            }
+        }
+        catch (error) {
+            this.handleError("Failed to handle incoming message", error);
+        }
+    }
+    async handleGreenApiWebhook(webhook, allowedTypes) {
+        if (!allowedTypes.includes(webhook.typeWebhook)) {
+            return;
+        }
+        try {
+            const transformedMessage = await this.transformer.toPlatformMessage(webhook);
+            const instance = await this.storage.getInstance(webhook.instanceData.idInstance);
+            if (!instance) {
+                throw new errors_1.NotFoundError("Instance not found");
+            }
+            await this.sendToPlatform(transformedMessage, instance);
+        }
+        catch (error) {
+            this.handleError("Failed to handle GREEN-API webhook", error);
+        }
+    }
+    async createInstance(instance, settings, userCred) {
+        console.log(instance, settings, userCred);
+        try {
+            const user = await this.storage.findUser(userCred);
+            if (!user) {
+                throw new errors_1.NotFoundError("No user with such credentials");
+            }
+            const client = this.createGreenApiClient(instance);
+            try {
+                await client.getSettings();
+            }
+            catch (error) {
+                throw new errors_1.IntegrationError(`Failed to get settings for instance ${instance.idInstance}: ${error.message}`, "INTEGRATION_ERROR");
+            }
+            const createdInstance = await this.storage.createInstance(instance, user.id, settings);
+            await client.setSettings(settings);
+            return createdInstance;
+        }
+        catch (error) {
+            this.handleError("Failed to add instance", error);
+        }
+    }
+    async removeInstance(idInstance) {
+        try {
+            const instance = await this.storage.getInstance(idInstance);
+            if (!instance) {
+                throw new errors_1.NotFoundError("No instance with such ID");
+            }
+            return this.storage.removeInstance(idInstance);
+        }
+        catch (error) {
+            this.handleError("Failed to remove instance", error);
+        }
+    }
+    async getInstance(idInstance) {
+        try {
+            return this.storage.getInstance(idInstance);
+        }
+        catch (error) {
+            this.handleError("Failed to remove instance", error);
+        }
+    }
+    async updateUser(userCred, userUpdateData) {
+        try {
+            await this.storage.updateUser(userCred, userUpdateData);
+            return { status: "ok", message: "Token updated successfully" };
+        }
+        catch (error) {
+            this.handleError(`Failed to update user ${userCred}`, error);
+        }
+    }
+    async createUser(userCred, data) {
+        const existingUser = await this.storage.findUser(userCred);
+        if (existingUser) {
+            throw new errors_1.BadRequestError("User already created");
+        }
+        try {
+            return this.storage.createUser(data);
+        }
+        catch (error) {
+            this.handleError(`Failed to create user ${userCred}`, error);
+        }
+    }
+}
+exports.BaseAdapter = BaseAdapter;

package/dist/core/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class IntegrationError extends Error {
+    readonly code: string;
+    readonly statusCode: number;
+    readonly details?: unknown | undefined;
+    constructor(message: string, code: string, statusCode?: number, details?: unknown | undefined);
+}
+export declare class BadRequestError extends IntegrationError {
+    constructor(message: string, details?: unknown);
+}
+export declare class AuthenticationError extends IntegrationError {
+    constructor(message: string);
+}
+export declare class NotFoundError extends IntegrationError {
+    constructor(message: string);
+}

package/dist/core/errors.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = exports.AuthenticationError = exports.BadRequestError = exports.IntegrationError = void 0;
+class IntegrationError extends Error {
+    constructor(message, code, statusCode = 500, details) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.details = details;
+        this.name = "IntegrationError";
+    }
+}
+exports.IntegrationError = IntegrationError;
+class BadRequestError extends IntegrationError {
+    constructor(message, details) {
+        super(message, "VALIDATION_ERROR", 400, details);
+    }
+}
+exports.BadRequestError = BadRequestError;
+class AuthenticationError extends IntegrationError {
+    constructor(message) {
+        super(message, "AUTHENTICATION_ERROR", 401);
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class NotFoundError extends IntegrationError {
+    constructor(message) {
+        super(message, "NOT_FOUND_ERROR", 404);
+    }
+}
+exports.NotFoundError = NotFoundError;

package/dist/core/green-api.client.d.ts

@@ -0,0 +1,28 @@
+import { Instance, Settings, SendMessage, SendFileByUrl, SendFileByUpload, SendPoll, StateInstance, Reboot, Logout, QR, SendResponse, SendFileByUploadResponse, SetSettingsResponse, GetAuthorizationCode, SetProfilePicture, WaSettings, UploadFile, SendLocation, SendContact, ForwardMessages, ForwardMessagesResponse } from "../types/types";
+export declare class GreenApiClient {
+    private instance;
+    private client;
+    private readonly baseUrl;
+    constructor(instance: Instance);
+    private buildUrl;
+    private buildEndpoint;
+    private makeRequest;
+    private makeFileUploadRequest;
+    sendMessage(message: SendMessage): Promise<SendResponse>;
+    sendFileByUrl(message: SendFileByUrl): Promise<SendResponse>;
+    sendFileByUpload(message: SendFileByUpload): Promise<SendFileByUploadResponse>;
+    sendPoll(message: SendPoll): Promise<SendResponse>;
+    forwardMessages(request: ForwardMessages): Promise<ForwardMessagesResponse>;
+    sendLocation(message: SendLocation): Promise<SendResponse>;
+    sendContact(message: SendContact): Promise<SendResponse>;
+    reboot(): Promise<Reboot>;
+    logout(): Promise<Logout>;
+    getStateInstance(): Promise<StateInstance>;
+    getQR(): Promise<QR>;
+    getSettings(): Promise<Settings>;
+    setSettings(settings: Settings): Promise<SetSettingsResponse>;
+    getWaSettings(): Promise<WaSettings>;
+    setProfilePicture(file: Blob | File): Promise<SetProfilePicture>;
+    uploadFile(file: Blob | File, customFileName?: string): Promise<UploadFile>;
+    getAuthorizationCode(phoneNumber: number): Promise<GetAuthorizationCode>;
+}

package/dist/core/green-api.client.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GreenApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+class GreenApiClient {
+    constructor(instance) {
+        this.instance = instance;
+        this.baseUrl = "https://api.green-api.com";
+        this.client = axios_1.default.create({
+            baseURL: this.buildUrl(),
+        });
+    }
+    buildUrl() {
+        return `${this.baseUrl}/waInstance${this.instance.idInstance}`;
+    }
+    buildEndpoint(endpoint) {
+        return `/${endpoint}/${this.instance.apiTokenInstance}`;
+    }
+    async makeRequest(method, endpoint, data, config) {
+        try {
+            const response = await (method === "get"
+                ? this.client.get(this.buildEndpoint(endpoint), config)
+                : this.client.post(this.buildEndpoint(endpoint), data, config));
+            return response.data;
+        }
+        catch (error) {
+            throw new Error(`Failed to ${endpoint.replace(/([A-Z])/g, " $1").toLowerCase()}: ${error.message}`);
+        }
+    }
+    async makeFileUploadRequest(endpoint, formData, headers) {
+        return this.makeRequest("post", endpoint, formData, {
+            headers: { "Content-Type": "multipart/form-data" },
+            ...headers,
+        });
+    }
+    async sendMessage(message) {
+        return this.makeRequest("post", "sendMessage", {
+            chatId: message.chatId,
+            message: message.message,
+            quotedMessageId: message.quotedMessageId,
+        });
+    }
+    async sendFileByUrl(message) {
+        return this.makeRequest("post", "sendFileByUrl", {
+            chatId: message.chatId,
+            urlFile: message.file.url,
+            fileName: message.file.fileName,
+            caption: message.caption,
+            quotedMessageId: message.quotedMessageId,
+        });
+    }
+    async sendFileByUpload(message) {
+        const formData = new FormData();
+        formData.append("file", message.file.data);
+        formData.append("chatId", message.chatId);
+        formData.append("fileName", message.file.fileName);
+        if (message.caption)
+            formData.append("caption", message.caption);
+        if (message.quotedMessageId)
+            formData.append("quotedMessageId", message.quotedMessageId);
+        return this.makeFileUploadRequest("sendFileByUpload", formData);
+    }
+    async sendPoll(message) {
+        return this.makeRequest("post", "sendPoll", {
+            chatId: message.chatId,
+            message: message.message,
+            options: message.options,
+            multipleAnswers: message.multipleAnswers,
+            quotedMessageId: message.quotedMessageId,
+        });
+    }
+    async forwardMessages(request) {
+        return this.makeRequest("post", "forwardMessages", {
+            chatId: request.chatId,
+            chatIdFrom: request.chatIdFrom,
+            messages: request.messages,
+        });
+    }
+    async sendLocation(message) {
+        return this.makeRequest("post", "sendLocation", {
+            chatId: message.chatId,
+            nameLocation: message.nameLocation,
+            address: message.address,
+            latitude: message.latitude,
+            longitude: message.longitude,
+            quotedMessageId: message.quotedMessageId,
+        });
+    }
+    async sendContact(message) {
+        return this.makeRequest("post", "sendContact", {
+            chatId: message.chatId,
+            contact: message.contact,
+            quotedMessageId: message.quotedMessageId,
+        });
+    }
+    async reboot() {
+        return this.makeRequest("get", "reboot");
+    }
+    async logout() {
+        return this.makeRequest("get", "logout");
+    }
+    async getStateInstance() {
+        return this.makeRequest("get", "getStateInstance");
+    }
+    async getQR() {
+        return this.makeRequest("get", "qr");
+    }
+    async getSettings() {
+        return this.makeRequest("get", "getSettings");
+    }
+    async setSettings(settings) {
+        return this.makeRequest("post", "setSettings", settings);
+    }
+    async getWaSettings() {
+        return this.makeRequest("get", "getWaSettings");
+    }
+    async setProfilePicture(file) {
+        const formData = new FormData();
+        formData.append("file", file);
+        return this.makeFileUploadRequest("setProfilePicture", formData);
+    }
+    async uploadFile(file, customFileName) {
+        const formData = new FormData();
+        formData.append("file", file);
+        const headers = {};
+        if (file instanceof File) {
+            const mimeType = file.type;
+            if (mimeType) {
+                headers["Content-Type"] = mimeType;
+            }
+            else if (customFileName) {
+                headers["GA-Filename"] = customFileName;
+            }
+        }
+        else if (customFileName) {
+            headers["GA-Filename"] = customFileName;
+        }
+        return this.makeFileUploadRequest("uploadFile", formData, headers);
+    }
+    async getAuthorizationCode(phoneNumber) {
+        if (!Number.isInteger(phoneNumber)) {
+            throw new Error("Phone number must contain only digits");
+        }
+        return this.makeRequest("post", "getAuthorizationCode", { phoneNumber });
+    }
+}
+exports.GreenApiClient = GreenApiClient;

package/dist/core/guard.d.ts

@@ -0,0 +1,7 @@
+import { BaseRequest } from "../types/types";
+import { StorageProvider } from "./storage-provider";
+export declare abstract class BaseGreenApiAuthGuard<T extends BaseRequest = BaseRequest> {
+    protected storage: StorageProvider;
+    constructor(storage: StorageProvider);
+    validateRequest(request: T): Promise<boolean>;
+}

package/dist/core/guard.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGreenApiAuthGuard = void 0;
+const errors_1 = require("./errors");
+class BaseGreenApiAuthGuard {
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async validateRequest(request) {
+        const token = request.headers["authorization"];
+        if (!token) {
+            throw new errors_1.AuthenticationError("Authentication header is missing");
+        }
+        const idInstance = request.body?.instanceData?.idInstance;
+        if (!idInstance) {
+            throw new errors_1.AuthenticationError("Invalid webhook format");
+        }
+        const instance = await this.storage.getInstance(idInstance);
+        if (!instance) {
+            throw new errors_1.AuthenticationError("No instance with such ID");
+        }
+        if (instance.settings?.webhookUrlToken !== token.split(" ")[1]) {
+            throw new errors_1.AuthenticationError("Invalid token");
+        }
+        return true;
+    }
+}
+exports.BaseGreenApiAuthGuard = BaseGreenApiAuthGuard;

package/dist/core/message-transformer.d.ts

@@ -0,0 +1,5 @@
+import { IncomingGreenApiWebhook, Message } from "../types/types";
+export declare abstract class MessageTransformer<TPlatformWebhook, TPlatformMessage> {
+    abstract toPlatformMessage(webhook: IncomingGreenApiWebhook): TPlatformMessage;
+    abstract toGreenApiMessage(message: TPlatformWebhook): Message;
+}

package/dist/core/message-transformer.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTransformer = void 0;
+class MessageTransformer {
+}
+exports.MessageTransformer = MessageTransformer;

package/dist/core/storage-provider.d.ts

@@ -0,0 +1,9 @@
+import { BaseInstance, BaseUser, Instance, Settings } from "../types/types";
+export declare abstract class StorageProvider<TUser extends BaseUser = BaseUser, TInstance extends BaseInstance = Instance, TUserCreate extends Record<string, any> = any, TUserUpdate extends Record<string, any> = any> {
+    abstract createInstance(instance: BaseInstance, userId: bigint | number, settings?: Settings): Promise<TInstance>;
+    abstract getInstance(idInstance: number | bigint): Promise<TInstance | null>;
+    abstract removeInstance(instanceId: number | bigint): Promise<TInstance>;
+    abstract createUser(data: TUserCreate): Promise<TUser>;
+    abstract findUser(identifier: string): Promise<TUser | null>;
+    abstract updateUser(identifier: string, data: Partial<TUserUpdate>): Promise<TUser>;
+}

package/dist/core/storage-provider.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageProvider = void 0;
+class StorageProvider {
+}
+exports.StorageProvider = StorageProvider;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types/types";
+export { BaseAdapter } from "./core/base-adapter";
+export { GreenApiClient } from "./core/green-api.client";
+export { MessageTransformer } from "./core/message-transformer";
+export { BaseGreenApiAuthGuard } from "./core/guard";
+export { StorageProvider } from "./core/storage-provider";
+export * from "./utils/helpers";

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageProvider = exports.BaseGreenApiAuthGuard = exports.MessageTransformer = exports.GreenApiClient = exports.BaseAdapter = void 0;
+__exportStar(require("./types/types"), exports);
+var base_adapter_1 = require("./core/base-adapter");
+Object.defineProperty(exports, "BaseAdapter", { enumerable: true, get: function () { return base_adapter_1.BaseAdapter; } });
+var green_api_client_1 = require("./core/green-api.client");
+Object.defineProperty(exports, "GreenApiClient", { enumerable: true, get: function () { return green_api_client_1.GreenApiClient; } });
+var message_transformer_1 = require("./core/message-transformer");
+Object.defineProperty(exports, "MessageTransformer", { enumerable: true, get: function () { return message_transformer_1.MessageTransformer; } });
+var guard_1 = require("./core/guard");
+Object.defineProperty(exports, "BaseGreenApiAuthGuard", { enumerable: true, get: function () { return guard_1.BaseGreenApiAuthGuard; } });
+var storage_provider_1 = require("./core/storage-provider");
+Object.defineProperty(exports, "StorageProvider", { enumerable: true, get: function () { return storage_provider_1.StorageProvider; } });
+__exportStar(require("./utils/helpers"), exports);

package/dist/types/types.d.ts

@@ -0,0 +1,178 @@
+export interface BaseInstance {
+    idInstance: number | bigint;
+    apiTokenInstance: string;
+    settings?: any;
+}
+export interface Instance extends BaseInstance {
+    [key: string]: any;
+}
+export type Message = SendMessage | SendFileByUpload | SendFileByUrl | SendPoll | SendLocation | SendContact | ForwardMessages;
+export interface BaseMessage {
+    type: SendMessageType;
+    chatId: string;
+    quotedMessageId?: string;
+}
+export type SendMessageType = "text" | "upload-file" | "url-file" | "poll" | "location" | "contact" | "forward";
+export interface SendMessage extends BaseMessage {
+    type: "text";
+    message: string;
+}
+export interface ForwardMessages {
+    type: "forward";
+    chatId: string;
+    chatIdFrom: string;
+    messages: string[];
+}
+export interface ForwardMessagesResponse {
+    messages: string[];
+}
+export interface Contact {
+    phoneContact: number;
+    firstName?: string;
+    middleName?: string;
+    lastName?: string;
+    company?: string;
+}
+export interface SendContact extends BaseMessage {
+    type: "contact";
+    contact: Contact;
+}
+export interface SendFileByUpload extends BaseMessage {
+    type: "upload-file";
+    caption?: string;
+    file: {
+        data: Blob | File;
+        fileName: string;
+    };
+}
+export interface SendFileByUrl extends BaseMessage {
+    type: "url-file";
+    caption?: string;
+    file: {
+        url: string;
+        fileName: string;
+    };
+}
+export interface SendLocation extends BaseMessage {
+    type: "location";
+    nameLocation?: string;
+    address?: string;
+    latitude: number;
+    longitude: number;
+}
+export interface PollOption {
+    optionName: string;
+}
+export interface SendPoll extends BaseMessage {
+    type: "poll";
+    message: string;
+    options: PollOption[];
+    multipleAnswers?: boolean;
+}
+export type MessageType = "textMessage" | "extendedTextMessage" | "imageMessage" | "videoMessage" | "documentMessage" | "audioMessage";
+export interface IncomingGreenApiWebhook {
+    typeWebhook: string;
+    instanceData: {
+        idInstance: number;
+        wid: string;
+        typeInstance: string;
+    };
+    timestamp: number;
+    idMessage: string;
+    senderData: {
+        chatId: string;
+        sender: string;
+        chatName?: string;
+        senderName?: string;
+        senderContactName?: string;
+    };
+    messageData: {
+        typeMessage: MessageType;
+        textMessageData?: {
+            textMessage: string;
+        };
+        extendedTextMessageData?: {
+            text: string;
+            description?: string;
+            title?: string;
+            jpegThumbnail?: string;
+            forwardingScore?: number;
+            isForwarded?: boolean;
+        };
+        fileMessageData?: {
+            downloadUrl: string;
+            caption?: string;
+            jpegThumbnail?: string;
+            mimeType: string;
+            forwardingScore?: number;
+            isForwarded?: boolean;
+            fileName: string;
+        };
+    };
+}
+export interface Settings {
+    wid?: string;
+    webhookUrl?: string;
+    webhookUrlToken?: string;
+    delaySendMessagesMilliseconds?: number;
+    markIncomingMessagesReaded?: "yes" | "no";
+    markIncomingMessagesReadedOnReply?: "yes" | "no";
+    outgoingWebhook?: "yes" | "no";
+    outgoingMessageWebhook?: "yes" | "no";
+    outgoingAPIMessageWebhook?: "yes" | "no";
+    stateWebhook?: "yes" | "no";
+    incomingWebhook?: "yes" | "no";
+    keepOnlineStatus?: "yes" | "no";
+    pollMessageWebhook?: "yes" | "no";
+    incomingCallWebhook?: "yes" | "no";
+}
+export interface Reboot {
+    isReboot: boolean;
+}
+export interface Logout {
+    isLogout: boolean;
+}
+export type InstanceState = "notAuthorized" | "authorized" | "blocked" | "starting" | "yellowCard";
+export interface StateInstance {
+    stateInstance: InstanceState;
+}
+export interface SendResponse {
+    idMessage: string;
+}
+export interface SendFileByUploadResponse {
+    idMessage: string;
+    urlFile: string;
+}
+export interface SetSettingsResponse {
+    saveSettings: boolean;
+}
+export interface QR {
+    type: "qrCode" | "error" | "alreadyLogged";
+    message: string;
+}
+export interface GetAuthorizationCode {
+    status: boolean;
+    code: string;
+}
+export interface UploadFile {
+    urlFile: string;
+}
+export interface WaSettings {
+    avatar: string;
+    phone: string;
+    stateInstance: InstanceState;
+    deviceId: string;
+}
+export interface SetProfilePicture {
+    reason: string | null;
+    urlAvatar: string;
+    setProfilePicture: boolean;
+}
+export interface BaseRequest {
+    headers: Record<string, any>;
+    body: any;
+}
+export interface BaseUser {
+    id: number | bigint;
+    [key: string]: any;
+}

package/dist/types/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });