@open3cl/engine 1.0.5 → 1.0.7

package/11_nadeq.spec.js

@@ -1,4 +1,5 @@
 import { Nadeq } from './11_nadeq.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Nadeq unit tests', () => {
   /**
@@ -6,7 +7,7 @@ describe('Nadeq unit tests', () => {
    */
   const nadeq = new Nadeq();
 
-  it.each([
+  test.each([
     [1, 8],
     [1, 28],
     [1.28125, 45],
@@ -26,7 +27,7 @@ describe('Nadeq unit tests', () => {
     }
   );
 
-  it.each([
+  test.each([
     [1, 8, 1],
     [2, 8, 2],
     [1.3375, 28, 1],

package/16.2_production_enr.spec.js

@@ -1,4 +1,5 @@
 import { ProductionENR } from './16.2_production_enr.js';
+import { describe, expect, test, it } from 'vitest';
 
 describe('production ENR unit tests', () => {
   /**

package/3.2.1_mur.spec.js

@@ -1,4 +1,5 @@
 import calc_mur from './3.2.1_mur.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de déperdition des murs', () => {
   /**

package/3.2.2_plancher_bas.spec.js

@@ -1,4 +1,5 @@
 import calc_pb from './3.2.2_plancher_bas.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de déperdition des planchers bas', () => {
   describe('calcul de déperdition pour les planchers bas de 2287E1043883T', () => {

package/3.3_baie_vitree.spec.js

@@ -1,5 +1,6 @@
 import calc_bv from './3.3_baie_vitree.js';
 import { PRECISION } from '../test/constant.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de déperdition des baies vitrées', () => {
   test('calcul de déperdition pour les murs de 2187E0982013C baie 1', () => {

package/6.1_apport_gratuit.spec.js

@@ -1,4 +1,5 @@
 import { calc_ai, calc_as } from './6.1_apport_gratuit.js';
+import { describe, expect, test } from 'vitest';
 
 describe("Recherche de bugs dans le calcul de l'apport gratuit", () => {
   /**

package/7_inertie.spec.js

@@ -1,4 +1,5 @@
 import { Inertie } from './7_inertie.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Inertie unit tests', () => {
   /**
@@ -6,7 +7,7 @@ describe('Inertie unit tests', () => {
    */
   const inertie = new Inertie();
 
-  it.each([
+  test.each([
     [1, 1, 0, 9],
     [1, 1, 0, 11],
     [1, 1, 0, 12],
@@ -34,7 +35,7 @@ describe('Inertie unit tests', () => {
     }
   );
 
-  it.each([
+  test.each([
     [1, 2, 8],
     [1, 4, 8],
     [1, 9, 8],
@@ -53,7 +54,7 @@ describe('Inertie unit tests', () => {
     }
   );
 
-  it.each([
+  test.each([
     [1, 1, 0, 2, 0],
     [1, 1, 0, 3, 0],
     [1, 1, 0, 4, 0],

package/9_chauffage.spec.js

@@ -1,4 +1,5 @@
 import calc_chauffage from './9_chauffage.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de la consommation', () => {
   test('calcul de la consommation de chauffage pour 2475E2510509B', () => {

package/9_conso_ch.spec.js

@@ -1,4 +1,5 @@
 import { conso_ch } from './9_conso_ch.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de la consommation du chauffage', () => {
   test('calcul de la consommation du chauffage pour 2475E2510509B', () => {

package/9_generateur_ch.spec.js

@@ -1,4 +1,5 @@
 import { calc_generateur_ch } from './9_generateur_ch.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de la consommation des generateurs de chauffage', () => {
   test('calcul de la consommation des generateurs de chauffage pour 2475E2510509B', () => {

package/conso.spec.js

@@ -1,4 +1,5 @@
 import calc_conso from './conso.js';
+import { describe, expect, test } from 'vitest';
 
 describe('Recherche de bugs dans le calcul de la consommation', () => {
   test('calcul de la consommation de chauffage pour 2475E2510509B', () => {

package/core/assets/domain/synchronize-assets.spec.js

@@ -1,17 +1,17 @@
 import { SynchronizeAssets } from './synchronize-assets.js';
 import { SynchronizeEnumTables } from './synchronize-enum-tables.js';
 import { SynchronizeValeurTables } from './synchronize-valeur-tables.js';
-import { jest } from '@jest/globals';
+import { describe, expect, test, vi } from 'vitest';
 
 describe('SynchronizeAssets unit tests', () => {
-  it('should synchronize xlsx and ods files', () => {
+  test('should synchronize xlsx and ods files', () => {
     const synchronizeEnumTables = new SynchronizeEnumTables(null, null);
     const synchronizeValeurTables = new SynchronizeValeurTables(null, null, null);
     const synchronizeAssets = new SynchronizeAssets(synchronizeEnumTables, synchronizeValeurTables);
 
-    jest.spyOn(console, 'log').mockReturnValue(null);
-    jest.spyOn(synchronizeEnumTables, 'execute').mockResolvedValue({});
-    jest.spyOn(synchronizeValeurTables, 'execute').mockResolvedValue({});
+    vi.spyOn(console, 'log').mockReturnValue(null);
+    vi.spyOn(synchronizeEnumTables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeValeurTables, 'execute').mockResolvedValue({});
 
     return synchronizeAssets.execute().then(() => {
       expect(synchronizeEnumTables.execute).toHaveBeenCalled();
@@ -20,14 +20,14 @@ describe('SynchronizeAssets unit tests', () => {
     });
   });
 
-  it('should log errors if synchronization has failed', () => {
+  test('should log errors if synchronization has failed', () => {
     const synchronizeEnumTables = new SynchronizeEnumTables(null, null);
     const synchronizeValeurTables = new SynchronizeValeurTables(null, null, null);
     const synchronizeAssets = new SynchronizeAssets(synchronizeEnumTables, synchronizeValeurTables);
 
-    jest.spyOn(console, 'error').mockReturnValue(null);
-    jest.spyOn(synchronizeEnumTables, 'execute').mockResolvedValue({});
-    jest.spyOn(synchronizeValeurTables, 'execute').mockRejectedValue(null);
+    vi.spyOn(console, 'error').mockReturnValue(null);
+    vi.spyOn(synchronizeEnumTables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeValeurTables, 'execute').mockRejectedValue(null);
 
     return synchronizeAssets.execute().catch((error) => {
       expect(error).toBeDefined();

package/core/assets/domain/synchronize-c1-tables.spec.js

@@ -2,17 +2,17 @@ import { SynchronizeC1Tables } from './synchronize-c1-tables.js';
 import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
 import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
 import { C1TablesFixture } from '../../../../test/fixtures/core/assets/c1-tables.fixture.js';
-import { jest } from '@jest/globals';
+import { describe, expect, test, vi } from 'vitest';
 
 describe('SynchronizeC1Tables unit tests', () => {
-  it('should read and parse 18.5_c1.ods file', () => {
+  test('should read and parse 18.5_c1.ods file', () => {
     const fileStore = new FileStore();
     const appConfig = new ApplicationConfig();
     const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
 
     const c1Data = C1TablesFixture.aC1Example();
-    jest.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(c1Data);
-    jest.spyOn(ApplicationConfig.prototype, 'c1FilePath', 'get').mockReturnValue('src/file.ods');
+    vi.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(c1Data);
+    vi.spyOn(ApplicationConfig.prototype, 'c1FilePath', 'get').mockReturnValue('src/file.ods');
 
     return synchronizeC1Tables.execute().then((output) => {
       expect(fileStore.readLocalOdsFileAndConvertToJson).toHaveBeenCalled();

package/core/assets/domain/synchronize-dpe-ges-limit-values-tables.spec.js

@@ -2,10 +2,10 @@ import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
 import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
 import { DpeGesLimitValuesTablesFixture } from '../../../../test/fixtures/core/assets/dpe-ges-limit-values-tables.fixture.js';
 import { SynchronizeDpeGesLimitValuesTables } from './synchronize-dpe-ges-limit-values-tables.js';
-import { jest } from '@jest/globals';
+import { describe, expect, test, vi } from 'vitest';
 
 describe('SynchronizeDpeGesLimitValuesTables unit tests', () => {
-  it('should read and parse dpe_ges_limit_values file', () => {
+  test('should read and parse dpe_ges_limit_values file', () => {
     const fileStore = new FileStore();
     const appConfig = new ApplicationConfig();
     const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
@@ -14,10 +14,10 @@ describe('SynchronizeDpeGesLimitValuesTables unit tests', () => {
     );
 
     const dpeGesLimitData = DpeGesLimitValuesTablesFixture.aDpeGesLimitExample();
-    jest.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(dpeGesLimitData);
-    jest
-      .spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get')
-      .mockReturnValue('src/file.ods');
+    vi.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(dpeGesLimitData);
+    vi.spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get').mockReturnValue(
+      'src/file.ods'
+    );
 
     return synchronizeDpeGesLimitValuesTables.execute().then((output) => {
       expect(fileStore.readLocalOdsFileAndConvertToJson).toHaveBeenCalled();

package/core/assets/domain/synchronize-enum-tables.spec.js

@@ -2,23 +2,23 @@ import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
 import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
 import { EnumTablesFixture } from '../../../../test/fixtures/core/assets/enum-tables.fixture.js';
 import { SynchronizeEnumTables } from './synchronize-enum-tables.js';
-import { jest } from '@jest/globals';
+import { describe, expect, test, vi } from 'vitest';
 
 describe('SynchronizeEnumTables', () => {
-  it('should download, parse and convert enum_tables.xlsx file', () => {
+  test('should download, parse and convert enum_tables.xlsx file', () => {
     const fileStore = new FileStore();
     const appConfig = new ApplicationConfig();
     const synchronizeEnumTables = new SynchronizeEnumTables(fileStore, appConfig);
 
     const enumTablesData = EnumTablesFixture.anEnumTableExample();
-    jest
-      .spyOn(ApplicationConfig.prototype, 'ademeEnumTablesFileUrl', 'get')
-      .mockReturnValue('http://localhost/file.xlsx');
-    jest
-      .spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get')
-      .mockReturnValue('src/assets');
-    jest.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue(enumTablesData);
-    jest.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+    vi.spyOn(ApplicationConfig.prototype, 'ademeEnumTablesFileUrl', 'get').mockReturnValue(
+      'http://localhost/file.xlsx'
+    );
+    vi.spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get').mockReturnValue(
+      'src/assets'
+    );
+    vi.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue(enumTablesData);
+    vi.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
 
     return synchronizeEnumTables.execute().then(() => {
       expect(fileStore.downloadXlsxFileAndConvertToJson).toHaveBeenCalled();

package/core/assets/domain/synchronize-solicitations-tables.spec.js

@@ -2,19 +2,19 @@ import { FileStore } from '../../file/infrastructure/adapter/file.store.js';
 import { ApplicationConfig } from '../../conf/infrastructure/application.config.js';
 import { SynchronizeSolicitationsTables } from './synchronize-solicitations-tables.js';
 import { SolicitationsTablesFixture } from '../../../../test/fixtures/core/assets/solicitations-tables.fixture.js';
-import { jest } from '@jest/globals';
+import { describe, expect, test, vi } from 'vitest';
 
 describe('SynchronizeSolicitationsTables unit tests', () => {
-  it('should read and parse 18.2_sollicitations_ext.ods file', () => {
+  test('should read and parse 18.2_sollicitations_ext.ods file', () => {
     const fileStore = new FileStore();
     const appConfig = new ApplicationConfig();
     const synchronizeSolicitationsTables = new SynchronizeSolicitationsTables(fileStore, appConfig);
 
     const solicitationsData = SolicitationsTablesFixture.aSolicitationExample();
-    jest.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(solicitationsData);
-    jest
-      .spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get')
-      .mockReturnValue('src/file.ods');
+    vi.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue(solicitationsData);
+    vi.spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get').mockReturnValue(
+      'src/file.ods'
+    );
 
     return synchronizeSolicitationsTables.execute().then((output) => {
       expect(fileStore.readLocalOdsFileAndConvertToJson).toHaveBeenCalled();

package/core/assets/domain/synchronize-valeur-tables.spec.js

@@ -4,12 +4,12 @@ import { ApplicationConfig } from '../../conf/infrastructure/application.config.
 import { SynchronizeC1Tables } from './synchronize-c1-tables.js';
 import { SynchronizeSolicitationsTables } from './synchronize-solicitations-tables.js';
 import { ValeurTablesFixture } from '../../../../test/fixtures/core/assets/valeur-tables.fixture.js';
-import { jest } from '@jest/globals';
 import { SynchronizeDpeGesLimitValuesTables } from './synchronize-dpe-ges-limit-values-tables.js';
 import { AddAdditionnalUeValuesTables } from './add-additionnal-ue-values-tables.js';
+import { describe, expect, test, vi } from 'vitest';
 
 describe('SynchronizeValeurTables unit tests', () => {
-  it('should download, parse and convert valeur_tables.xlsx file', () => {
+  test('should download, parse and convert valeur_tables.xlsx file', () => {
     const fileStore = new FileStore();
     const appConfig = new ApplicationConfig();
     const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
@@ -29,19 +29,19 @@ describe('SynchronizeValeurTables unit tests', () => {
     );
 
     const valeurTablesData = ValeurTablesFixture.aValeurTableExample();
-    jest
-      .spyOn(ApplicationConfig.prototype, 'ademeValeurTablesFileUrl', 'get')
-      .mockReturnValue('http://localhost/file.xlsx');
-    jest
-      .spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get')
-      .mockReturnValue('src/assets');
+    vi.spyOn(ApplicationConfig.prototype, 'ademeValeurTablesFileUrl', 'get').mockReturnValue(
+      'http://localhost/file.xlsx'
+    );
+    vi.spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get').mockReturnValue(
+      'src/assets'
+    );
 
-    jest.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue(valeurTablesData);
-    jest.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
-    jest.spyOn(synchronizeC1Tables, 'execute').mockResolvedValue({});
-    jest.spyOn(synchronizeSolicitationTables, 'execute').mockResolvedValue({});
-    jest.spyOn(synchronizeDpeGesLimitValuesTables, 'execute').mockResolvedValue({});
-    jest.spyOn(addAdditionnalUeValuesTables, 'execute').mockResolvedValue({});
+    vi.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue(valeurTablesData);
+    vi.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+    vi.spyOn(synchronizeC1Tables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeSolicitationTables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeDpeGesLimitValuesTables, 'execute').mockResolvedValue({});
+    vi.spyOn(addAdditionnalUeValuesTables, 'execute').mockResolvedValue({});
 
     return synchronizeValeurTables.execute().then(() => {
       expect(fileStore.downloadXlsxFileAndConvertToJson).toHaveBeenCalled();

package/core/file/infrastructure/adapter/file.store.spec.js

@@ -1,13 +1,14 @@
 import { FileStore } from './file.store.js';
+import { describe, expect, test, vi } from 'vitest';
 
-global.fetch = jest.fn(() =>
+global.fetch = vi.fn(() =>
   Promise.resolve({
     arrayBuffer: () => Promise.resolve(new ArrayBuffer(1))
   })
 );
 
 describe('FileStore unit tests', () => {
-  it('should be able to download and parse an xlsx file', () => {
+  test('should be able to download and parse an xlsx file', () => {
     const fileStore = new FileStore();
 
     return fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080').then((output) => {
@@ -15,7 +16,7 @@ describe('FileStore unit tests', () => {
     });
   });
 
-  it('should be able to read and parse local ods file', () => {
+  test('should be able to read and parse local ods file', () => {
     const fileStore = new FileStore();
 
     return fileStore.readLocalOdsFileAndConvertToJson('file.ods').then((output) => {
@@ -23,7 +24,7 @@ describe('FileStore unit tests', () => {
     });
   });
 
-  it('should write file to local system', () => {
+  test('should write file to local system', () => {
     const fileStore = new FileStore();
     return fileStore.writeFileToLocalSystem('src/output.js', 'filecontent');
   });

package/core/tv/infrastructure/tvs.store.spec.js

@@ -1,7 +1,8 @@
 import { TvsStore } from './tvs.store.js';
+import { describe, expect, test } from 'vitest';
 
 describe('TvsStore unit tests', () => {
-  it('should get rendement distribution ch id', () => {
+  test('should get rendement distribution ch id', () => {
     const store = new TvsStore();
 
     expect(store.getRendementDistributionCh('41', '0')).toMatchObject({
@@ -24,7 +25,7 @@ describe('TvsStore unit tests', () => {
     });
   });
 
-  it('should get rendement distribution ch by id', () => {
+  test('should get rendement distribution ch by id', () => {
     const store = new TvsStore();
 
     expect(store.getRendementDistributionChById('10')).toMatchObject({

package/core/util/infrastructure/object-util.spec.js

@@ -1,7 +1,8 @@
 import { ObjectUtil } from './object-util.js';
+import { describe, expect, test } from 'vitest';
 
 describe('ObjectUtil unit tests', () => {
-  it('should be able to deeply transform an object keys and values', () => {
+  test('should be able to deeply transform an object keys and values', () => {
     expect(
       ObjectUtil.deepObjectTransform(
         { key1: 'Value1', key2: 'Value2', nested: [{ key3: 'Value3' }] },

package/core/util/logger/log-service.js

@@ -0,0 +1,47 @@
+import { createLogger, format, transports } from 'winston';
+
+const { combine, timestamp, prettyPrint, colorize, errors, printf } = format;
+
+// Disable traditional console logs
+const copyLog = console.log;
+const copyWarn = console.warn;
+const copyDebug = console.debug;
+const copyError = console.error;
+
+export const logger = createLogger({
+  level: 'info',
+  format: combine(
+    errors({ stack: true }),
+    colorize(),
+    timestamp(),
+    prettyPrint(),
+    printf(({ level, message, timestamp, stack }) => {
+      if (stack) {
+        // print log trace
+        return `${timestamp} ${level}: ${message} - ${stack}`;
+      }
+      return `${timestamp} ${level}: ${message}`;
+    })
+  ),
+  transports: [new transports.Console()]
+});
+
+export const setLoggerOff = (ignoreErrors = false) => {
+  logger.silent = true;
+  console.log = () => {};
+  console.warn = () => {};
+  console.debug = () => {};
+  if (ignoreErrors) {
+    console.error = () => {};
+  }
+};
+
+export const setLoggerOn = (errorsIgnored = false) => {
+  logger.silent = false;
+  console.log = copyLog;
+  console.warn = copyWarn;
+  console.debug = copyDebug;
+  if (errorsIgnored) {
+    console.error = copyError;
+  }
+};

package/features/dpe/domain/models/baie-ets.model.ts

@@ -0,0 +1,12 @@
+import { DE } from './dpe.model';
+
+export interface BaieEts {
+  donnee_entree?: BaieEtsDE;
+}
+
+export interface BaieEtsDE extends DE {
+  enum_orientation_id?: number;
+  enum_inclinaison_vitrage_id?: number; // ENUM inclinaison_vitrage
+  surface_totale_baie?: number;
+  nb_baie?: number;
+}

package/features/dpe/domain/models/baie-vitree.model.ts

@@ -0,0 +1,95 @@
+import { DE } from './dpe.model';
+
+export interface BaieVitree {
+  donnee_entree?: BaieVitreeDE;
+  donnee_intermediaire?: BaieVitreeDI;
+  baie_vitree_double_fenetre?: BaieVitreeDoubleFenetre;
+}
+
+export interface BaieVitreeDE extends DE {
+  reference_paroi?: string;
+  reference_lnc?: string;
+  tv_coef_reduction_deperdition_id?: string; // TV
+  surface_aiu?: number;
+  surface_aue?: number;
+  enum_cfg_isolation_lnc_id?: string; // ENUM cfg_isolation_lnc
+  enum_type_adjacence_id?: string; // ENUM type_adjacence
+  surface_totale_baie?: number;
+  nb_baie?: number;
+  tv_ug_id?: string; // TV
+  enum_type_vitrage_id?: string; // ENUM type_vitrage
+  enum_inclinaison_vitrage_id?: string; // ENUM inclinaison_vitrage
+  enum_type_gaz_lame_id?: string; // ENUM type_gaz_lame
+  epaisseur_lame?: number;
+  vitrage_vir?: boolean;
+  enum_methode_saisie_perf_vitrage_id?: string; // ENUM methode_saisie_perf_vitrage
+  ug_saisi?: number;
+  tv_uw_id?: string;
+  enum_type_materiaux_menuiserie_id?: string; // ENUM type_materiaux_menuiserie
+  enum_type_baie_id?: string; // ENUM type_baie
+  uw_saisi?: number;
+  double_fenetre?: boolean;
+  uw_1?: number;
+  sw_1?: number;
+  uw_2?: number;
+  sw_2?: number;
+  tv_deltar_id?: string;
+  tv_ujn_id?: string;
+  enum_type_fermeture_id?: string;
+  presence_protection_solaire_hors_fermeture?: boolean;
+  ujn_saisi?: number;
+  presence_retour_isolation?: boolean;
+  presence_joint?: boolean;
+  largeur_dormant?: number;
+  tv_sw_id?: string;
+  sw_saisi?: number;
+  enum_type_pose_id?: string; // ENUM type_pose
+  enum_orientation_id?: string;
+  tv_coef_masque_proche_id?: string;
+  tv_coef_masque_lointain_homogene_id?: string;
+  masque_lointain_non_homogene_collection: {
+    masque_lointain_non_homogene: {
+      tv_coef_masque_lointain_non_homogene_id?: string; // TV
+    };
+  }[];
+}
+
+export interface BaieVitreeDI {
+  b: number;
+  ug?: number;
+  uw: number;
+  ujn?: number;
+  u_menuiserie: number;
+  sw: number;
+  fe1: number;
+  fe2: number;
+}
+
+export interface BaieVitreeDoubleFenetre {
+  donnee_entree?: BaieVitreeDoubleFenetreDE;
+  donnee_intermediaire?: BaieVitreeDoubleFenetreDI;
+}
+
+export interface BaieVitreeDoubleFenetreDE {
+  tv_ug_id?: string;
+  enum_type_vitrage_id: string;
+  enum_inclinaison_vitrage_id: string;
+  enum_type_gaz_lame_id?: string;
+  epaisseur_lame?: number;
+  vitrage_vir?: boolean;
+  enum_methode_saisie_perf_vitrage_id: string;
+  ug_saisi?: number;
+  tv_uw_id?: string;
+  enum_type_materiaux_menuiserie_id: string;
+  enum_type_baie_id: string;
+  uw_saisi?: number;
+  tv_sw_id?: string;
+  sw_saisi?: number;
+  enum_type_pose_id: string;
+}
+
+export interface BaieVitreeDoubleFenetreDI {
+  ug?: number;
+  uw: number;
+  sw: number;
+}

package/features/dpe/domain/models/climatisation.model.ts

@@ -0,0 +1,25 @@
+import { DE } from './dpe.model';
+
+export interface Climatisation {
+  donnee_entree?: ClimatisationDE;
+  donnee_intermediaire?: ClimatisationDI;
+}
+
+export interface ClimatisationDE extends DE {
+  tv_seer_id?: number;
+  nombre_logement_echantillon?: number;
+  enum_methode_calcul_conso_id: number;
+  enum_periode_installation_fr_id: number;
+  cle_repartition_clim?: number;
+  enum_type_generateur_fr_id: number;
+  enum_type_energie_id?: number;
+  enum_methode_saisie_carac_sys_id: number;
+  ref_produit_fr?: string;
+}
+
+export interface ClimatisationDI {
+  eer: number;
+  besoin_fr: number;
+  conso_fr: number;
+  conso_fr_depensier: number;
+}