@eleva-io/erp-sdk 0.1.0

package/dist/client/client.d.ts

@@ -0,0 +1,11 @@
+import { HorizontalAPI } from "./resources/horizontal/api";
+import { TicketingAPI } from "./resources/ticketing/api";
+export * from "./resources/ticketing/types";
+export declare class ERPClient {
+    private httpClient;
+    private _tasks;
+    private _horizontal;
+    constructor(apiKey: string, apiSecret: string, baseURL: string);
+    tasks(): TicketingAPI;
+    horizontal(): HorizontalAPI;
+}

package/dist/client/client.js

@@ -0,0 +1,41 @@
+"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.ERPClient = void 0;
+const http_1 = require("./http");
+const api_1 = require("./resources/horizontal/api");
+const api_2 = require("./resources/ticketing/api");
+__exportStar(require("./resources/ticketing/types"), exports);
+class ERPClient {
+    constructor(apiKey, apiSecret, baseURL) {
+        this._tasks = null;
+        this._horizontal = null;
+        this.httpClient = new http_1.HTTPClient(apiKey, apiSecret, baseURL);
+    }
+    tasks() {
+        if (!this._tasks) {
+            this._tasks = new api_2.TicketingAPI(this.httpClient);
+        }
+        return this._tasks;
+    }
+    horizontal() {
+        if (!this._horizontal) {
+            this._horizontal = new api_1.HorizontalAPI(this.httpClient);
+        }
+        return this._horizontal;
+    }
+}
+exports.ERPClient = ERPClient;

package/dist/client/http.d.ts

@@ -0,0 +1,12 @@
+import { APIResponse } from "../types";
+export declare class HTTPClient {
+    private apiKey;
+    private apiSecret;
+    private client;
+    constructor(apiKey: string, apiSecret: string, baseURL: string);
+    get<T>(path: string, params?: Record<string, unknown>): Promise<APIResponse<T>>;
+    post<T>(path: string, data?: unknown, params?: Record<string, unknown>): Promise<APIResponse<T>>;
+    put<T>(path: string, data?: unknown, params?: Record<string, unknown>): Promise<APIResponse<T>>;
+    delete<T>(path: string, params?: Record<string, unknown>): Promise<APIResponse<T>>;
+    getBinary(path: string, params?: Record<string, unknown>): Promise<Buffer>;
+}

package/dist/client/http.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const signature_1 = require("./utils/signature");
+const querystring_1 = __importDefault(require("querystring"));
+class HTTPClient {
+    constructor(apiKey, apiSecret, baseURL) {
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+        this.client = axios_1.default.create({
+            baseURL,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        // Interceptor para agregar headers de autenticación
+        this.client.interceptors.request.use((config) => {
+            const signatureData = (0, signature_1.generateSignature)(config.data || {}, this.apiKey, this.apiSecret);
+            // Manejar query params
+            if (config.params) {
+                const queryStr = querystring_1.default.stringify(config.params);
+                config.url = `${config.url}?${queryStr}`;
+                config.params = undefined; // Limpiamos params ya que los incluimos en la URL
+            }
+            if (config.headers) {
+                config.headers.set("x-api-key", this.apiKey);
+                config.headers.set("x-timestamp", signatureData.timestamp.toString());
+                config.headers.set("x-signature", signatureData.signature);
+            }
+            return config;
+        });
+        // Interceptor para manejar respuestas
+        this.client.interceptors.response.use((response) => {
+            // Mantener la respuesta original de Axios
+            return response;
+        }, (error) => {
+            var _a, _b, _c, _d, _e, _f;
+            const apiError = {
+                code: ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.code) || "UNKNOWN_ERROR",
+                message: ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.message) || "An unexpected error occurred",
+                errors: ((_f = (_e = error.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.errors) || [],
+            };
+            return Promise.reject(apiError);
+        });
+    }
+    async get(path, params) {
+        const response = await this.client.get(path, { params });
+        return response.data;
+    }
+    async post(path, data, params) {
+        const response = await this.client.post(path, data, {
+            params,
+        });
+        return response.data;
+    }
+    async put(path, data, params) {
+        const response = await this.client.put(path, data, {
+            params,
+        });
+        return response.data;
+    }
+    async delete(path, params) {
+        const response = await this.client.delete(path, {
+            params,
+        });
+        return response.data;
+    }
+    async getBinary(path, params) {
+        const response = await this.client.get(path, {
+            params,
+            responseType: "arraybuffer",
+        });
+        return Buffer.from(response.data);
+    }
+}
+exports.HTTPClient = HTTPClient;

package/dist/client/resources/horizontal/api.d.ts

@@ -0,0 +1,8 @@
+import { HTTPClient } from "../../http";
+import { CommunitiesAPI } from "./communities/api";
+export declare class HorizontalAPI {
+    private httpClient;
+    constructor(httpClient: HTTPClient);
+    communities(): CommunitiesAPI;
+}
+export * from "./communities/types";

package/dist/client/resources/horizontal/api.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 });
+exports.HorizontalAPI = void 0;
+const api_1 = require("./communities/api");
+class HorizontalAPI {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    communities() {
+        return new api_1.CommunitiesAPI(this.httpClient);
+    }
+}
+exports.HorizontalAPI = HorizontalAPI;
+__exportStar(require("./communities/types"), exports);

package/dist/client/resources/horizontal/communities/api.d.ts

@@ -0,0 +1,12 @@
+import { HTTPClient } from "../../../http";
+import { APIResponse } from "../../../../types";
+import { AgentRole, Community, CommunityAgent } from "./types";
+export declare class CommunitiesAPI {
+    private httpClient;
+    private readonly basePath;
+    constructor(httpClient: HTTPClient);
+    getById(communityId: string): Promise<APIResponse<Community>>;
+    getAgentRoles(): Promise<APIResponse<AgentRole[]>>;
+    getCommunityAgents(communityId: string): Promise<APIResponse<CommunityAgent[]>>;
+}
+export * from "./types";

package/dist/client/resources/horizontal/communities/api.js

@@ -0,0 +1,34 @@
+"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.CommunitiesAPI = void 0;
+class CommunitiesAPI {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.basePath = "/api/v1/horizontal/communities";
+    }
+    async getById(communityId) {
+        return this.httpClient.get(`${this.basePath}/${communityId}`);
+    }
+    async getAgentRoles() {
+        return this.httpClient.get(`${this.basePath}/config/agents`);
+    }
+    async getCommunityAgents(communityId) {
+        return this.httpClient.get(`${this.basePath}/${communityId}/agents`);
+    }
+}
+exports.CommunitiesAPI = CommunitiesAPI;
+__exportStar(require("./types"), exports);

package/dist/client/resources/horizontal/communities/types.d.ts

@@ -0,0 +1,49 @@
+import { ResourceInfo } from "../../types";
+export interface AgentRole {
+    id: number;
+    domainId: string;
+    name: string;
+    required: boolean;
+    unique: boolean;
+}
+export interface CommunityAgent {
+    communityId: string;
+    agentId: string;
+    roleId: number;
+    updatedAt: string;
+}
+export interface Community {
+    id: string;
+    domainId: string;
+    name: string;
+    personId: string;
+    enrollmentDate: string | null;
+    macrocommunityId: string | null;
+    coefficient: number | null;
+    churnDate: string | null;
+    churnReasonId: number | null;
+    tags: string[] | null;
+    customFields: Record<string, any>;
+    updatedAt: string;
+    neighbors: Array<{
+        personId: string;
+        typeId: number;
+    }>;
+    person: {
+        id: string;
+        domainId: string;
+        typeId: number;
+        langId: number;
+        fullName: string;
+        legalId: string | null;
+        legalRepresentative: string | null;
+        bornAt: string | null;
+        phones: string[] | null;
+        emails: string[] | null;
+        notificationEmail: boolean;
+        notificationPhone: boolean;
+        notificationPostal: boolean;
+        tags: string[] | null;
+    };
+    resourceInfo: ResourceInfo;
+}

package/dist/client/resources/horizontal/communities/types.js

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

package/dist/client/resources/tasks/api.d.ts

@@ -0,0 +1,18 @@
+import { HTTPClient } from "../../http";
+import { APIResponse } from "../../../types";
+import { CreateTaskDTO, Task, TaskCategory } from "./types";
+export declare class TasksAPI {
+    private httpClient;
+    private readonly basePath;
+    constructor(httpClient: HTTPClient);
+    create(data: CreateTaskDTO): Promise<APIResponse<Task>>;
+    getAll(filters?: Record<string, unknown>): Promise<APIResponse<Task[]>>;
+    getById(id: string): Promise<APIResponse<Task>>;
+    update(id: string, data: Partial<Task>): Promise<APIResponse<Task>>;
+    delete(id: string): Promise<APIResponse<void>>;
+    downloadAttachment(taskId: string, documentId: string): Promise<Buffer>;
+    getCategories(filters?: Record<string, unknown>): Promise<APIResponse<TaskCategory[]>>;
+    getCategoryById(id: number): Promise<APIResponse<TaskCategory>>;
+    getSubtaskFromParentId(parentId: string): Promise<APIResponse<Task[]>>;
+}
+export * from "./types";

package/dist/client/resources/tasks/api.js

@@ -0,0 +1,54 @@
+"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.TasksAPI = void 0;
+class TasksAPI {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.basePath = "/api/v1/ticketing";
+    }
+    async create(data) {
+        return this.httpClient.post(`${this.basePath}/tasks`, data);
+    }
+    async getAll(filters) {
+        return this.httpClient.get(`${this.basePath}/tasks`, filters);
+    }
+    async getById(id) {
+        return this.httpClient.get(`${this.basePath}/tasks/${id}`);
+    }
+    async update(id, data) {
+        return this.httpClient.put(`${this.basePath}/tasks/${id}`, data);
+    }
+    async delete(id) {
+        return this.httpClient.delete(`${this.basePath}/tasks/${id}`);
+    }
+    async downloadAttachment(taskId, documentId) {
+        return this.httpClient.getBinary(`${this.basePath}/tasks/${taskId}/attachments/${documentId}`);
+    }
+    async getCategories(filters) {
+        return this.httpClient.get(`${this.basePath}/tasks/config/categories`, filters);
+    }
+    async getCategoryById(id) {
+        return this.getCategories({ "id[]": [id] }).then((response) => response[0]);
+    }
+    async getSubtaskFromParentId(parentId) {
+        return this.httpClient.get(`${this.basePath}/tasks`, {
+            "parentId[]": [parentId],
+        });
+    }
+}
+exports.TasksAPI = TasksAPI;
+__exportStar(require("./types"), exports);

package/dist/client/resources/tasks/types.d.ts

@@ -0,0 +1,58 @@
+export declare enum TaskPriority {
+    low = 1,
+    medium = 2,
+    high = 3
+}
+export declare enum TaskStatus {
+    todo = 1,
+    wip = 2,
+    done = 3,
+    discarded = 4
+}
+export declare enum TaskReporterType {
+    agent = 1,
+    contact = 2,
+    provider = 3,
+    system = 4,
+    ai = 5
+}
+export interface Task {
+    id: string;
+    domainId: string;
+    parentId: string | null;
+    contactId: string | null;
+    categoryId: number;
+    priorityId: TaskPriority;
+    statusId: TaskStatus;
+    code: string;
+    title: string;
+    description: string | null;
+    reporterTypeId: TaskReporterType;
+    reporterId: string;
+    responsibleId: string;
+    executorId: string;
+    providerId: string | null;
+    tags: string[] | null;
+    dueDate: string | null;
+    firstResponseDue: string | null;
+    updatedAt: string;
+}
+export interface CreateTaskDTO {
+    title: string;
+    categoryId: number;
+    priorityId: TaskPriority;
+    executorId: string;
+    responsibleId: string;
+    reporterId: string;
+    reporterTypeId: TaskReporterType;
+    parentId?: string;
+    dueDate?: string | null;
+    description?: string;
+}
+export interface TaskCategory {
+    id: number;
+    domainId: string;
+    name: string;
+    key: string;
+    icon: string;
+}

package/dist/client/resources/tasks/types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskReporterType = exports.TaskStatus = exports.TaskPriority = void 0;
+var TaskPriority;
+(function (TaskPriority) {
+    TaskPriority[TaskPriority["low"] = 1] = "low";
+    TaskPriority[TaskPriority["medium"] = 2] = "medium";
+    TaskPriority[TaskPriority["high"] = 3] = "high";
+})(TaskPriority || (exports.TaskPriority = TaskPriority = {}));
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus[TaskStatus["todo"] = 1] = "todo";
+    TaskStatus[TaskStatus["wip"] = 2] = "wip";
+    TaskStatus[TaskStatus["done"] = 3] = "done";
+    TaskStatus[TaskStatus["discarded"] = 4] = "discarded";
+})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
+var TaskReporterType;
+(function (TaskReporterType) {
+    TaskReporterType[TaskReporterType["agent"] = 1] = "agent";
+    TaskReporterType[TaskReporterType["contact"] = 2] = "contact";
+    TaskReporterType[TaskReporterType["provider"] = 3] = "provider";
+    TaskReporterType[TaskReporterType["system"] = 4] = "system";
+    TaskReporterType[TaskReporterType["ai"] = 5] = "ai";
+})(TaskReporterType || (exports.TaskReporterType = TaskReporterType = {}));

package/dist/client/resources/ticketing/api.d.ts

@@ -0,0 +1,18 @@
+import { HTTPClient } from "../../http";
+import { APIResponse } from "../../../types";
+import { CreateTaskDTO, Task, TaskCategory } from "./types";
+export declare class TicketingAPI {
+    private httpClient;
+    private readonly basePath;
+    constructor(httpClient: HTTPClient);
+    create(data: CreateTaskDTO): Promise<APIResponse<Task>>;
+    getAll(filters?: Record<string, unknown>): Promise<APIResponse<Task[]>>;
+    getById(id: string): Promise<APIResponse<Task>>;
+    update(id: string, data: Partial<Task>): Promise<APIResponse<Task>>;
+    delete(id: string): Promise<APIResponse<void>>;
+    downloadAttachment(taskId: string, documentId: string): Promise<Buffer>;
+    getCategories(filters?: Record<string, unknown>): Promise<APIResponse<TaskCategory[]>>;
+    getCategoryById(id: number): Promise<APIResponse<TaskCategory>>;
+    getSubtaskFromParentId(parentId: string): Promise<APIResponse<Task[]>>;
+}
+export * from "./types";

package/dist/client/resources/ticketing/api.js

@@ -0,0 +1,54 @@
+"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.TicketingAPI = void 0;
+class TicketingAPI {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.basePath = "/api/v1/ticketing";
+    }
+    async create(data) {
+        return this.httpClient.post(`${this.basePath}/tasks`, data);
+    }
+    async getAll(filters) {
+        return this.httpClient.get(`${this.basePath}/tasks`, filters);
+    }
+    async getById(id) {
+        return this.httpClient.get(`${this.basePath}/tasks/${id}`);
+    }
+    async update(id, data) {
+        return this.httpClient.put(`${this.basePath}/tasks/${id}`, data);
+    }
+    async delete(id) {
+        return this.httpClient.delete(`${this.basePath}/tasks/${id}`);
+    }
+    async downloadAttachment(taskId, documentId) {
+        return this.httpClient.getBinary(`${this.basePath}/tasks/${taskId}/attachments/${documentId}`);
+    }
+    async getCategories(filters) {
+        return this.httpClient.get(`${this.basePath}/tasks/config/categories`, filters);
+    }
+    async getCategoryById(id) {
+        return this.getCategories({ "id[]": [id] }).then((response) => response[0]);
+    }
+    async getSubtaskFromParentId(parentId) {
+        return this.httpClient.get(`${this.basePath}/tasks`, {
+            "parentId[]": [parentId],
+        });
+    }
+}
+exports.TicketingAPI = TicketingAPI;
+__exportStar(require("./types"), exports);

package/dist/client/resources/ticketing/types.d.ts

@@ -0,0 +1,61 @@
+import { ResourceInfo } from "../types";
+export declare enum TaskPriority {
+    low = 1,
+    medium = 2,
+    high = 3
+}
+export declare enum TaskStatus {
+    todo = 1,
+    wip = 2,
+    done = 3,
+    discarded = 4
+}
+export declare enum TaskReporterType {
+    agent = 1,
+    contact = 2,
+    provider = 3,
+    system = 4,
+    ai = 5
+}
+export interface Task {
+    id: string;
+    domainId: string;
+    parentId: string | null;
+    contactId: string | null;
+    categoryId: number;
+    priorityId: TaskPriority;
+    statusId: TaskStatus;
+    code: string;
+    title: string;
+    description: string | null;
+    reporterTypeId: TaskReporterType;
+    reporterId: string;
+    responsibleId: string;
+    executorId: string;
+    providerId: string | null;
+    tags: string[] | null;
+    dueDate: string | null;
+    firstResponseDue: string | null;
+    updatedAt: string;
+    resourceInfo?: ResourceInfo;
+}
+export interface CreateTaskDTO {
+    title: string;
+    categoryId: number;
+    priorityId: TaskPriority;
+    executorId: string;
+    responsibleId: string;
+    reporterId: string;
+    reporterTypeId: TaskReporterType;
+    parentId?: string;
+    dueDate?: string | null;
+    description?: string;
+    resourceInfo?: ResourceInfo;
+}
+export interface TaskCategory {
+    id: number;
+    domainId: string;
+    name: string;
+    key: string;
+    icon: string;
+}

package/dist/client/resources/ticketing/types.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskReporterType = exports.TaskStatus = exports.TaskPriority = void 0;
+var TaskPriority;
+(function (TaskPriority) {
+    TaskPriority[TaskPriority["low"] = 1] = "low";
+    TaskPriority[TaskPriority["medium"] = 2] = "medium";
+    TaskPriority[TaskPriority["high"] = 3] = "high";
+})(TaskPriority || (exports.TaskPriority = TaskPriority = {}));
+var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus[TaskStatus["todo"] = 1] = "todo";
+    TaskStatus[TaskStatus["wip"] = 2] = "wip";
+    TaskStatus[TaskStatus["done"] = 3] = "done";
+    TaskStatus[TaskStatus["discarded"] = 4] = "discarded";
+})(TaskStatus || (exports.TaskStatus = TaskStatus = {}));
+var TaskReporterType;
+(function (TaskReporterType) {
+    TaskReporterType[TaskReporterType["agent"] = 1] = "agent";
+    TaskReporterType[TaskReporterType["contact"] = 2] = "contact";
+    TaskReporterType[TaskReporterType["provider"] = 3] = "provider";
+    TaskReporterType[TaskReporterType["system"] = 4] = "system";
+    TaskReporterType[TaskReporterType["ai"] = 5] = "ai";
+})(TaskReporterType || (exports.TaskReporterType = TaskReporterType = {}));

package/dist/client/resources/types.d.ts

@@ -0,0 +1,12 @@
+export interface OrganizationUnitDTO {
+    id: string;
+    name?: string;
+    parentId?: string;
+}
+export interface ResourceInfo {
+    id?: string;
+    domainId?: string;
+    entityId?: number;
+    refId?: string;
+    organizationUnit?: OrganizationUnitDTO;
+}

package/dist/client/resources/types.js

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

package/dist/client/utils/signature.d.ts

@@ -0,0 +1,5 @@
+export interface SignatureData {
+    signature: string;
+    timestamp: number;
+}
+export declare function generateSignature(body: unknown, apiKey: string, apiSecret: string): SignatureData;

package/dist/client/utils/signature.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSignature = generateSignature;
+const crypto_1 = __importDefault(require("crypto"));
+function generateSignature(body, apiKey, apiSecret) {
+    const bodyStr = JSON.stringify(body, null, 0) || "";
+    const timestamp = Date.now();
+    const signature = crypto_1.default
+        .createHmac("sha256", apiSecret)
+        .update(`${bodyStr}:${timestamp}:${apiKey}`)
+        .digest("hex");
+    return {
+        signature,
+        timestamp,
+    };
+}

package/dist/erp.d.ts

@@ -0,0 +1,14 @@
+import { ERPClient } from "./client/client";
+import { TaskCreator } from "./tasks/creator";
+import { ElevaERPConfig } from "./types";
+export declare class ElevaERPTasks {
+    private _erp;
+    constructor(_erp: ElevaERP);
+    creator(): TaskCreator;
+}
+export declare class ElevaERP {
+    private _client;
+    constructor(config: ElevaERPConfig);
+    client(): ERPClient;
+    tasks(): ElevaERPTasks;
+}

package/dist/erp.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElevaERP = exports.ElevaERPTasks = void 0;
+const client_1 = require("./client/client");
+const creator_1 = require("./tasks/creator");
+class ElevaERPTasks {
+    constructor(_erp) {
+        this._erp = _erp;
+    }
+    creator() {
+        return new creator_1.TaskCreator(this._erp);
+    }
+}
+exports.ElevaERPTasks = ElevaERPTasks;
+class ElevaERP {
+    constructor(config) {
+        const baseURL = config.baseURL || "https://api.eleva.io";
+        this._client = new client_1.ERPClient(config.apiKey, config.apiSecret, baseURL);
+    }
+    client() {
+        return this._client;
+    }
+    tasks() {
+        return new ElevaERPTasks(this);
+    }
+}
+exports.ElevaERP = ElevaERP;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./erp";
+export * from "./types";
+export * from "./tasks/template";
+export * from "./tasks/creator";
+export * from "./client/resources/ticketing/types";

package/dist/index.js

@@ -0,0 +1,21 @@
+"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("./erp"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./tasks/template"), exports);
+__exportStar(require("./tasks/creator"), exports);
+__exportStar(require("./client/resources/ticketing/types"), exports);

package/dist/tasks/creator.d.ts

@@ -0,0 +1,9 @@
+import { ElevaERP } from "../erp";
+import { STD } from "./std";
+import { TaskTemplate } from "./template";
+export declare class TaskCreator {
+    private _erp;
+    constructor(_erp: ElevaERP);
+    private createTaskWithSubtasks;
+    template(template: TaskTemplate, std: STD): Promise<import("..").Task>;
+}

package/dist/tasks/creator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskCreator = void 0;
+class TaskCreator {
+    constructor(_erp) {
+        this._erp = _erp;
+    }
+    async createTaskWithSubtasks(task, parentId) {
+        const { subtasks, ...taskData } = task;
+        const createdTask = await this._erp
+            .client()
+            .tasks()
+            .create({
+            ...taskData,
+            parentId,
+        });
+        await Promise.all(subtasks.map((subtask) => this.createTaskWithSubtasks(subtask, createdTask.id)));
+        return createdTask;
+    }
+    async template(template, std) {
+        const task = await template.toTask(std);
+        return this.createTaskWithSubtasks(task);
+    }
+}
+exports.TaskCreator = TaskCreator;

package/dist/tasks/std.d.ts

@@ -0,0 +1,36 @@
+import { TaskCategory } from "../client/client";
+import { AgentRole, Community, CommunityAgent } from "../client/resources/horizontal/communities/types";
+import { ElevaERP } from "../erp";
+export interface STD {
+    agentLookupByRoleName(roleName: string): Promise<string>;
+    getCategoryIdByName(name: string): Promise<number>;
+    getCategoryIdByKey(key: string): Promise<number>;
+    getOrganizationUnitId(name?: string): Promise<string | undefined | null>;
+    date(): DateSTD;
+}
+export declare class DateSTD {
+    absoluteDay(day: number): string;
+    relativeDay(day: number): string;
+}
+export declare abstract class STDBase implements STD {
+    abstract agentLookupByRoleName(roleName: string): Promise<string>;
+    abstract getCategoryIdByName(name: string): Promise<number>;
+    abstract getCategoryIdByKey(key: string): Promise<number>;
+    abstract getOrganizationUnitId(name?: string): Promise<string | undefined | null>;
+    date(): DateSTD;
+}
+type HOAAgentWithRole = CommunityAgent & {
+    role: AgentRole | undefined;
+};
+export declare class HOASTD extends STDBase {
+    private _hoa;
+    private _agents;
+    private _categories;
+    static fromId(erp: ElevaERP, hoaId: string): Promise<HOASTD>;
+    constructor(_hoa: Community, _agents: HOAAgentWithRole[], _categories: TaskCategory[]);
+    agentLookupByRoleName(roleName: string): Promise<string>;
+    getCategoryIdByName(name: string): Promise<number>;
+    getCategoryIdByKey(key: string): Promise<number>;
+    getOrganizationUnitId(name?: string): Promise<string | undefined>;
+}
+export {};

package/dist/tasks/std.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOASTD = exports.STDBase = exports.DateSTD = void 0;
+const moment_1 = __importDefault(require("moment"));
+class DateSTD {
+    absoluteDay(day) {
+        const today = (0, moment_1.default)();
+        if (day < today.date()) {
+            today.add(1, "month");
+        }
+        return today.set("date", day).toISOString();
+    }
+    relativeDay(day) {
+        return (0, moment_1.default)().add(day, "days").toISOString();
+    }
+}
+exports.DateSTD = DateSTD;
+class STDBase {
+    date() {
+        return new DateSTD();
+    }
+}
+exports.STDBase = STDBase;
+class HOASTD extends STDBase {
+    static async fromId(erp, hoaId) {
+        const hoa = await erp.client().horizontal().communities().getById(hoaId);
+        const globalAgents = await erp
+            .client()
+            .horizontal()
+            .communities()
+            .getAgentRoles();
+        const agentsRaw = await erp
+            .client()
+            .horizontal()
+            .communities()
+            .getCommunityAgents(hoaId);
+        const agents = agentsRaw.map((agent) => ({
+            ...agent,
+            role: globalAgents.find((role) => role.id === agent.roleId),
+        }));
+        const categories = await erp.client().tasks().getCategories();
+        return new HOASTD(hoa, agents, categories);
+    }
+    constructor(_hoa, _agents, _categories) {
+        super();
+        this._hoa = _hoa;
+        this._agents = _agents;
+        this._categories = _categories;
+    }
+    async agentLookupByRoleName(roleName) {
+        const agent = this._agents.find((agent) => { var _a; return ((_a = agent.role) === null || _a === void 0 ? void 0 : _a.name.toLowerCase()) === roleName.toLowerCase(); });
+        if (!agent) {
+            throw new Error(`Agent with role name ${roleName} not found`);
+        }
+        return agent.agentId;
+    }
+    async getCategoryIdByName(name) {
+        const category = this._categories.find((category) => category.name.toLowerCase() === name.toLowerCase());
+        if (!category) {
+            throw new Error(`Category with name ${name} not found`);
+        }
+        return category.id;
+    }
+    async getCategoryIdByKey(key) {
+        const category = this._categories.find((category) => category.key.toLowerCase() === key.toLowerCase());
+        if (!category) {
+            throw new Error(`Category with key ${key} not found`);
+        }
+        return category.id;
+    }
+    async getOrganizationUnitId(name) {
+        var _a;
+        return (_a = this._hoa.resourceInfo.organizationUnit) === null || _a === void 0 ? void 0 : _a.id;
+    }
+}
+exports.HOASTD = HOASTD;

package/dist/tasks/template.d.ts

@@ -0,0 +1,43 @@
+import { Task, TaskPriority, TaskReporterType } from "../client/client";
+import { ResourceInfo } from "../client/resources/types";
+import { STD } from "./std";
+type Caller<T> = ((std: STD) => T) | ((std: STD) => Promise<T>);
+export interface TaskTemplateEvaluated {
+    title: string;
+    priorityId: TaskPriority;
+    categoryId: number;
+    reporterId: string;
+    reporterTypeId: TaskReporterType;
+    responsibleId: string;
+    executorId: string;
+    dueDate: string | null;
+    subtasks: TaskTemplateEvaluated[];
+    resourceInfo?: ResourceInfo;
+}
+export declare class TaskTemplate {
+    title: Caller<Task["title"]>;
+    priorityId: Caller<Task["priorityId"]>;
+    categoryId: Caller<Task["categoryId"]>;
+    reporterId: Caller<Task["reporterId"]>;
+    responsibleId: Caller<Task["responsibleId"]>;
+    executorId: Caller<Task["executorId"]>;
+    dueDate: Caller<Task["dueDate"]>;
+    subtasks: Caller<TaskTemplate[]>;
+    reporterTypeId: Caller<Task["reporterTypeId"]>;
+    organizationUnitId: Caller<string | undefined | null>;
+    constructor({ title, priorityId, categoryId, reporterId, responsibleId, executorId, dueDate, subtasks, reporterTypeId, organizationUnitId, }: {
+        title: Caller<Task["title"]>;
+        priorityId: Caller<Task["priorityId"]>;
+        categoryId: Caller<Task["categoryId"]>;
+        reporterId: Caller<Task["reporterId"]>;
+        responsibleId: Caller<Task["responsibleId"]>;
+        executorId: Caller<Task["executorId"]>;
+        dueDate: Caller<Task["dueDate"]>;
+        subtasks: Caller<TaskTemplate[]>;
+        reporterTypeId: Caller<Task["reporterTypeId"]>;
+        organizationUnitId: Caller<string | undefined | null>;
+    });
+    private _caller;
+    toTask(std: STD): Promise<TaskTemplateEvaluated>;
+}
+export {};

package/dist/tasks/template.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTemplate = void 0;
+class TaskTemplate {
+    constructor({ title, priorityId, categoryId, reporterId, responsibleId, executorId, dueDate, subtasks, reporterTypeId, organizationUnitId, }) {
+        this.title = title;
+        this.priorityId = priorityId;
+        this.dueDate = dueDate;
+        this.subtasks = subtasks;
+        this.reporterTypeId = reporterTypeId;
+        this.categoryId = categoryId;
+        this.reporterId = reporterId;
+        this.responsibleId = responsibleId;
+        this.executorId = executorId;
+        this.subtasks = subtasks;
+        this.organizationUnitId = organizationUnitId;
+    }
+    async _caller(caller, std) {
+        return caller(std);
+    }
+    async toTask(std) {
+        const [title, priorityId, categoryId, reporterId, responsibleId, executorId, dueDate, subtasksTemplate, reporterTypeId, organizationUnitId,] = await Promise.all([
+            this._caller(this.title, std),
+            this._caller(this.priorityId, std),
+            this._caller(this.categoryId, std),
+            this._caller(this.reporterId, std),
+            this._caller(this.responsibleId, std),
+            this._caller(this.executorId, std),
+            this._caller(this.dueDate, std),
+            this._caller(this.subtasks, std),
+            this._caller(this.reporterTypeId, std),
+            this._caller(this.organizationUnitId, std),
+        ]);
+        const subtasks = await Promise.all(subtasksTemplate.map((subtask) => subtask.toTask(std)));
+        const resourceInfo = organizationUnitId
+            ? {
+                organizationUnit: {
+                    id: organizationUnitId,
+                },
+            }
+            : undefined;
+        return {
+            title,
+            priorityId,
+            categoryId,
+            reporterId,
+            reporterTypeId,
+            responsibleId,
+            executorId,
+            dueDate,
+            subtasks,
+            resourceInfo,
+        };
+    }
+}
+exports.TaskTemplate = TaskTemplate;

package/dist/types/index.d.ts

@@ -0,0 +1,14 @@
+export interface ElevaERPConfig {
+    apiKey: string;
+    baseURL?: string;
+}
+export interface APIResponse<T> {
+    data: T;
+    status: number;
+    message?: string;
+}
+export interface APIError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}

package/dist/types/index.js

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

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+export interface ElevaERPConfig {
+    apiKey: string;
+    apiSecret: string;
+    baseURL?: string;
+}
+export type APIResponse<T> = T;
+export interface APIError {
+    code: string;
+    message: string;
+    errors?: unknown[];
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@eleva-io/erp-sdk",
+  "version": "0.1.0",
+  "description": "SDK oficial para el ERP de Eleva",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "eleva",
+    "erp",
+    "sdk",
+    "proptech"
+  ],
+  "author": "Eleva",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "dotenv": "^16.4.5",
+    "tsx": "^4.19.3",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "moment": "2.30.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16",
+    "pnpm": ">=8"
+  },
+  "scripts": {
+    "build": "pnpm tsc",
+    "test": "jest",
+    "dev": "pnpm tsc --watch",
+    "sandbox": "tsx sandbox/index.ts",
+    "sandbox:watch": "tsx watch sandbox/index.ts"
+  }
+}