proflores-db-model 0.1.33 → 0.2.0

package/src/models/technical-sheet/ImageInfo.ts

@@ -0,0 +1,111 @@
+import {
+  Entity,
+  PrimaryGeneratedColumn,
+  Column,
+  ObjectLiteral,
+  ManyToOne,
+  JoinColumn,
+} from "typeorm";
+import { PlantTechnicalSheet } from "./PlantTechnicalSheet";
+import { PlantGrowthType } from "./PlantGrowthType";
+import { LightInfo } from "./LightInfo";
+import { HumidityInfo } from "./HumidityInfo";
+import { ClimateIdeal } from "./ClimateIdeal";
+import { SubstrateInfo } from "./SubstrateInfo";
+import { FertilizationInfo } from "./FertilizationInfo";
+import { PestInfo } from "./PestInfo";
+import { PropagationMethodInfo } from "./PropagationMethodInfo";
+import { PlantSize } from "./PlantSize";
+import { GrowthClassInfo } from "./GrowthClassInfo";
+
+@Entity("technical_sheet_images")
+export class ImageInfo implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idImage!: number;
+
+  @Column("varchar", { length: 500 })
+  url!: string;
+
+  @Column("text", { nullable: true })
+  description?: string;
+
+  @Column({ type: "boolean", default: true })
+  isActive!: boolean;
+
+  @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "plantTechnicalSheetId" })
+  plantTechnicalSheet?: PlantTechnicalSheet;
+
+  @ManyToOne(() => PlantGrowthType, (growthType) => growthType.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "plantGrowthTypeId" })
+  plantGrowthType?: PlantGrowthType;
+
+  @ManyToOne(() => LightInfo, (lightInfo) => lightInfo.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "lightInfoId" })
+  lightInfo?: LightInfo;
+
+  @ManyToOne(() => HumidityInfo, (humidityInfo) => humidityInfo.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "humidityInfoId" })
+  humidityInfo?: HumidityInfo;
+
+  @ManyToOne(() => ClimateIdeal, (climate) => climate.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "climateIdealId" })
+  climateIdeal?: ClimateIdeal;
+
+  @ManyToOne(() => SubstrateInfo, (substrate) => substrate.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "substrateInfoId" })
+  substrateInfo?: SubstrateInfo;
+
+  @ManyToOne(() => FertilizationInfo, (f) => f.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "fertilizationInfoId" })
+  fertilizationInfo?: FertilizationInfo;
+
+  @ManyToOne(() => PestInfo, (pest) => pest.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "pestId" })
+  pest?: PestInfo;
+
+  @ManyToOne(() => PropagationMethodInfo, (info) => info.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "propagationMethodId" })
+  propagationMethod?: PropagationMethodInfo;
+
+  @ManyToOne(() => PlantSize, (size) => size.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "plantSizeId" })
+  plantSize?: PlantSize;
+
+  @ManyToOne(() => GrowthClassInfo, (growthClass) => growthClass.images, {
+    nullable: true,
+    onDelete: "CASCADE",
+  })
+  @JoinColumn({ name: "growthClassInfoId" })
+  growthClassInfo?: GrowthClassInfo;
+}

package/src/models/technical-sheet/LightInfo.ts

@@ -0,0 +1,31 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    OneToMany,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { LIGHT, LightRequirement } from './catalogs/light-info';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('light_info')
+  export class LightInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idLightInfo!: number;
+  
+    @EnumColumn(Object.keys(LIGHT) as LightRequirement[])
+    type!: LightRequirement;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.lightInfo, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PestInfo.ts

@@ -0,0 +1,65 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ObjectLiteral,
+    ManyToOne,
+    JoinColumn,
+    OneToMany,
+  } from 'typeorm';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  import {
+    PEST_TYPE,
+    PestType,
+    PLANT_PART,
+    PlantPart,
+    CONTROL_METHOD,
+    ControlMethod,
+  } from './catalogs/pest-info';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('pests')
+  export class PestInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idPestInfo!: number;
+  
+    @Column('varchar', { length: 255 })
+    commonName!: string;
+  
+    @Column('varchar', { nullable: true, length: 255 })
+    scientificName?: string;
+  
+    @EnumColumn(Object.keys(PEST_TYPE) as PestType[])
+    type!: PestType;
+  
+    @EnumColumn(Object.keys(PLANT_PART) as PlantPart[])
+    affectedParts!: PlantPart;
+  
+    @Column('text')
+    symptoms!: string;
+  
+    @Column('text', { nullable: true })
+    appearanceConditions?: string;
+  
+    @EnumColumn(Object.keys(CONTROL_METHOD) as ControlMethod[])
+    controlMethod!: ControlMethod;
+  
+    @Column('text', { nullable: true })
+    controlNotes?: string;
+  
+    @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.pests, {
+      onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'technicalSheetId' })
+    technicalSheet!: PlantTechnicalSheet;
+  
+    @OneToMany(() => ImageInfo, (image) => image.pest, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PlantGrowthType.ts

@@ -0,0 +1,41 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ObjectLiteral,
+    OneToMany,
+  } from 'typeorm';
+  import { EnumColumn } from './utils/enumColumn';
+  import { GROWTH_AREA, GROWTH_HABIT } from './catalogs/growth-type';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  
+  export type PlantGrowthArea = keyof typeof GROWTH_AREA;
+  export type PlantGrowthHabit = keyof typeof GROWTH_HABIT;
+  
+  @Entity('plant_growth_types')
+  export class PlantGrowthType implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idPlantGrowthType!: number;
+  
+    @EnumColumn(Object.keys(GROWTH_AREA) as PlantGrowthArea[])
+    area!: PlantGrowthArea;
+  
+    @EnumColumn(Object.keys(GROWTH_HABIT) as PlantGrowthHabit[])
+    habit!: PlantGrowthHabit;
+  
+    @Column('text', { nullable: true })
+    description?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.plantGrowthType, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @OneToMany(() => PlantTechnicalSheet, (sheet) => sheet.plantType)
+    sheets!: PlantTechnicalSheet[];
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PlantSize.ts

@@ -0,0 +1,48 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    ManyToOne,
+    OneToMany,
+    JoinColumn,
+    ObjectLiteral,
+  } from 'typeorm';
+  import { GROWTH_HABIT_GEOM, GrowthHabit } from './catalogs/plant-size';
+  import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+  import { ImageInfo } from './ImageInfo';
+  import { EnumColumn } from './utils/enumColumn';
+  
+  @Entity('plant_size')
+  export class PlantSize implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idPlantSize!: number;
+  
+    @Column('int')
+    heightCm!: number;
+  
+    @Column('int', { nullable: true })
+    widthCm?: number | null;
+  
+    @EnumColumn(Object.keys(GROWTH_HABIT_GEOM) as GrowthHabit[], { nullable: true })
+    habit?: GrowthHabit | undefined;
+  
+    @Column('text', { nullable: true })
+    notes?: string | null;
+  
+    @OneToMany(() => ImageInfo, (image) => image.plantSize, {
+      cascade: true,
+      nullable: true,
+    })
+    images?: ImageInfo[] | undefined;
+  
+    @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.size, {
+      nullable: false,
+      onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'plantTechnicalSheetId' })
+    plantTechnicalSheet!: PlantTechnicalSheet;
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PlantTechnicalSheet.ts

@@ -0,0 +1,93 @@
+import {
+    Entity,
+    PrimaryGeneratedColumn,
+    Column,
+    ObjectLiteral,
+    OneToOne,
+    JoinColumn,
+    OneToMany,
+  } from "typeorm";
+  import { PlantGrowthType } from "./PlantGrowthType";
+  import { LightInfo } from "./LightInfo";
+  import { HumidityInfo } from "./HumidityInfo";
+  import { ClimateIdeal } from "./ClimateIdeal";
+  import { SubstrateInfo } from "./SubstrateInfo";
+  import { FertilizationInfo } from "./FertilizationInfo";
+  import { PestInfo } from "./PestInfo";
+  import { CareInstructions } from "./CareInstructions";
+  import { PropagationMethodInfo } from "./PropagationMethodInfo";
+  import { PlantSize } from "./PlantSize";
+  import { GrowthClassInfo } from "./GrowthClassInfo";
+  import { ImageInfo } from "./ImageInfo";
+  
+  @Entity("plant_technical_sheets")
+  export class PlantTechnicalSheet implements ObjectLiteral {
+    @PrimaryGeneratedColumn("increment")
+    idPlantTechnicalSheet!: number;
+  
+    @Column("varchar", { length: 255 })
+    commonName!: string;
+  
+    @Column("varchar", { length: 255 })
+    scientificName!: string;
+  
+    @Column("varchar", { length: 255 })
+    origin!: string;
+  
+    @OneToOne(() => PlantGrowthType, { cascade: true })
+    @JoinColumn({ name: "plantGrowthTypeId" })
+    plantType!: PlantGrowthType;
+  
+    @OneToOne(() => LightInfo, { cascade: true })
+    @JoinColumn({ name: "lightInfoId" })
+    light!: LightInfo;
+  
+    @OneToOne(() => HumidityInfo, { cascade: true })
+    @JoinColumn({ name: "humidityInfoId" })
+    humidity!: HumidityInfo;
+  
+    @OneToOne(() => ClimateIdeal, { cascade: true })
+    @JoinColumn({ name: "climateIdealId" })
+    climate!: ClimateIdeal;
+  
+    @OneToOne(() => SubstrateInfo, { cascade: true })
+    @JoinColumn({ name: "substrateInfoId" })
+    substrate!: SubstrateInfo;
+  
+    @OneToOne(() => FertilizationInfo, { cascade: true })
+    @JoinColumn({ name: "fertilizationInfoId" })
+    fertilization!: FertilizationInfo;
+  
+    @OneToMany(() => PestInfo, (pest) => pest.technicalSheet, {
+      cascade: true,
+    })
+    pests!: PestInfo[];
+  
+    @OneToOne(() => CareInstructions, { cascade: true })
+    @JoinColumn({ name: "careInstructionsId" })
+    care!: CareInstructions;
+  
+    @OneToOne(() => PropagationMethodInfo, { cascade: true })
+    @JoinColumn({ name: "propagationMethodId" })
+    propagation!: PropagationMethodInfo;
+  
+    @OneToOne(() => PlantSize, { cascade: true })
+    @JoinColumn({ name: "plantSizeId" })
+    size!: PlantSize;
+  
+    @OneToOne(() => GrowthClassInfo, { cascade: true })
+    @JoinColumn({ name: "growthClassInfoId" })
+    growthClass!: GrowthClassInfo;
+  
+    @OneToMany(() => ImageInfo, (img) => img.plantTechnicalSheet, {
+      cascade: true,
+    })
+    images?: ImageInfo[];
+  
+    @Column("text", { nullable: true })
+    notes?: string;
+  
+    @Column({ type: "boolean", default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/PropagationMethodInfo.ts

@@ -0,0 +1,37 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  OneToMany,
+  ObjectLiteral,
+} from "typeorm";
+import { PropagationMethod, PROPAGATION } from "./catalogs/propagation-method";
+import { ImageInfo } from "./ImageInfo";
+import { PlantTechnicalSheet } from "./PlantTechnicalSheet";
+import { EnumColumn } from "./utils/enumColumn";
+
+@Entity("propagation_method_info")
+export class PropagationMethodInfo implements ObjectLiteral {
+  @PrimaryGeneratedColumn("increment")
+  idPropagationMethodInfo!: number;
+
+  @EnumColumn(Object.keys(PROPAGATION) as PropagationMethod[], {
+    nullable: false,
+  })
+  type!: PropagationMethod | undefined;
+
+  @Column("text", { nullable: true })
+  description?: string | null;
+
+  @OneToMany(() => ImageInfo, (image) => image.propagationMethod, {
+    cascade: true,
+    nullable: true,
+  })
+  images?: ImageInfo[] | undefined;
+
+  @OneToMany(() => PlantTechnicalSheet, (sheet) => sheet.propagation)
+  plantTechnicalSheets!: PlantTechnicalSheet[];
+
+  @Column({ type: "boolean", default: true })
+  isActive?: boolean | undefined;
+}

package/src/models/technical-sheet/SubstrateInfo.ts

@@ -0,0 +1,45 @@
+import {
+    Entity,
+    Column,
+    PrimaryGeneratedColumn,
+    ManyToOne,
+    OneToMany,
+    JoinColumn,
+    ObjectLiteral,
+} from 'typeorm';
+import { SubstrateType, SUBSTRATE } from './catalogs/substrate-info';
+import { ImageInfo } from './ImageInfo';
+import { PlantTechnicalSheet } from './PlantTechnicalSheet';
+import { EnumColumn } from './utils/enumColumn';
+
+  @Entity('substrate_info')
+  export class SubstrateInfo implements ObjectLiteral {
+    @PrimaryGeneratedColumn('increment')
+    idSubstrateInfo!: number;
+  
+    @EnumColumn(Object.keys(SUBSTRATE) as SubstrateType[])
+    type!: SubstrateType;
+  
+    @Column('text', { nullable: true })
+    recipe?: string;
+  
+    @Column('text', { nullable: true })
+    notes?: string;
+  
+    @OneToMany(() => ImageInfo, (image) => image.substrateInfo, {
+      cascade: true,
+      nullable: true,
+    })
+    images?: ImageInfo[];
+  
+    @ManyToOne(() => PlantTechnicalSheet, (sheet) => sheet.substrate, {
+      nullable: false,
+      onDelete: 'CASCADE',
+    })
+    @JoinColumn({ name: 'plantTechnicalSheetId' })
+    plantTechnicalSheet!: PlantTechnicalSheet;
+  
+    @Column({ type: 'boolean', default: true })
+    isActive!: boolean;
+  }
+  

package/src/models/technical-sheet/catalogs/climate-ideal.ts

@@ -0,0 +1,16 @@
+// src/models/technical-sheet/catalogs/climate-ideal.ts
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const CLIMATE = makeCatalog({
+  TROPICAL: '18–35 °C, sin heladas.',
+  SUBTROPICAL: '12–30 °C, invierno suave.',
+  TEMPLADO: '5–28 °C, estaciones marcadas.',
+  MEDITERRÁNEO: 'Invierno templado, verano seco.',
+  DESÉRTICO: '5–45 °C, muy seco.',
+  FRÍO_MONTANO: '–5–20 °C, heladas frecuentes.',
+  UNIVERSAL: 'Amplio rango 5–35 °C.',
+});
+
+export type ClimateType = keyof typeof CLIMATE;
+
+export type TemperatureRangeC = [min: number, max: number];

package/src/models/technical-sheet/catalogs/fertilization-info.ts

@@ -0,0 +1,41 @@
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const FERTILIZER_TYPE = makeCatalog({
+  ORGÁNICO: 'Humus, compost, estiércol.',
+  MINERAL: 'Sales NPK solubles.',
+  LIBERACIÓN_LENTA: 'Gránulos 3–6 meses.',
+  LÍQUIDO: 'Soluble para riego.',
+  FOLIAR: 'Aplicación foliar.',
+  ESPECÍFICO_PARA_FLORACIÓN: 'Alto P y K.',
+  ESPECÍFICO_PARA_HOJAS: 'Alto N.',
+  ENRAIZANTE: 'Auxinas para raíces.',
+  ABONO_COMPLETO: 'NPK balanceado + micro.',
+  NINGUNO: 'No se fertiliza regularmente.',
+});
+
+export type FertilizerType = keyof typeof FERTILIZER_TYPE;
+
+export const FERTILIZER_FREQ = makeCatalog({
+  SEMANAL: 'Cada semana.',
+  CADA_15_DÍAS: 'Cada 15 días.',
+  MENSUAL: 'Mensual.',
+  CADA_3_MESES: 'Trimestral.',
+  EN_PRIMAVERA_VERANO: 'Solo temporada activa.',
+  EN_PERÍODOS_ACTIVOS: 'Cuando la planta crece.',
+  OCASIONAL: 'Ante carencias.',
+  NINGUNA: 'Nunca.',
+});
+
+export type FertilizerFrequency = keyof typeof FERTILIZER_FREQ;
+
+export const FERTILIZER_METHOD = makeCatalog({
+  EN_EL_RIEGO: 'Disuelto en riego.',
+  DIRECTO_EN_SUSTRATO: 'Espolvoreado en sustrato.',
+  FOLIAR: 'Pulverizado en hojas.',
+  GRANULADO: 'Gránulos superficiales.',
+  EN_TABLETAS: 'Tabletas enterradas.',
+  HIDROPONÍA: 'En solución nutritiva.',
+  NO_APLICA: 'No corresponde.',
+});
+
+export type FertilizerMethod = keyof typeof FERTILIZER_METHOD;

package/src/models/technical-sheet/catalogs/growth-class.ts

@@ -0,0 +1,14 @@
+// src/models/technical-sheet/catalogs/growth-class.ts
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const GROWTH_CLASS = makeCatalog({
+  EFÍMERA_ANUAL: 'Ciclo <1 año.',
+  HEMIANUAL_ESTACIONAL: 'Activa 1–2 estaciones/año.',
+  PERENNE_CRECIMIENTO_CONTINUO: 'Activa todo el año.',
+  LEÑOSA_LENTA: '<20 cm/año.',
+  HERBÁCEA_MODERADA: '30–80 cm/año.',
+  TREPADORA_RÁPIDA: '>1.5 m/año.',
+  ESTOLONIFERA_EXPANSIVA: 'Expansión horizontal veloz.',
+});
+
+export type GrowthClass = keyof typeof GROWTH_CLASS;

package/src/models/technical-sheet/catalogs/growth-type.ts

@@ -0,0 +1,37 @@
+// src/models/technical-sheet/catalogs.ts
+
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const GROWTH_AREA = makeCatalog({
+  INTERIOR: 'Dentro de edificaciones; temperatura controlada.',
+  EXTERIOR_SOMBRA: '<2 h de sol directo.',
+  EXTERIOR_MEDIA_SOMBRA: '2–4 h de sol suave.',
+  EXTERIOR_SOL_DIRECTO: '>6 h de sol pleno.',
+  INVERNADERO: 'Estructura con temp. y HR controladas.',
+  ACUÁTICA: 'Raíces en agua o sustrato inundado.',
+  TERRARIO: 'Recinto cerrado, humedad muy alta.',
+});
+export type PlantGrowthArea = keyof typeof GROWTH_AREA;
+
+export const GROWTH_HABIT = makeCatalog({
+  ERGIDA: 'Porte vertical.',
+  TREPADORA: 'Escala tutores o cuelga.',
+  COLGANTE: 'Tallos péndulos.',
+  HELECHO: 'Frondas divididas.',
+  SUCULENTA: 'Tejidos carnosos con agua.',
+  CACTUS: 'Tallo suculento con espinas.',
+  BROMELIA: 'Epífita de copa.',
+  ORQUÍDEA_EPÍFITA: 'Raíces aéreas.',
+  ARBUSTO: 'Leñoso <5 m.',
+  COBERTORA: 'Cubre el suelo.',
+  ENREDADERA: 'Tallo que se enrosca.',
+  FLOR_PERENNE: 'Herbácea plurianual.',
+  ÁRBOL: 'Leñoso ≥5 m.',
+  PALMERA: 'Tronco no ramificado.',
+  PASTO_ORNAMENTAL: 'Gramínea decorativa.',
+  FLOTANTE: 'Flota sobre el agua.',
+  EMERGENTE: 'Sobresale del agua.',
+  MUSGO: 'Briofita sin raíces.',
+  MINI_HELECHO: 'Helecho pequeño.',
+});
+export type PlantGrowthHabit = keyof typeof GROWTH_HABIT;

package/src/models/technical-sheet/catalogs/humidity-info.ts

@@ -0,0 +1,12 @@
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const HUMIDITY = makeCatalog({
+  XERICO: 'Sequía extrema (<10 % HR).',
+  SECO: 'Riego escaso (sustrato seco).',
+  MESICO: 'Sustrato ligeramente húmedo.',
+  HUMEDO: 'HR 60–80 %; riego frecuente.',
+  HUMEDO_CONSTANTE: 'Sustrato siempre húmedo.',
+  ACUATICO: 'Raíces permanentemente sumergidas.',
+});
+
+export type HumidityRequirement = keyof typeof HUMIDITY;

package/src/models/technical-sheet/catalogs/light-info.ts

@@ -0,0 +1,13 @@
+// src/models/technical-sheet/catalogs/light-info.ts
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const LIGHT = makeCatalog({
+  SOMBRA_PROFUNDA: '<2 h luz directa (100–200 lux).',
+  SOMBRA_PARCIAL: '2–4 h luz filtrada (200–500 lux).',
+  LUZ_INDIRECTA_BRILLANTE: 'Junto a ventana (500–1500 lux).',
+  SOL_SUAVE: 'Sol suave 2–4 h.',
+  SOL_PARCIAL: 'Sol 4–6 h.',
+  SOL_PLENO: 'Sol >6 h; >30 klux.',
+});
+
+export type LightRequirement = keyof typeof LIGHT;

package/src/models/technical-sheet/catalogs/pest-info.ts

@@ -0,0 +1,36 @@
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const PLANT_PART = makeCatalog({
+  HOJAS: 'Hojas.',
+  TALLOS: 'Tallos.',
+  RAÍCES: 'Raíces.',
+  FLORES: 'Flores.',
+  FRUTOS: 'Frutos.',
+  TODA_LA_PLANTA: 'Daño sistémico.',
+});
+export type PlantPart = keyof typeof PLANT_PART;
+
+export const CONTROL_METHOD = makeCatalog({
+  JABÓN_POTÁSICO: 'Insecticida suave.',
+  ACEITE_DE_NEEM: 'Azadiractina sistémica.',
+  INSECTICIDA_SISTÉMICO: 'Absorción interna.',
+  INSECTICIDA_CONTACTO: 'Mata por contacto.',
+  FUNGICIDA_SISTÉMICO: 'Control interno hongos.',
+  FUNGICIDA_CONTACTO: 'Barrera superficial.',
+  TRAMPAS: 'Captura física.',
+  PODA_SANITARIA: 'Eliminación partes infectadas.',
+  CONTROL_BIOLÓGICO: 'Depredadores benéficos.',
+  OTRO: 'Otro método.',
+});
+export type ControlMethod = keyof typeof CONTROL_METHOD;
+
+export const PEST_TYPE = makeCatalog({
+  INSECTO: 'Insectos.',
+  HONGO: 'Hongos.',
+  ÁCARO: 'Aácaros.',
+  BACTERIA: 'Bacterias.',
+  VIRUS: 'Virus.',
+  NEMATODO: 'Nematodos.',
+  OTRO: 'Otro.',
+});
+export type PestType = keyof typeof PEST_TYPE;

package/src/models/technical-sheet/catalogs/plant-size.ts

@@ -0,0 +1,15 @@
+// src/models/technical-sheet/catalogs/plant-size.ts
+import { makeCatalog } from '../utils/makeCatalog';
+
+export const GROWTH_HABIT_GEOM = makeCatalog({
+  COMPACTA: 'Poco volumen.',
+  EXPANSIVA: 'Brotes laterales extensos.',
+  ERECTA: 'Vertical sin soporte.',
+  RASERA: 'Se extiende sobre el suelo.',
+  TREPADORA: 'Escala estructuras.',
+  COLGANTE: 'Tallos péndulos.',
+  ARBUSTIVA: 'Múltiples ramas leñosas.',
+  ARBOREA: 'Tronco leñoso único.',
+});
+
+export type GrowthHabit = keyof typeof GROWTH_HABIT_GEOM;