cecon-interfaces 1.8.82 → 1.8.84

package/dist/index.d.ts

@@ -37,6 +37,15 @@ export * from './mercado-pago/interfaces';
 export * from './mobyo';
 export * from './monitor';
 export * from './mottu';
+export * from './n8n';
+export * from './n8n/entities/chat-api-callback.entity';
+export * from './n8n/entities/chat-context.entity';
+export * from './n8n/entities/chat-response.entity';
+export * from './n8n/entities/chat-trigger.entity';
+export * from './n8n/interfaces/i-chat-api-callback';
+export * from './n8n/interfaces/i-chat-context';
+export * from './n8n/interfaces/i-chat-response';
+export * from './n8n/interfaces/i-chat-trigger';
 export * from './nati-v1';
 export * from './nati-v2';
 export * from './natipay';

package/dist/index.js

@@ -53,6 +53,15 @@ __exportStar(require("./mercado-pago/interfaces"), exports);
 __exportStar(require("./mobyo"), exports);
 __exportStar(require("./monitor"), exports);
 __exportStar(require("./mottu"), exports);
+__exportStar(require("./n8n"), exports);
+__exportStar(require("./n8n/entities/chat-api-callback.entity"), exports);
+__exportStar(require("./n8n/entities/chat-context.entity"), exports);
+__exportStar(require("./n8n/entities/chat-response.entity"), exports);
+__exportStar(require("./n8n/entities/chat-trigger.entity"), exports);
+__exportStar(require("./n8n/interfaces/i-chat-api-callback"), exports);
+__exportStar(require("./n8n/interfaces/i-chat-context"), exports);
+__exportStar(require("./n8n/interfaces/i-chat-response"), exports);
+__exportStar(require("./n8n/interfaces/i-chat-trigger"), exports);
 __exportStar(require("./nati-v1"), exports);
 __exportStar(require("./nati-v2"), exports);
 __exportStar(require("./natipay"), exports);

package/dist/n8n/entities/chat-api-callback.entity.d.ts

@@ -0,0 +1,75 @@
+import { IN8nChatApiCallback } from '../interfaces/i-chat-api-callback';
+export declare class N8nChatApiCallbackEntity implements IN8nChatApiCallback {
+    callApi: boolean;
+    callbackId: string;
+    apiUrl: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers: {
+        authorization?: string;
+        contentType?: string;
+        userAgent?: string;
+        customHeaders?: Record<string, string>;
+    };
+    payload?: {
+        userData?: {
+            userId: string;
+            name?: string;
+            phone?: string;
+            email?: string;
+        };
+        formData?: Record<string, any>;
+        contextData?: {
+            sessionId: string;
+            messageId: string;
+            platform: string;
+            timestamp: Date;
+        };
+        customPayload?: any;
+    };
+    requestConfig?: {
+        timeout?: number;
+        retryAttempts?: number;
+        retryDelay?: number;
+        validateSSL?: boolean;
+    };
+    responseHandling?: {
+        autoResponse: boolean;
+        successMessage?: string;
+        errorMessage?: string;
+        responseTemplate?: string;
+    };
+    metadata?: {
+        action: string;
+        description?: string;
+        requiredFields?: string[];
+        workflow?: {
+            workflowId: string;
+            nodeId: string;
+            stepName: string;
+        };
+    };
+    conditions?: {
+        requireAllFields?: boolean;
+        customValidations?: Array<{
+            field: string;
+            rule: 'required' | 'email' | 'phone' | 'date' | 'regex';
+            value?: string;
+            message?: string;
+        }>;
+    };
+    webhook?: {
+        url: string;
+        method: 'POST' | 'PUT';
+        notifyOnSuccess?: boolean;
+        notifyOnError?: boolean;
+    };
+    constructor(data?: Partial<IN8nChatApiCallback>);
+    /**
+     * Valida se o callback está configurado corretamente para execução
+     */
+    isValid(): boolean;
+    /**
+     * Valida se todas as condições são atendidas para executar a API
+     */
+    canExecute(formData?: Record<string, any>): boolean;
+}

package/dist/n8n/entities/chat-api-callback.entity.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nChatApiCallbackEntity = void 0;
+var N8nChatApiCallbackEntity = /** @class */ (function () {
+    // #endregion Properties (12)
+    function N8nChatApiCallbackEntity(data) {
+        if (data === void 0) { data = {}; }
+        var _a, _b, _c, _d, _e;
+        this.callApi = (_a = data.callApi) !== null && _a !== void 0 ? _a : false;
+        this.callbackId = (_b = data.callbackId) !== null && _b !== void 0 ? _b : '';
+        this.apiUrl = (_c = data.apiUrl) !== null && _c !== void 0 ? _c : '';
+        this.method = (_d = data.method) !== null && _d !== void 0 ? _d : 'POST';
+        this.headers = (_e = data.headers) !== null && _e !== void 0 ? _e : {};
+        this.payload = data.payload;
+        this.requestConfig = data.requestConfig;
+        this.responseHandling = data.responseHandling;
+        this.metadata = data.metadata;
+        this.conditions = data.conditions;
+        this.webhook = data.webhook;
+    }
+    /**
+     * Valida se o callback está configurado corretamente para execução
+     */
+    N8nChatApiCallbackEntity.prototype.isValid = function () {
+        if (!this.callApi)
+            return true; // Se não vai chamar API, é válido
+        return !!(this.callbackId && this.apiUrl && this.method);
+    };
+    /**
+     * Valida se todas as condições são atendidas para executar a API
+     */
+    N8nChatApiCallbackEntity.prototype.canExecute = function (formData) {
+        var _a, _b, _c;
+        if (!this.callApi || !this.isValid())
+            return false;
+        // Verifica campos obrigatórios
+        if (((_a = this.conditions) === null || _a === void 0 ? void 0 : _a.requireAllFields) && ((_b = this.metadata) === null || _b === void 0 ? void 0 : _b.requiredFields)) {
+            for (var _i = 0, _d = this.metadata.requiredFields; _i < _d.length; _i++) {
+                var field = _d[_i];
+                if (!(formData === null || formData === void 0 ? void 0 : formData[field]))
+                    return false;
+            }
+        }
+        // Valida validações customizadas
+        if (((_c = this.conditions) === null || _c === void 0 ? void 0 : _c.customValidations) && formData) {
+            for (var _e = 0, _f = this.conditions.customValidations; _e < _f.length; _e++) {
+                var validation = _f[_e];
+                var value = formData[validation.field];
+                switch (validation.rule) {
+                    case 'required':
+                        if (!value)
+                            return false;
+                        break;
+                    case 'email':
+                        if (value && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+                            return false;
+                        break;
+                    case 'phone':
+                        if (value && !/^\+?[\d\s\-\(\)]+$/.test(value))
+                            return false;
+                        break;
+                    case 'date':
+                        if (value && isNaN(Date.parse(value)))
+                            return false;
+                        break;
+                    case 'regex':
+                        if (value && validation.value && !new RegExp(validation.value).test(value))
+                            return false;
+                        break;
+                }
+            }
+        }
+        return true;
+    };
+    return N8nChatApiCallbackEntity;
+}());
+exports.N8nChatApiCallbackEntity = N8nChatApiCallbackEntity;

package/dist/n8n/entities/chat-context.entity.d.ts

@@ -0,0 +1,49 @@
+import { IN8nChatContext } from '../interfaces/i-chat-context';
+export declare class N8nChatContextEntity implements IN8nChatContext {
+    contextId: string;
+    sessionId: string;
+    userId: string;
+    platform: string;
+    messageHistory: Array<{
+        messageId: string;
+        message: string;
+        messageType: string;
+        timestamp: Date;
+        sender: 'user' | 'bot';
+        metadata?: any;
+    }>;
+    conversationState: {
+        currentFlow?: string;
+        currentStep?: string;
+        isActive: boolean;
+        lastActivity: Date;
+        variables?: Record<string, any>;
+    };
+    userData: {
+        name?: string;
+        email?: string;
+        phone?: string;
+        preferences?: Record<string, any>;
+        customFields?: Record<string, any>;
+    };
+    sessionConfig: {
+        timeout?: number;
+        maxMessages?: number;
+        language?: string;
+        timezone?: string;
+    };
+    metrics?: {
+        totalMessages: number;
+        userMessages: number;
+        botMessages: number;
+        sessionDuration?: number;
+        firstMessageAt: Date;
+        lastMessageAt: Date;
+    };
+    timestamps: {
+        createdAt: Date;
+        updatedAt: Date;
+        expiresAt?: Date;
+    };
+    constructor(data?: Partial<N8nChatContextEntity>);
+}

package/dist/n8n/entities/chat-context.entity.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nChatContextEntity = void 0;
+var N8nChatContextEntity = /** @class */ (function () {
+    // #endregion Properties (10)
+    // #region Constructors (1)
+    function N8nChatContextEntity(data) {
+        // #region Properties (10)
+        this.contextId = '';
+        this.sessionId = '';
+        this.userId = '';
+        this.platform = '';
+        this.messageHistory = [];
+        this.conversationState = {
+            isActive: false,
+            lastActivity: new Date(),
+        };
+        this.userData = {};
+        this.sessionConfig = {
+            timeout: 30,
+            maxMessages: 100,
+            language: 'pt-BR',
+            timezone: 'America/Sao_Paulo',
+        };
+        this.metrics = undefined;
+        this.timestamps = {
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+        if (data) {
+            for (var key in data) {
+                if (data.hasOwnProperty(key) && key in this) {
+                    this[key] = data[key];
+                }
+            }
+        }
+    }
+    return N8nChatContextEntity;
+}());
+exports.N8nChatContextEntity = N8nChatContextEntity;

package/dist/n8n/entities/chat-response.entity.d.ts

@@ -0,0 +1,77 @@
+import { IN8nChatApiCallback } from '../interfaces/i-chat-api-callback';
+import { IN8nChatResponse } from '../interfaces/i-chat-response';
+export declare class N8nChatResponseEntity implements IN8nChatResponse {
+    responseId: string;
+    originalMessageId: string;
+    sessionId: string;
+    userId: string;
+    message: string;
+    messageType: 'text' | 'image' | 'audio' | 'video' | 'document' | 'template' | 'quick_reply' | 'button';
+    timestamp: Date;
+    platform: string;
+    responseData?: {
+        buttons?: Array<{
+            id: string;
+            text: string;
+            type: 'reply' | 'url' | 'call';
+            payload?: string;
+            url?: string;
+            phoneNumber?: string;
+            apiCallback?: IN8nChatApiCallback;
+        }>;
+        quickReplies?: Array<{
+            id: string;
+            text: string;
+            payload?: string;
+            apiCallback?: IN8nChatApiCallback;
+        }>;
+        template?: {
+            type: string;
+            elements: any[];
+        };
+        media?: {
+            url: string;
+            type: string;
+            caption?: string;
+            filename?: string;
+        };
+    };
+    delivery: {
+        priority: 'low' | 'normal' | 'high';
+        delay?: number;
+        retryAttempts?: number;
+    };
+    metadata?: {
+        automated: boolean;
+        botName?: string;
+        workflowId?: string;
+        nodeId?: string;
+    };
+    status: 'queued' | 'sent' | 'delivered' | 'read' | 'failed';
+    constructor(data?: Partial<N8nChatResponseEntity>);
+    /**
+     * Adiciona um botão com callback de API opcional
+     */
+    addButton(button: {
+        id: string;
+        text: string;
+        type: 'reply' | 'url' | 'call';
+        payload?: string;
+        url?: string;
+        phoneNumber?: string;
+        apiCallback?: IN8nChatApiCallback;
+    }): void;
+    /**
+     * Adiciona uma resposta rápida com callback de API opcional
+     */
+    addQuickReply(quickReply: {
+        id: string;
+        text: string;
+        payload?: string;
+        apiCallback?: IN8nChatApiCallback;
+    }): void;
+    /**
+     * Valida se a resposta está pronta para ser enviada
+     */
+    isValid(): boolean;
+}

package/dist/n8n/entities/chat-response.entity.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nChatResponseEntity = void 0;
+var N8nChatResponseEntity = /** @class */ (function () {
+    // #endregion Properties (12)
+    // #region Constructors (1)
+    function N8nChatResponseEntity(data) {
+        // #region Properties (12)
+        this.responseId = '';
+        this.originalMessageId = '';
+        this.sessionId = '';
+        this.userId = '';
+        this.message = '';
+        this.messageType = 'text';
+        this.timestamp = new Date();
+        this.platform = '';
+        this.responseData = undefined;
+        this.delivery = {
+            priority: 'normal',
+        };
+        this.metadata = undefined;
+        this.status = 'queued';
+        if (data) {
+            for (var key in data) {
+                if (data.hasOwnProperty(key) && key in this) {
+                    this[key] = data[key];
+                }
+            }
+        }
+    }
+    // #endregion Constructors (1)
+    /**
+     * Adiciona um botão com callback de API opcional
+     */
+    N8nChatResponseEntity.prototype.addButton = function (button) {
+        if (!this.responseData) {
+            this.responseData = {};
+        }
+        if (!this.responseData.buttons) {
+            this.responseData.buttons = [];
+        }
+        this.responseData.buttons.push(button);
+        this.messageType = 'button';
+    };
+    /**
+     * Adiciona uma resposta rápida com callback de API opcional
+     */
+    N8nChatResponseEntity.prototype.addQuickReply = function (quickReply) {
+        if (!this.responseData) {
+            this.responseData = {};
+        }
+        if (!this.responseData.quickReplies) {
+            this.responseData.quickReplies = [];
+        }
+        this.responseData.quickReplies.push(quickReply);
+        this.messageType = 'quick_reply';
+    };
+    /**
+     * Valida se a resposta está pronta para ser enviada
+     */
+    N8nChatResponseEntity.prototype.isValid = function () {
+        var hasBasicData = !!(this.responseId && this.userId && this.sessionId);
+        var hasContent = !!(this.message || this.responseData);
+        return hasBasicData && hasContent;
+    };
+    return N8nChatResponseEntity;
+}());
+exports.N8nChatResponseEntity = N8nChatResponseEntity;

package/dist/n8n/entities/chat-trigger.entity.d.ts

@@ -0,0 +1,47 @@
+import { IN8nChatTrigger } from '../interfaces/i-chat-trigger';
+export declare class N8nChatTriggerEntity implements IN8nChatTrigger {
+    messageId: string;
+    sessionId: string;
+    userId: string;
+    message: string;
+    messageType: 'text' | 'image' | 'audio' | 'video' | 'document' | 'location' | 'contact' | 'sticker' | 'emoji';
+    timestamp: Date;
+    platform: string;
+    user: {
+        id: string;
+        name: string;
+        phone?: string;
+        email?: string;
+        avatar?: string;
+        language?: string;
+    };
+    conversation: {
+        id: string;
+        title?: string;
+        isGroup: boolean;
+        participantCount?: number;
+    };
+    metadata: {
+        isForwarded?: boolean;
+        isReply?: boolean;
+        replyToMessageId?: string;
+        hasMedia?: boolean;
+        mediaUrl?: string;
+        mediaType?: string;
+        location?: {
+            latitude: number;
+            longitude: number;
+            address?: string;
+        };
+    };
+    webhook: {
+        id: string;
+        url: string;
+        headers?: Record<string, string>;
+    };
+    rawData?: any;
+    tags?: string[];
+    customData?: Record<string, any>;
+    status: 'pending' | 'processing' | 'completed' | 'error';
+    constructor(data?: Partial<N8nChatTriggerEntity>);
+}

package/dist/n8n/entities/chat-trigger.entity.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nChatTriggerEntity = void 0;
+var N8nChatTriggerEntity = /** @class */ (function () {
+    // #endregion Properties (15)
+    // #region Constructors (1)
+    function N8nChatTriggerEntity(data) {
+        // #region Properties (15)
+        this.messageId = '';
+        this.sessionId = '';
+        this.userId = '';
+        this.message = '';
+        this.messageType = 'text';
+        this.timestamp = new Date();
+        this.platform = '';
+        this.user = {
+            id: '',
+            name: '',
+        };
+        this.conversation = {
+            id: '',
+            isGroup: false,
+        };
+        this.metadata = {};
+        this.webhook = {
+            id: '',
+            url: '',
+        };
+        this.rawData = null;
+        this.tags = [];
+        this.customData = {};
+        this.status = 'pending';
+        if (data) {
+            for (var key in data) {
+                if (data.hasOwnProperty(key) && key in this) {
+                    this[key] = data[key];
+                }
+            }
+        }
+    }
+    return N8nChatTriggerEntity;
+}());
+exports.N8nChatTriggerEntity = N8nChatTriggerEntity;

package/dist/n8n/entities/index.d.ts

@@ -0,0 +1,3 @@
+export { N8nChatContextEntity } from './chat-context.entity';
+export { N8nChatResponseEntity } from './chat-response.entity';
+export { N8nChatTriggerEntity } from './chat-trigger.entity';

package/dist/n8n/entities/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.N8nChatTriggerEntity = exports.N8nChatResponseEntity = exports.N8nChatContextEntity = void 0;
+var chat_context_entity_1 = require("./chat-context.entity");
+Object.defineProperty(exports, "N8nChatContextEntity", { enumerable: true, get: function () { return chat_context_entity_1.N8nChatContextEntity; } });
+var chat_response_entity_1 = require("./chat-response.entity");
+Object.defineProperty(exports, "N8nChatResponseEntity", { enumerable: true, get: function () { return chat_response_entity_1.N8nChatResponseEntity; } });
+var chat_trigger_entity_1 = require("./chat-trigger.entity");
+Object.defineProperty(exports, "N8nChatTriggerEntity", { enumerable: true, get: function () { return chat_trigger_entity_1.N8nChatTriggerEntity; } });

package/dist/n8n/index.d.ts

@@ -0,0 +1,10 @@
+export * from './entities';
+export * from './interfaces';
+export * from './interfaces/i-chat-api-callback';
+export * from './interfaces/i-chat-context';
+export * from './interfaces/i-chat-response';
+export * from './interfaces/i-chat-trigger';
+export * from './entities/chat-api-callback.entity';
+export * from './entities/chat-context.entity';
+export * from './entities/chat-response.entity';
+export * from './entities/chat-trigger.entity';

package/dist/n8n/index.js

@@ -0,0 +1,28 @@
+"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 });
+__exportStar(require("./entities"), exports);
+__exportStar(require("./interfaces"), exports);
+// Interfaces
+__exportStar(require("./interfaces/i-chat-api-callback"), exports);
+__exportStar(require("./interfaces/i-chat-context"), exports);
+__exportStar(require("./interfaces/i-chat-response"), exports);
+__exportStar(require("./interfaces/i-chat-trigger"), exports);
+// Entities
+__exportStar(require("./entities/chat-api-callback.entity"), exports);
+__exportStar(require("./entities/chat-context.entity"), exports);
+__exportStar(require("./entities/chat-response.entity"), exports);
+__exportStar(require("./entities/chat-trigger.entity"), exports);

package/dist/n8n/interfaces/i-chat-api-callback.d.ts

@@ -0,0 +1,65 @@
+export interface IN8nChatApiCallback {
+    callApi: boolean;
+    callbackId: string;
+    apiUrl: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers: {
+        authorization?: string;
+        contentType?: string;
+        userAgent?: string;
+        customHeaders?: Record<string, string>;
+    };
+    payload?: {
+        userData?: {
+            userId: string;
+            name?: string;
+            phone?: string;
+            email?: string;
+        };
+        formData?: Record<string, any>;
+        contextData?: {
+            sessionId: string;
+            messageId: string;
+            platform: string;
+            timestamp: Date;
+        };
+        customPayload?: any;
+    };
+    requestConfig?: {
+        timeout?: number;
+        retryAttempts?: number;
+        retryDelay?: number;
+        validateSSL?: boolean;
+    };
+    responseHandling?: {
+        autoResponse: boolean;
+        successMessage?: string;
+        errorMessage?: string;
+        responseTemplate?: string;
+    };
+    metadata?: {
+        action: string;
+        description?: string;
+        requiredFields?: string[];
+        workflow?: {
+            workflowId: string;
+            nodeId: string;
+            stepName: string;
+        };
+    };
+    conditions?: {
+        requireAllFields?: boolean;
+        customValidations?: Array<{
+            field: string;
+            rule: 'required' | 'email' | 'phone' | 'date' | 'regex';
+            value?: string;
+            message?: string;
+        }>;
+    };
+    webhook?: {
+        url: string;
+        method: 'POST' | 'PUT';
+        notifyOnSuccess?: boolean;
+        notifyOnError?: boolean;
+    };
+}

package/dist/n8n/interfaces/i-chat-api-callback.js

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