proflores-db-model 0.2.47 → 0.2.49

package/dist/models/apu/Apu.d.ts

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from "typeorm";
 import { Concept } from "./Concept";
 import { ApuItem } from "./ApuItem";
+import { IndirectCostConfig } from "./IndirectCostConfig";
 export declare class Apu implements ObjectLiteral {
     idApu: number;
     concept: Concept;
@@ -11,4 +12,5 @@ export declare class Apu implements ObjectLiteral {
     profitPct: number;
     notes?: string | null;
     items?: ApuItem[];
+    indirectCostConfig?: IndirectCostConfig;
 }

package/dist/models/apu/Apu.js

@@ -13,6 +13,7 @@ exports.Apu = void 0;
 const typeorm_1 = require("typeorm");
 const Concept_1 = require("./Concept");
 const ApuItem_1 = require("./ApuItem");
+const IndirectCostConfig_1 = require("./IndirectCostConfig");
 let Apu = class Apu {
 };
 exports.Apu = Apu;
@@ -53,6 +54,10 @@ __decorate([
     (0, typeorm_1.OneToMany)(() => ApuItem_1.ApuItem, (ai) => ai.apu, { cascade: true }),
     __metadata("design:type", Array)
 ], Apu.prototype, "items", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => IndirectCostConfig_1.IndirectCostConfig, (config) => config.apu),
+    __metadata("design:type", IndirectCostConfig_1.IndirectCostConfig)
+], Apu.prototype, "indirectCostConfig", void 0);
 exports.Apu = Apu = __decorate([
     (0, typeorm_1.Entity)("apu"),
     (0, typeorm_1.Unique)("uq_apu_concept_version", ["concept", "version"]),

package/dist/models/apu/Concept.d.ts

@@ -2,6 +2,18 @@ import { ObjectLiteral } from "typeorm";
 import { UnitOfMeasure } from "../../entities/UnitOfMesure";
 import { Apu } from "./Apu";
 import { BudgetItem } from "./BudgetItem";
+export declare enum ConceptCategory {
+    JARDINERIA = "JAR",
+    RIEGO = "RIE",
+    OBRAS_CIVILES = "OBR",
+    MOBILIARIO = "MOB",
+    TERRACERIAS = "TER",
+    MANTENIMIENTO = "MAN",
+    MATERIALES = "MAT",
+    MANO_DE_OBRA = "LAB",
+    HERRAMIENTAS = "TOOL",
+    FERTILIZACION = "FER"
+}
 export declare class Concept implements ObjectLiteral {
     idConcept: number;
     code?: string | null;
@@ -10,7 +22,7 @@ export declare class Concept implements ObjectLiteral {
     unit: UnitOfMeasure;
     satClave?: string | null;
     satUnit?: string | null;
-    category?: string | null;
+    category?: ConceptCategory | null;
     isActive: boolean;
     apus?: Apu[];
     budgetItems?: BudgetItem[];

package/dist/models/apu/Concept.js

@@ -9,12 +9,25 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Concept = void 0;
+exports.Concept = exports.ConceptCategory = void 0;
 // apu/entities/Concept.ts
 const typeorm_1 = require("typeorm");
 const UnitOfMesure_1 = require("../../entities/UnitOfMesure"); // <-- ajusta tu ruta real
 const Apu_1 = require("./Apu");
 const BudgetItem_1 = require("./BudgetItem");
+var ConceptCategory;
+(function (ConceptCategory) {
+    ConceptCategory["JARDINERIA"] = "JAR";
+    ConceptCategory["RIEGO"] = "RIE";
+    ConceptCategory["OBRAS_CIVILES"] = "OBR";
+    ConceptCategory["MOBILIARIO"] = "MOB";
+    ConceptCategory["TERRACERIAS"] = "TER";
+    ConceptCategory["MANTENIMIENTO"] = "MAN";
+    ConceptCategory["MATERIALES"] = "MAT";
+    ConceptCategory["MANO_DE_OBRA"] = "LAB";
+    ConceptCategory["HERRAMIENTAS"] = "TOOL";
+    ConceptCategory["FERTILIZACION"] = "FER";
+})(ConceptCategory || (exports.ConceptCategory = ConceptCategory = {}));
 let Concept = class Concept {
 };
 exports.Concept = Concept;
@@ -48,7 +61,11 @@ __decorate([
     __metadata("design:type", Object)
 ], Concept.prototype, "satUnit", void 0);
 __decorate([
-    (0, typeorm_1.Column)("varchar", { length: 64, nullable: true }),
+    (0, typeorm_1.Column)({
+        type: "enum",
+        enum: ConceptCategory,
+        nullable: true
+    }),
     __metadata("design:type", Object)
 ], Concept.prototype, "category", void 0);
 __decorate([

package/dist/models/apu/IndirectCostCalculator.d.ts

@@ -0,0 +1,37 @@
+import { IndirectCostConfig } from "./IndirectCostConfig";
+export declare class IndirectCostCalculator {
+    /**
+     * Calcula el factor total de costos indirectos para una configuración
+     * @param config Configuración de costos indirectos
+     * @returns Factor total (0..1)
+     */
+    static calculateTotalIndirectFactor(config: IndirectCostConfig): number;
+    /**
+     * Calcula el desglose de costos indirectos por categoría
+     * @param config Configuración de costos indirectos
+     * @param directCost Costo directo base
+     * @returns Desglose por categoría
+     */
+    static calculateIndirectCostBreakdown(config: IndirectCostConfig, directCost: number): {
+        [category: string]: {
+            percentage: number;
+            amount: number;
+            name: string;
+        };
+    };
+    /**
+     * Calcula el costo total incluyendo indirectos
+     * @param directCost Costo directo
+     * @param config Configuración de costos indirectos
+     * @returns Costo total
+     */
+    static calculateTotalCost(directCost: number, config: IndirectCostConfig): number;
+    /**
+     * Crea una configuración de costos indirectos desde una plantilla
+     * @param template Plantilla base
+     * @param scope Ámbito de aplicación (APU o PROJECT)
+     * @returns Configuración de costos indirectos
+     */
+    static createConfigFromTemplate(template: any, // IndirectCostTemplate
+    scope: "APU" | "PROJECT"): Partial<IndirectCostConfig>;
+}

package/dist/models/apu/IndirectCostCalculator.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndirectCostCalculator = void 0;
+class IndirectCostCalculator {
+    /**
+     * Calcula el factor total de costos indirectos para una configuración
+     * @param config Configuración de costos indirectos
+     * @returns Factor total (0..1)
+     */
+    static calculateTotalIndirectFactor(config) {
+        if (!config.items || config.items.length === 0) {
+            return 0;
+        }
+        return config.items
+            .filter(item => item.isActive)
+            .reduce((total, item) => total + item.percentage, 0);
+    }
+    /**
+     * Calcula el desglose de costos indirectos por categoría
+     * @param config Configuración de costos indirectos
+     * @param directCost Costo directo base
+     * @returns Desglose por categoría
+     */
+    static calculateIndirectCostBreakdown(config, directCost) {
+        const breakdown = {};
+        if (!config.items) {
+            return breakdown;
+        }
+        config.items
+            .filter(item => item.isActive)
+            .forEach(item => {
+            breakdown[item.category] = {
+                percentage: item.percentage,
+                amount: directCost * item.percentage + (item.fixedAmount || 0),
+                name: item.name
+            };
+        });
+        return breakdown;
+    }
+    /**
+     * Calcula el costo total incluyendo indirectos
+     * @param directCost Costo directo
+     * @param config Configuración de costos indirectos
+     * @returns Costo total
+     */
+    static calculateTotalCost(directCost, config) {
+        var _a;
+        const indirectFactor = this.calculateTotalIndirectFactor(config);
+        const indirectCost = directCost * indirectFactor;
+        // Agregar montos fijos si existen
+        const fixedAmounts = ((_a = config.items) === null || _a === void 0 ? void 0 : _a.filter(item => item.isActive && item.fixedAmount).reduce((sum, item) => sum + (item.fixedAmount || 0), 0)) || 0;
+        return directCost + indirectCost + fixedAmounts;
+    }
+    /**
+     * Crea una configuración de costos indirectos desde una plantilla
+     * @param template Plantilla base
+     * @param scope Ámbito de aplicación (APU o PROJECT)
+     * @returns Configuración de costos indirectos
+     */
+    static createConfigFromTemplate(template, // IndirectCostTemplate
+    scope) {
+        var _a;
+        return {
+            scope: scope,
+            template: template,
+            name: `Config basada en ${template.name}`,
+            description: template.description,
+            items: (_a = template.items) === null || _a === void 0 ? void 0 : _a.map((templateItem) => ({
+                category: templateItem.category,
+                name: templateItem.name,
+                description: templateItem.description,
+                percentage: templateItem.percentage,
+                sortOrder: templateItem.sortOrder,
+                isActive: true
+            }))
+        };
+    }
+}
+exports.IndirectCostCalculator = IndirectCostCalculator;

package/dist/models/apu/IndirectCostConfig.d.ts

@@ -0,0 +1,19 @@
+import { ObjectLiteral } from "typeorm";
+import { Apu } from "./Apu";
+import { Project } from "./Project";
+import { IndirectCostTemplate } from "./IndirectCostTemplate";
+import { IndirectCostItem } from "./IndirectCostItem";
+export declare enum IndirectCostScope {
+    APU = "APU",// Aplica solo a un APU específico
+    PROJECT = "PROJECT"
+}
+export declare class IndirectCostConfig implements ObjectLiteral {
+    idIndirectCostConfig: number;
+    scope: IndirectCostScope;
+    apu?: Apu | null;
+    project?: Project | null;
+    template?: IndirectCostTemplate | null;
+    name?: string | null;
+    description?: string | null;
+    items?: IndirectCostItem[];
+}

package/dist/models/apu/IndirectCostConfig.js

@@ -0,0 +1,69 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndirectCostConfig = exports.IndirectCostScope = void 0;
+// apu/entities/IndirectCostConfig.ts
+const typeorm_1 = require("typeorm");
+const Apu_1 = require("./Apu");
+const Project_1 = require("./Project");
+const IndirectCostTemplate_1 = require("./IndirectCostTemplate");
+const IndirectCostItem_1 = require("./IndirectCostItem");
+var IndirectCostScope;
+(function (IndirectCostScope) {
+    IndirectCostScope["APU"] = "APU";
+    IndirectCostScope["PROJECT"] = "PROJECT"; // Aplica a todo el proyecto
+})(IndirectCostScope || (exports.IndirectCostScope = IndirectCostScope = {}));
+let IndirectCostConfig = class IndirectCostConfig {
+};
+exports.IndirectCostConfig = IndirectCostConfig;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)("increment"),
+    __metadata("design:type", Number)
+], IndirectCostConfig.prototype, "idIndirectCostConfig", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: "enum",
+        enum: IndirectCostScope
+    }),
+    __metadata("design:type", String)
+], IndirectCostConfig.prototype, "scope", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Apu_1.Apu, { nullable: true, onDelete: "CASCADE" }),
+    (0, typeorm_1.JoinColumn)({ name: "idApu" }),
+    __metadata("design:type", Object)
+], IndirectCostConfig.prototype, "apu", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => Project_1.Project, { nullable: true, onDelete: "CASCADE" }),
+    (0, typeorm_1.JoinColumn)({ name: "idProject" }),
+    __metadata("design:type", Object)
+], IndirectCostConfig.prototype, "project", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => IndirectCostTemplate_1.IndirectCostTemplate, { nullable: true }),
+    (0, typeorm_1.JoinColumn)({ name: "idIndirectCostTemplate" }),
+    __metadata("design:type", Object)
+], IndirectCostConfig.prototype, "template", void 0);
+__decorate([
+    (0, typeorm_1.Column)("varchar", { length: 255, nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostConfig.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)("text", { nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostConfig.prototype, "description", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => IndirectCostItem_1.IndirectCostItem, (item) => item.config, { cascade: true }),
+    __metadata("design:type", Array)
+], IndirectCostConfig.prototype, "items", void 0);
+exports.IndirectCostConfig = IndirectCostConfig = __decorate([
+    (0, typeorm_1.Entity)("indirect_cost_configs"),
+    (0, typeorm_1.Index)(["apu"], { unique: true, where: "scope = 'APU'" }),
+    (0, typeorm_1.Index)(["project"], { unique: true, where: "scope = 'PROJECT'" })
+], IndirectCostConfig);

package/dist/models/apu/IndirectCostItem.d.ts

@@ -0,0 +1,14 @@
+import { ObjectLiteral } from "typeorm";
+import { IndirectCostConfig } from "./IndirectCostConfig";
+import { IndirectCostCategory } from "./IndirectCostTemplateItem";
+export declare class IndirectCostItem implements ObjectLiteral {
+    idIndirectCostItem: number;
+    config: IndirectCostConfig;
+    category: IndirectCostCategory;
+    name: string;
+    description?: string | null;
+    percentage: number;
+    fixedAmount?: number | null;
+    sortOrder: number;
+    isActive: boolean;
+}

package/dist/models/apu/IndirectCostItem.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndirectCostItem = void 0;
+// apu/entities/IndirectCostItem.ts
+const typeorm_1 = require("typeorm");
+const IndirectCostConfig_1 = require("./IndirectCostConfig");
+const IndirectCostTemplateItem_1 = require("./IndirectCostTemplateItem");
+let IndirectCostItem = class IndirectCostItem {
+};
+exports.IndirectCostItem = IndirectCostItem;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)("increment"),
+    __metadata("design:type", Number)
+], IndirectCostItem.prototype, "idIndirectCostItem", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => IndirectCostConfig_1.IndirectCostConfig, { nullable: false, onDelete: "CASCADE" }),
+    (0, typeorm_1.JoinColumn)({ name: "idIndirectCostConfig" }),
+    __metadata("design:type", IndirectCostConfig_1.IndirectCostConfig)
+], IndirectCostItem.prototype, "config", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: "enum",
+        enum: IndirectCostTemplateItem_1.IndirectCostCategory
+    }),
+    __metadata("design:type", String)
+], IndirectCostItem.prototype, "category", void 0);
+__decorate([
+    (0, typeorm_1.Column)("varchar", { length: 255 }),
+    __metadata("design:type", String)
+], IndirectCostItem.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)("text", { nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostItem.prototype, "description", void 0);
+__decorate([
+    (0, typeorm_1.Column)("decimal", { precision: 5, scale: 4, default: 0 }),
+    __metadata("design:type", Number)
+], IndirectCostItem.prototype, "percentage", void 0);
+__decorate([
+    (0, typeorm_1.Column)("decimal", { precision: 18, scale: 2, nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostItem.prototype, "fixedAmount", void 0);
+__decorate([
+    (0, typeorm_1.Column)("int", { default: 0 }),
+    __metadata("design:type", Number)
+], IndirectCostItem.prototype, "sortOrder", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: "boolean", default: true }),
+    __metadata("design:type", Boolean)
+], IndirectCostItem.prototype, "isActive", void 0);
+exports.IndirectCostItem = IndirectCostItem = __decorate([
+    (0, typeorm_1.Entity)("indirect_cost_items"),
+    (0, typeorm_1.Index)(["config", "category"], { unique: true }),
+    (0, typeorm_1.Check)(`"percentage" >= 0 AND "percentage" <= 1`)
+], IndirectCostItem);

package/dist/models/apu/IndirectCostTemplate.d.ts

@@ -0,0 +1,10 @@
+import { ObjectLiteral } from "typeorm";
+import { IndirectCostTemplateItem } from "./IndirectCostTemplateItem";
+export declare class IndirectCostTemplate implements ObjectLiteral {
+    idIndirectCostTemplate: number;
+    name: string;
+    description?: string | null;
+    projectType?: string | null;
+    isActive: boolean;
+    items?: IndirectCostTemplateItem[];
+}

package/dist/models/apu/IndirectCostTemplate.js

@@ -0,0 +1,46 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndirectCostTemplate = void 0;
+// apu/entities/IndirectCostTemplate.ts
+const typeorm_1 = require("typeorm");
+const IndirectCostTemplateItem_1 = require("./IndirectCostTemplateItem");
+let IndirectCostTemplate = class IndirectCostTemplate {
+};
+exports.IndirectCostTemplate = IndirectCostTemplate;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)("increment"),
+    __metadata("design:type", Number)
+], IndirectCostTemplate.prototype, "idIndirectCostTemplate", void 0);
+__decorate([
+    (0, typeorm_1.Column)("varchar", { length: 255, unique: true }),
+    __metadata("design:type", String)
+], IndirectCostTemplate.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)("text", { nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostTemplate.prototype, "description", void 0);
+__decorate([
+    (0, typeorm_1.Column)("varchar", { length: 64, nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostTemplate.prototype, "projectType", void 0);
+__decorate([
+    (0, typeorm_1.Column)({ type: "boolean", default: true }),
+    __metadata("design:type", Boolean)
+], IndirectCostTemplate.prototype, "isActive", void 0);
+__decorate([
+    (0, typeorm_1.OneToMany)(() => IndirectCostTemplateItem_1.IndirectCostTemplateItem, (item) => item.template, { cascade: true }),
+    __metadata("design:type", Array)
+], IndirectCostTemplate.prototype, "items", void 0);
+exports.IndirectCostTemplate = IndirectCostTemplate = __decorate([
+    (0, typeorm_1.Entity)("indirect_cost_templates"),
+    (0, typeorm_1.Index)(["name"], { unique: true })
+], IndirectCostTemplate);

package/dist/models/apu/IndirectCostTemplateItem.d.ts

@@ -0,0 +1,19 @@
+import { ObjectLiteral } from "typeorm";
+import { IndirectCostTemplate } from "./IndirectCostTemplate";
+export declare enum IndirectCostCategory {
+    ADMIN_CENTRAL = "ADMIN_CENTRAL",
+    ADMIN_OBRA = "ADMIN_OBRA",
+    VIATICOS_TRANSPORTE = "VIATICOS_TRANSPORTE",
+    HERRAMIENTAS_EQUIPO = "HERRAMIENTAS_EQUIPO",
+    SEGUROS_FIANZAS = "SEGUROS_FIANZAS",
+    IMPREVISTOS = "IMPREVISTOS"
+}
+export declare class IndirectCostTemplateItem implements ObjectLiteral {
+    idIndirectCostTemplateItem: number;
+    template: IndirectCostTemplate;
+    category: IndirectCostCategory;
+    name: string;
+    description?: string | null;
+    percentage: number;
+    sortOrder: number;
+}

package/dist/models/apu/IndirectCostTemplateItem.js

@@ -0,0 +1,64 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndirectCostTemplateItem = exports.IndirectCostCategory = void 0;
+// apu/entities/IndirectCostTemplateItem.ts
+const typeorm_1 = require("typeorm");
+const IndirectCostTemplate_1 = require("./IndirectCostTemplate");
+var IndirectCostCategory;
+(function (IndirectCostCategory) {
+    IndirectCostCategory["ADMIN_CENTRAL"] = "ADMIN_CENTRAL";
+    IndirectCostCategory["ADMIN_OBRA"] = "ADMIN_OBRA";
+    IndirectCostCategory["VIATICOS_TRANSPORTE"] = "VIATICOS_TRANSPORTE";
+    IndirectCostCategory["HERRAMIENTAS_EQUIPO"] = "HERRAMIENTAS_EQUIPO";
+    IndirectCostCategory["SEGUROS_FIANZAS"] = "SEGUROS_FIANZAS";
+    IndirectCostCategory["IMPREVISTOS"] = "IMPREVISTOS";
+})(IndirectCostCategory || (exports.IndirectCostCategory = IndirectCostCategory = {}));
+let IndirectCostTemplateItem = class IndirectCostTemplateItem {
+};
+exports.IndirectCostTemplateItem = IndirectCostTemplateItem;
+__decorate([
+    (0, typeorm_1.PrimaryGeneratedColumn)("increment"),
+    __metadata("design:type", Number)
+], IndirectCostTemplateItem.prototype, "idIndirectCostTemplateItem", void 0);
+__decorate([
+    (0, typeorm_1.ManyToOne)(() => IndirectCostTemplate_1.IndirectCostTemplate, { nullable: false, onDelete: "CASCADE" }),
+    (0, typeorm_1.JoinColumn)({ name: "idIndirectCostTemplate" }),
+    __metadata("design:type", IndirectCostTemplate_1.IndirectCostTemplate)
+], IndirectCostTemplateItem.prototype, "template", void 0);
+__decorate([
+    (0, typeorm_1.Column)({
+        type: "enum",
+        enum: IndirectCostCategory
+    }),
+    __metadata("design:type", String)
+], IndirectCostTemplateItem.prototype, "category", void 0);
+__decorate([
+    (0, typeorm_1.Column)("varchar", { length: 255 }),
+    __metadata("design:type", String)
+], IndirectCostTemplateItem.prototype, "name", void 0);
+__decorate([
+    (0, typeorm_1.Column)("text", { nullable: true }),
+    __metadata("design:type", Object)
+], IndirectCostTemplateItem.prototype, "description", void 0);
+__decorate([
+    (0, typeorm_1.Column)("decimal", { precision: 5, scale: 4, default: 0 }),
+    __metadata("design:type", Number)
+], IndirectCostTemplateItem.prototype, "percentage", void 0);
+__decorate([
+    (0, typeorm_1.Column)("int", { default: 0 }),
+    __metadata("design:type", Number)
+], IndirectCostTemplateItem.prototype, "sortOrder", void 0);
+exports.IndirectCostTemplateItem = IndirectCostTemplateItem = __decorate([
+    (0, typeorm_1.Entity)("indirect_cost_template_items"),
+    (0, typeorm_1.Index)(["template", "category"], { unique: true }),
+    (0, typeorm_1.Check)(`"percentage" >= 0 AND "percentage" <= 1`)
+], IndirectCostTemplateItem);

package/dist/models/apu/index.d.ts

@@ -12,3 +12,9 @@ export { Resource } from './Resource';
 export { ResourcePrice } from './ResourcePrice';
 export { ResourceType } from './enums/resource-type.enum';
 export { BudgetSnapshot } from './budget-snapshot.entity';
+export { IndirectCostTemplate } from './IndirectCostTemplate';
+export { IndirectCostTemplateItem, IndirectCostCategory } from './IndirectCostTemplateItem';
+export { IndirectCostConfig, IndirectCostScope } from './IndirectCostConfig';
+export { IndirectCostItem } from './IndirectCostItem';
+export { IndirectCostCalculator } from './IndirectCostCalculator';
+export { ConceptCategory } from './Concept';

package/dist/models/apu/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BudgetSnapshot = exports.ResourceType = exports.ResourcePrice = exports.Resource = exports.Project = exports.PriceList = exports.Concept = exports.Company = exports.Client = exports.BudgetCancellationFolio = exports.BudgetItem = exports.Budget = exports.ApuItem = exports.Apu = void 0;
+exports.ConceptCategory = exports.IndirectCostCalculator = exports.IndirectCostItem = exports.IndirectCostScope = exports.IndirectCostConfig = exports.IndirectCostCategory = exports.IndirectCostTemplateItem = exports.IndirectCostTemplate = exports.BudgetSnapshot = exports.ResourceType = exports.ResourcePrice = exports.Resource = exports.Project = exports.PriceList = exports.Concept = exports.Company = exports.Client = exports.BudgetCancellationFolio = exports.BudgetItem = exports.Budget = exports.ApuItem = exports.Apu = void 0;
 var Apu_1 = require("./Apu"); //
 Object.defineProperty(exports, "Apu", { enumerable: true, get: function () { return Apu_1.Apu; } });
 var ApuItem_1 = require("./ApuItem"); //
@@ -29,3 +29,19 @@ var resource_type_enum_1 = require("./enums/resource-type.enum");
 Object.defineProperty(exports, "ResourceType", { enumerable: true, get: function () { return resource_type_enum_1.ResourceType; } });
 var budget_snapshot_entity_1 = require("./budget-snapshot.entity");
 Object.defineProperty(exports, "BudgetSnapshot", { enumerable: true, get: function () { return budget_snapshot_entity_1.BudgetSnapshot; } });
+// Indirect Cost System
+var IndirectCostTemplate_1 = require("./IndirectCostTemplate");
+Object.defineProperty(exports, "IndirectCostTemplate", { enumerable: true, get: function () { return IndirectCostTemplate_1.IndirectCostTemplate; } });
+var IndirectCostTemplateItem_1 = require("./IndirectCostTemplateItem");
+Object.defineProperty(exports, "IndirectCostTemplateItem", { enumerable: true, get: function () { return IndirectCostTemplateItem_1.IndirectCostTemplateItem; } });
+Object.defineProperty(exports, "IndirectCostCategory", { enumerable: true, get: function () { return IndirectCostTemplateItem_1.IndirectCostCategory; } });
+var IndirectCostConfig_1 = require("./IndirectCostConfig");
+Object.defineProperty(exports, "IndirectCostConfig", { enumerable: true, get: function () { return IndirectCostConfig_1.IndirectCostConfig; } });
+Object.defineProperty(exports, "IndirectCostScope", { enumerable: true, get: function () { return IndirectCostConfig_1.IndirectCostScope; } });
+var IndirectCostItem_1 = require("./IndirectCostItem");
+Object.defineProperty(exports, "IndirectCostItem", { enumerable: true, get: function () { return IndirectCostItem_1.IndirectCostItem; } });
+var IndirectCostCalculator_1 = require("./IndirectCostCalculator");
+Object.defineProperty(exports, "IndirectCostCalculator", { enumerable: true, get: function () { return IndirectCostCalculator_1.IndirectCostCalculator; } });
+// Export ConceptCategory enum
+var Concept_2 = require("./Concept");
+Object.defineProperty(exports, "ConceptCategory", { enumerable: true, get: function () { return Concept_2.ConceptCategory; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "proflores-db-model",
-  "version": "0.2.47",
+  "version": "0.2.49",
   "description": "Data model for managing expenses and transactions for Proflores nursery business",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/models/apu/Apu.ts

@@ -3,6 +3,7 @@ import {
 } from "typeorm";
 import { Concept } from "./Concept";
 import { ApuItem } from "./ApuItem";
+import { IndirectCostConfig } from "./IndirectCostConfig";
 
 @Entity("apu")
 @Unique("uq_apu_concept_version", ["concept", "version"])
@@ -37,4 +38,7 @@ export class Apu implements ObjectLiteral {
 
   @OneToMany(() => ApuItem, (ai) => ai.apu, { cascade: true })
   items?: ApuItem[];
+
+  @OneToMany(() => IndirectCostConfig, (config) => config.apu)
+  indirectCostConfig?: IndirectCostConfig;
 }

package/src/models/apu/Concept.ts

@@ -6,6 +6,19 @@ import { UnitOfMeasure } from "../../entities/UnitOfMesure"; // <-- ajusta tu ru
 import { Apu } from "./Apu";
 import { BudgetItem } from "./BudgetItem";
 
+export enum ConceptCategory {
+  JARDINERIA = "JAR",
+  RIEGO = "RIE", 
+  OBRAS_CIVILES = "OBR",
+  MOBILIARIO = "MOB",
+  TERRACERIAS = "TER",
+  MANTENIMIENTO = "MAN",
+  MATERIALES = "MAT",
+  MANO_DE_OBRA = "LAB",
+  HERRAMIENTAS = "TOOL",
+  FERTILIZACION = "FER"
+}
+
 @Entity("concepts")
 @Index(["code"], { unique: true })
 export class Concept implements ObjectLiteral {
@@ -31,8 +44,12 @@ export class Concept implements ObjectLiteral {
   @Column("varchar", { length: 64, nullable: true })
   satUnit?: string | null;
 
-  @Column("varchar", { length: 64, nullable: true })
-  category?: string | null;
+  @Column({
+    type: "enum",
+    enum: ConceptCategory,
+    nullable: true
+  })
+  category?: ConceptCategory | null;
 
   @Column({ type: "boolean", default: true })
   isActive!: boolean;

package/src/models/apu/IndirectCostCalculator.ts

@@ -0,0 +1,92 @@
+// apu/utils/IndirectCostCalculator.ts
+import { IndirectCostConfig } from "./IndirectCostConfig";
+
+export class IndirectCostCalculator {
+  /**
+   * Calcula el factor total de costos indirectos para una configuración
+   * @param config Configuración de costos indirectos
+   * @returns Factor total (0..1)
+   */
+  static calculateTotalIndirectFactor(config: IndirectCostConfig): number {
+    if (!config.items || config.items.length === 0) {
+      return 0;
+    }
+
+    return config.items
+      .filter(item => item.isActive)
+      .reduce((total, item) => total + item.percentage, 0);
+  }
+
+  /**
+   * Calcula el desglose de costos indirectos por categoría
+   * @param config Configuración de costos indirectos
+   * @param directCost Costo directo base
+   * @returns Desglose por categoría
+   */
+  static calculateIndirectCostBreakdown(
+    config: IndirectCostConfig, 
+    directCost: number
+  ): { [category: string]: { percentage: number; amount: number; name: string } } {
+    const breakdown: { [category: string]: { percentage: number; amount: number; name: string } } = {};
+
+    if (!config.items) {
+      return breakdown;
+    }
+
+    config.items
+      .filter(item => item.isActive)
+      .forEach(item => {
+        breakdown[item.category] = {
+          percentage: item.percentage,
+          amount: directCost * item.percentage + (item.fixedAmount || 0),
+          name: item.name
+        };
+      });
+
+    return breakdown;
+  }
+
+  /**
+   * Calcula el costo total incluyendo indirectos
+   * @param directCost Costo directo
+   * @param config Configuración de costos indirectos
+   * @returns Costo total
+   */
+  static calculateTotalCost(directCost: number, config: IndirectCostConfig): number {
+    const indirectFactor = this.calculateTotalIndirectFactor(config);
+    const indirectCost = directCost * indirectFactor;
+    
+    // Agregar montos fijos si existen
+    const fixedAmounts = config.items
+      ?.filter(item => item.isActive && item.fixedAmount)
+      .reduce((sum, item) => sum + (item.fixedAmount || 0), 0) || 0;
+
+    return directCost + indirectCost + fixedAmounts;
+  }
+
+  /**
+   * Crea una configuración de costos indirectos desde una plantilla
+   * @param template Plantilla base
+   * @param scope Ámbito de aplicación (APU o PROJECT)
+   * @returns Configuración de costos indirectos
+   */
+  static createConfigFromTemplate(
+    template: any, // IndirectCostTemplate
+    scope: "APU" | "PROJECT"
+  ): Partial<IndirectCostConfig> {
+    return {
+      scope: scope as any,
+      template: template,
+      name: `Config basada en ${template.name}`,
+      description: template.description,
+      items: template.items?.map((templateItem: any) => ({
+        category: templateItem.category,
+        name: templateItem.name,
+        description: templateItem.description,
+        percentage: templateItem.percentage,
+        sortOrder: templateItem.sortOrder,
+        isActive: true
+      }))
+    };
+  }
+}

package/src/models/apu/IndirectCostConfig.ts

@@ -0,0 +1,48 @@
+// apu/entities/IndirectCostConfig.ts
+import {
+  Entity, PrimaryGeneratedColumn, Column, ObjectLiteral, ManyToOne, OneToMany, JoinColumn, Index,
+} from "typeorm";
+import { Apu } from "./Apu";
+import { Project } from "./Project";
+import { IndirectCostTemplate } from "./IndirectCostTemplate";
+import { IndirectCostItem } from "./IndirectCostItem";
+
+export enum IndirectCostScope {
+  APU = "APU",           // Aplica solo a un APU específico
+  PROJECT = "PROJECT"    // Aplica a todo el proyecto
+}
+
+@Entity("indirect_cost_configs")
+@Index(["apu"], { unique: true, where: "scope = 'APU'" })
+@Index(["project"], { unique: true, where: "scope = 'PROJECT'" })
+export class IndirectCostConfig implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idIndirectCostConfig!: number;
+
+  @Column({
+    type: "enum",
+    enum: IndirectCostScope
+  })
+  scope!: IndirectCostScope;
+
+  @ManyToOne(() => Apu, { nullable: true, onDelete: "CASCADE" })
+  @JoinColumn({ name: "idApu" })
+  apu?: Apu | null;
+
+  @ManyToOne(() => Project, { nullable: true, onDelete: "CASCADE" })
+  @JoinColumn({ name: "idProject" })
+  project?: Project | null;
+
+  @ManyToOne(() => IndirectCostTemplate, { nullable: true })
+  @JoinColumn({ name: "idIndirectCostTemplate" })
+  template?: IndirectCostTemplate | null;
+
+  @Column("varchar", { length: 255, nullable: true })
+  name?: string | null;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @OneToMany(() => IndirectCostItem, (item) => item.config, { cascade: true })
+  items?: IndirectCostItem[];
+}

package/src/models/apu/IndirectCostItem.ts

@@ -0,0 +1,42 @@
+// apu/entities/IndirectCostItem.ts
+import {
+  Entity, PrimaryGeneratedColumn, Column, ObjectLiteral, ManyToOne, JoinColumn, Index, Check,
+} from "typeorm";
+import { IndirectCostConfig } from "./IndirectCostConfig";
+import { IndirectCostCategory } from "./IndirectCostTemplateItem";
+
+@Entity("indirect_cost_items")
+@Index(["config", "category"], { unique: true })
+@Check(`"percentage" >= 0 AND "percentage" <= 1`)
+export class IndirectCostItem implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idIndirectCostItem!: number;
+
+  @ManyToOne(() => IndirectCostConfig, { nullable: false, onDelete: "CASCADE" })
+  @JoinColumn({ name: "idIndirectCostConfig" })
+  config!: IndirectCostConfig;
+
+  @Column({
+    type: "enum",
+    enum: IndirectCostCategory
+  })
+  category!: IndirectCostCategory;
+
+  @Column("varchar", { length: 255 })
+  name!: string;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @Column("decimal", { precision: 5, scale: 4, default: 0 })
+  percentage!: number; // 0..1 (porcentaje sobre costo directo)
+
+  @Column("decimal", { precision: 18, scale: 2, nullable: true })
+  fixedAmount?: number | null; // Monto fijo opcional
+
+  @Column("int", { default: 0 })
+  sortOrder!: number;
+
+  @Column({ type: "boolean", default: true })
+  isActive!: boolean;
+}

package/src/models/apu/IndirectCostTemplate.ts

@@ -0,0 +1,27 @@
+// apu/entities/IndirectCostTemplate.ts
+import {
+  Entity, PrimaryGeneratedColumn, Column, ObjectLiteral, OneToMany, Index,
+} from "typeorm";
+import { IndirectCostTemplateItem } from "./IndirectCostTemplateItem";
+
+@Entity("indirect_cost_templates")
+@Index(["name"], { unique: true })
+export class IndirectCostTemplate implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idIndirectCostTemplate!: number;
+
+  @Column("varchar", { length: 255, unique: true })
+  name!: string;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @Column("varchar", { length: 64, nullable: true })
+  projectType?: string | null; // Tipo de obra: "JARDINERIA", "RIEGO", etc.
+
+  @Column({ type: "boolean", default: true })
+  isActive!: boolean;
+
+  @OneToMany(() => IndirectCostTemplateItem, (item) => item.template, { cascade: true })
+  items?: IndirectCostTemplateItem[];
+}

package/src/models/apu/IndirectCostTemplateItem.ts

@@ -0,0 +1,44 @@
+// apu/entities/IndirectCostTemplateItem.ts
+import {
+  Entity, PrimaryGeneratedColumn, Column, ObjectLiteral, ManyToOne, JoinColumn, Index, Check,
+} from "typeorm";
+import { IndirectCostTemplate } from "./IndirectCostTemplate";
+
+export enum IndirectCostCategory {
+  ADMIN_CENTRAL = "ADMIN_CENTRAL",
+  ADMIN_OBRA = "ADMIN_OBRA", 
+  VIATICOS_TRANSPORTE = "VIATICOS_TRANSPORTE",
+  HERRAMIENTAS_EQUIPO = "HERRAMIENTAS_EQUIPO",
+  SEGUROS_FIANZAS = "SEGUROS_FIANZAS",
+  IMPREVISTOS = "IMPREVISTOS"
+}
+
+@Entity("indirect_cost_template_items")
+@Index(["template", "category"], { unique: true })
+@Check(`"percentage" >= 0 AND "percentage" <= 1`)
+export class IndirectCostTemplateItem implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idIndirectCostTemplateItem!: number;
+
+  @ManyToOne(() => IndirectCostTemplate, { nullable: false, onDelete: "CASCADE" })
+  @JoinColumn({ name: "idIndirectCostTemplate" })
+  template!: IndirectCostTemplate;
+
+  @Column({
+    type: "enum",
+    enum: IndirectCostCategory
+  })
+  category!: IndirectCostCategory;
+
+  @Column("varchar", { length: 255 })
+  name!: string;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @Column("decimal", { precision: 5, scale: 4, default: 0 })
+  percentage!: number; // 0..1 (porcentaje sobre costo directo)
+
+  @Column("int", { default: 0 })
+  sortOrder!: number;
+}

package/src/models/apu/index.ts

@@ -11,4 +11,14 @@ export { Project } from './Project';
 export { Resource } from './Resource'; //
 export { ResourcePrice } from './ResourcePrice'; // 
 export { ResourceType } from './enums/resource-type.enum';
-export { BudgetSnapshot } from './budget-snapshot.entity'
+export { BudgetSnapshot } from './budget-snapshot.entity';
+
+// Indirect Cost System
+export { IndirectCostTemplate } from './IndirectCostTemplate';
+export { IndirectCostTemplateItem, IndirectCostCategory } from './IndirectCostTemplateItem';
+export { IndirectCostConfig, IndirectCostScope } from './IndirectCostConfig';
+export { IndirectCostItem } from './IndirectCostItem';
+export { IndirectCostCalculator } from './IndirectCostCalculator';
+
+// Export ConceptCategory enum
+export { ConceptCategory } from './Concept';