@postxl/generator 0.70.3 → 0.71.1

package/dist/generators/indices/{import-export/importexport-import-service.generator.js → import/service.generator.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportExportImportService = void 0;
+exports.generateImportService = void 0;
 const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 const types_1 = require("../../../lib/schema/types");
 const string_1 = require("../../../lib/utils/string");
 /**
- * Generates the Exporter class for the Import-Export module
+ * Generates the Import Service class for the Import module
  */
-function generateImportExportImportService({ models, meta }) {
-    const imports = imports_1.ImportsGenerator.from(meta.importExport.importService.location.path);
-    const { types, decoder, converterFunctions } = meta.importExport;
+function generateImportService({ models, meta }) {
+    const imports = imports_1.ImportsGenerator.from(meta.import.importService.location.path);
+    const { types, decoder, converterFunctions } = meta.import;
     const { delta_Fields, delta, delta_Model } = types;
     const { create, errors, unchanged, update } = delta_Model;
     const { nonUnique, invalidReference, invalidType, isRequiredDependency, missingField } = errors;
@@ -60,15 +60,15 @@ type Delta_Result<Model extends ${dto.genericModel}<ID>, ID extends ${dto.idType
   | { type: '${unchanged.discriminant}' }
 
 @Injectable()
-export class ${meta.importExport.importService.name} {
+export class ${meta.import.importService.name} {
   constructor(
     private readonly data: ${meta.data.dataService.class},
     private readonly dispatcher: ${meta.actions.dispatcher.class},
   ) {
-    // We have a circular dependency between DispatcherService and ${meta.importExport.importService.name}. 
+    // We have a circular dependency between DispatcherService and ${meta.import.importService.name}. 
     // In order to avoid trouble, instead of using Nest's forwardRef(), we inject the dispatcher service here
-    // and set the dispatcher's ${meta.importExport.importService.sharedName} to this instance.
-    this.dispatcher.${meta.importExport.importService.sharedName} =this
+    // and set the dispatcher's ${meta.import.importService.sharedName} to this instance.
+    this.dispatcher.${meta.import.importService.sharedName} =this
   }
 
   
@@ -122,7 +122,7 @@ export class ${meta.importExport.importService.name} {
     data, 
     execution 
   }: { 
-    data: ${meta.importExport.decoder.decodedPXLModelDataTypeName}; 
+    data: ${meta.import.decoder.decodedPXLModelDataTypeName}; 
     execution: ${meta.actions.execution.interface}
   }) {
     const { bulkMutations } = await this.detectDelta(data)
@@ -445,15 +445,15 @@ function deltaToUpdateDtoFunction<Model extends ${dto.genericModel}<ID>, ID exte
   return updateDTO
 }`;
 }
-exports.generateImportExportImportService = generateImportExportImportService;
+exports.generateImportService = generateImportService;
 function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imports, }) {
-    const { types } = schemaMeta.importExport;
+    const { types } = schemaMeta.import;
     const { delta_Model } = types;
     imports.addTypeImport({
         from: types.location.path,
-        items: [modelMeta.importExport.delta_Model_Errors],
+        items: [modelMeta.import.delta_Model_Errors],
     });
-    const returnType = `${delta_Model.type}<${model.typeName}, ${modelMeta.types.brandedIdType}, ${modelMeta.importExport.delta_Model_Errors}>[]`;
+    const returnType = `${delta_Model.type}<${model.typeName}, ${modelMeta.types.brandedIdType}, ${modelMeta.import.delta_Model_Errors}>[]`;
     const sharedValidations = [];
     const requiredFields = [];
     const fieldNames = [];
@@ -472,7 +472,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
         if (field.kind === 'scalar') {
             if (field.isUnique) {
                 imports.addTypeImport({
-                    from: schemaMeta.importExport.types.location.path,
+                    from: schemaMeta.import.types.location.path,
                     items: [delta_Model.errors.nonUnique.type],
                 });
                 const getByName = `getBy${(0, string_1.toPascalCase)(fieldName)}`;
@@ -484,7 +484,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
             }
             if (field.validation && field.validation.type === 'int') {
                 imports.addTypeImport({
-                    from: schemaMeta.importExport.types.location.path,
+                    from: schemaMeta.import.types.location.path,
                     items: [delta_Model.errors.invalidType.type],
                 });
                 sharedValidations.push(`this.validateInt({item, fieldName: '${fieldName}'})`);
@@ -493,7 +493,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
         else if (field.kind === 'relation') {
             const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: field.relationToModel });
             imports.addTypeImport({
-                from: schemaMeta.importExport.types.location.path,
+                from: schemaMeta.import.types.location.path,
                 items: [delta_Model.errors.invalidReference.type],
             });
             sharedValidations.push(`this.validateReferenceField({
@@ -516,7 +516,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
                 continue;
             }
             imports.addTypeImport({
-                from: schemaMeta.importExport.types.location.path,
+                from: schemaMeta.import.types.location.path,
                 items: [delta_Model.errors.isRequiredDependency.type],
             });
             const relatedModelMeta = (0, meta_1.getModelMetadata)({ model: relatedModel });
@@ -534,7 +534,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
     }
     if (requiredFields.length > 0) {
         imports.addTypeImport({
-            from: schemaMeta.importExport.types.location.path,
+            from: schemaMeta.import.types.location.path,
             items: [delta_Model.errors.missingField.type],
         });
     }
@@ -554,7 +554,7 @@ function generateDetectDeltaFunction({ model, modelMeta, models, schemaMeta, imp
 private async detect${modelMeta.internalSingularNameCapitalized}Delta(
   items?: ${model.typeName}[]
 ): Promise<${returnType}> {
-  const sharedValidations: (item: ${model.name}) => Promise<(${modelMeta.importExport.delta_Model_Errors} | undefined)[]> = 
+  const sharedValidations: (item: ${model.name}) => Promise<(${modelMeta.import.delta_Model_Errors} | undefined)[]> = 
     ${sharedValidationsFunction}
 
     return this.detectModelDelta({

package/dist/generators/indices/{import-export/importexport-types.generator.d.ts → import/types.generator.d.ts}

@@ -1,9 +1,9 @@
 import { SchemaMetaData } from '../../../lib/meta';
 import { Model } from '../../../lib/schema/schema';
 /**
- * Generates types for import export module.
+ * Generates types for import module.
  */
-export declare function generateImportExportTypes({ models, meta }: {
+export declare function generateImportTypes({ models, meta }: {
     models: Model[];
     meta: SchemaMetaData;
 }): string;

package/dist/generators/indices/{import-export/importexport-types.generator.js → import/types.generator.js}

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportExportTypes = void 0;
+exports.generateImportTypes = void 0;
 const imports_1 = require("../../../lib/imports");
 const meta_1 = require("../../../lib/meta");
 /**
- * Generates types for import export module.
+ * Generates types for import module.
  */
-function generateImportExportTypes({ models, meta }) {
-    const { types } = meta.importExport;
+function generateImportTypes({ models, meta }) {
+    const { types } = meta.import;
     const imports = imports_1.ImportsGenerator.from(types.location.path);
     const dto = meta.types.dto;
     imports
@@ -93,11 +93,11 @@ function generateImportExportTypes({ models, meta }) {
         if (modelErrorTypes.length === 0) {
             modelErrorTypes.push(`never`);
         }
-        errorTypes.push(`export type ${modelMeta.importExport.delta_Model_Errors} = ${modelErrorTypes.join('\n| ')}`);
+        errorTypes.push(`export type ${modelMeta.import.delta_Model_Errors} = ${modelErrorTypes.join('\n| ')}`);
         deltaTypes.push(`${modelMeta.seed.constantName}?: ${types.delta_Model.type}<
         ${modelMeta.types.typeName}, 
         ${modelMeta.types.brandedIdType},
-        ${modelMeta.importExport.delta_Model_Errors}
+        ${modelMeta.import.delta_Model_Errors}
       >[]`);
     }
     return /* ts */ `
@@ -239,4 +239,4 @@ export type DataChanges = {
   bulkMutations: ${meta.data.types.bulkMutation}[]
 }`;
 }
-exports.generateImportExportTypes = generateImportExportTypes;
+exports.generateImportTypes = generateImportTypes;

package/dist/generators/indices/seed-migration.generator.js

@@ -14,9 +14,7 @@ function generateSeedMigration({ models, meta }) {
         const modelMeta = (0, meta_1.getModelMetadata)({ model });
         imports.addImports({
             [modelMeta.seed.location.path]: [modelMeta.seed.constantName],
-            [meta.importExport.converterFunctions.location.import]: [
-                meta.importExport.converterFunctions.importedDataToBulkMutations,
-            ],
+            [meta.import.converterFunctions.location.import]: [meta.import.converterFunctions.importedDataToBulkMutations],
             [meta.seed.actionsLocation.import]: [(0, types_1.toTypeName)('Action_Seed_Data')],
         });
         modelTypes.push(`${modelMeta.seed.constantName}`);
@@ -29,7 +27,7 @@ export const MIGRATION_001_BASEDATA: Action_Seed_Data = {
   type: 'data',
   name: 'Base data',
   order: 1,
-  payload: ${meta.importExport.converterFunctions.importedDataToBulkMutations}({
+  payload: ${meta.import.converterFunctions.importedDataToBulkMutations}({
     ${modelTypes.join(',\n')}
   }),
 }

package/dist/generators/indices/seed-template.generator.js

@@ -62,7 +62,7 @@ function initializeWorkbook() {
 function addModel({ model, meta, wb }) {
     const ws = wb.addWorksheet(model.name);
     const table = ws.addTable({
-        name: meta.importExport.tableName,
+        name: meta.import.tableName,
         ref: 'A1',
         headerRow: true,
         totalsRow: false,

package/dist/generators/models/export/encoder.generator.d.ts

@@ -0,0 +1,9 @@
+import { ModelMetaData } from '../../../lib/meta';
+import { Model } from '../../../lib/schema/schema';
+/**
+ * Creates an encoder for the Seed Excel template.
+ */
+export declare function generateModelExportEncoder({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

package/dist/generators/models/export/encoder.generator.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelExportEncoder = void 0;
+const imports_1 = require("../../../lib/imports");
+const types_1 = require("../../../lib/schema/types");
+/**
+ * Creates an encoder for the Seed Excel template.
+ */
+function generateModelExportEncoder({ model, meta }) {
+    const { location, itemEncoderFunctionName, encodedExcelType, arrayEncoderFunctionName } = meta.export.encoder;
+    const imports = imports_1.ImportsGenerator.from(location.path).addImports({
+        [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
+        [meta.import.decoder.location.import]: [meta.import.decoder.rowDecoderName],
+    });
+    const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural } = meta;
+    /* prettier-ignore */
+    return `
+    import * as z from 'zod'
+
+    import { capitalizeKeys } from '@postxl/runtime'
+
+    ${imports.generate()}
+
+
+    /**
+     * The type for rows in the ${userFriendly} table
+     */
+    export type ${encodedExcelType} = z.infer<typeof ${meta.import.decoder.rowDecoderName}>
+
+
+    /**
+     * Converts a ${userFriendly} to an Excel row
+     */
+    export const ${itemEncoderFunctionName} = (item: ${model.typeName}): ${encodedExcelType} => capitalizeKeys(item)
+
+    /**
+     * Converts a list of ${userFriendlyPlural} to an Excel table
+     */
+    export const ${arrayEncoderFunctionName} = (items: ${model.typeName}[]): ${encodedExcelType}[] => items.map(${itemEncoderFunctionName})
+  `;
+}
+exports.generateModelExportEncoder = generateModelExportEncoder;

package/dist/generators/models/import/decoder.generator.d.ts

@@ -0,0 +1,9 @@
+import { ModelMetaData } from '../../../lib/meta';
+import { Model } from '../../../lib/schema/schema';
+/**
+ * Creates a decoder for the Seed Excel template.
+ */
+export declare function generateModelImportDecoder({ model, meta }: {
+    model: Model;
+    meta: ModelMetaData;
+}): string;

package/dist/generators/models/{importexport-decoder.generator.js → import/decoder.generator.js}

@@ -1,78 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateImportExportDecoder = exports.generateModelImportExportDecoder = void 0;
-const imports_1 = require("../../lib/imports");
-const meta_1 = require("../../lib/meta");
-const types_1 = require("../../lib/schema/types");
-const types_2 = require("../../lib/types");
+exports.generateModelImportDecoder = void 0;
+const imports_1 = require("../../../lib/imports");
+const meta_1 = require("../../../lib/meta");
+const types_1 = require("../../../lib/schema/types");
+const types_2 = require("../../../lib/types");
 const zodPackageName = (0, types_1.toPackageName)('@postxl/zod');
 /**
  * Creates a decoder for the Seed Excel template.
  */
-function generateModelImportExportDecoder({ model, meta }) {
-    const { filePath: decoderFilePath, itemEncoderFunctionName: rowExportFunctionName, encodedExcelType: excelType, arrayEncoderFunctionName: tableExportFunctionName, tableDecoder: tableImportDecoder, } = meta.importExport.decoder;
-    const imports = imports_1.ImportsGenerator.from(decoderFilePath).addImports({
+function generateModelImportDecoder({ model, meta }) {
+    const { tableDecoder: tableImportDecoder } = meta.import.decoder;
+    const imports = imports_1.ImportsGenerator.from(meta.import.decoder.location.path).addImports({
         [zodPackageName]: [(0, types_1.toFunctionName)('excelNullOrBlankDecoder')],
         [meta.types.importPath]: [(0, types_1.toAnnotatedTypeName)(meta.types.typeName)],
     });
-    const { userFriendlyName: userFriendly, userFriendlyNamePlural: userFriendlyPlural, internalSingularName: singular, internalSingularNameCapitalized: singularCapitalized, } = meta;
+    const { userFriendlyName: userFriendly, internalSingularNameCapitalized: singularCapitalized } = meta;
     const { fieldDecoders, blankFieldDecoders } = generateFieldDecoders({ model, meta, imports });
     return `
 import * as z from 'zod'
 
-import { uncapitalizeKeys, capitalizeKeys } from '@postxl/runtime'
+import { uncapitalizeKeys } from '@postxl/runtime'
 
 ${imports.generate()}
 
 /**
 * The decoder for an Excel row containing a ${userFriendly} entry
 */
-const ${singular}ExcelRowImportDecoderInput = z.object({
+export const ${meta.import.decoder.rowDecoderName} = z.object({
   ${fieldDecoders.join(',\n')}
 })
 
-
-/**
- * The type for rows in the ${userFriendly} table
- */
-export type ${excelType} = z.infer<typeof ${singular}ExcelRowImportDecoderInput>
-
-const ${singular}ExcelRowImportDecoder = ${singular}ExcelRowImportDecoderInput.transform(uncapitalizeKeys)
-
 /**
  * The decoder to identify blank rows in the ${userFriendly} table
  * 
  * Excel tables often contain blank rows - esp. when the table has 0 entries, the table in Excel contains a single row with empty values.
  * This decoder identifies these rows and converts them to undefined.
  * In the table decoder, we use a union of the blank row decoder and the actual row decoder to not throw on blank rows - but instead  filter them out.
- */
-const blank${singularCapitalized}ExcelRowImportDecoderInput = z
-  .object({
-    ${blankFieldDecoders.join(',\n')}
-  })
-  .transform(() => undefined)
+*/
+const blank${singularCapitalized}RowDecoder = z
+.object({
+  ${blankFieldDecoders.join(',\n')}
+})
+.transform(() => undefined)
 
 /**
  * The decoder for an Excel table that contains ${userFriendly} entries
  * 
  * We use a union of the blank row decoder and the actual row decoder to not throw on blank rows - but instead  filter them out.
- */
+*/
 export const ${tableImportDecoder} = z
-  .array(blank${singularCapitalized}ExcelRowImportDecoderInput.or(${singular}ExcelRowImportDecoder))
-  .transform((items) => items.filter(Boolean) as ${model.typeName}[])
-
-/**
- * Converts a ${userFriendly} to an Excel row
- */
-export const ${rowExportFunctionName} = (item: ${model.typeName}): ${excelType} => capitalizeKeys(item)
-
-/**
- * Converts a list of ${userFriendlyPlural} to an Excel table
- */
-export const ${tableExportFunctionName} = (items: ${model.typeName}[]): ${excelType}[] => items.map(${rowExportFunctionName})
-  `;
+  .array(
+    blank${singularCapitalized}RowDecoder
+    .or(${meta.import.decoder.rowDecoderName}.transform(uncapitalizeKeys))
+  )
+  .transform((items) => items.filter(Boolean) as ${model.typeName}[])`;
 }
-exports.generateModelImportExportDecoder = generateModelImportExportDecoder;
+exports.generateModelImportDecoder = generateModelImportDecoder;
 function generateFieldDecoders({ model, meta, imports, }) {
     const fieldDecoders = [];
     const blankFieldDecoders = [];
@@ -152,60 +136,3 @@ function toExcelDecoder({ tsTypeName, nullable, imports, }) {
             throw new Error('Unknown type');
     }
 }
-/**
- * Generates the data decoder, aggregating all the models.
- */
-function generateImportExportDecoder({ models, meta }) {
-    const { decodedPXLModelDataTypeName, encodedExcelDataTypeName, fullDecoderName, fullEncoderFunctionName } = meta.importExport.decoder;
-    const imports = imports_1.ImportsGenerator.from(meta.importExport.decoder.location.path);
-    const importTypes = [];
-    const decoderEntries = [];
-    const exportFields = [];
-    for (const model of models) {
-        const modelMeta = (0, meta_1.getModelMetadata)({ model });
-        imports.addImport({
-            from: modelMeta.importExport.decoder.filePath,
-            items: [
-                modelMeta.importExport.decoder.tableDecoder,
-                modelMeta.importExport.decoder.arrayEncoderFunctionName,
-                (0, types_1.toAnnotatedTypeName)(modelMeta.importExport.decoder.encodedExcelType),
-            ],
-        });
-        importTypes.push(`${modelMeta.importExport.tableName}?: ${modelMeta.importExport.decoder.encodedExcelType}[]`);
-        decoderEntries.push(`${modelMeta.importExport.tableName}: ${modelMeta.importExport.decoder.tableDecoder}.optional()`);
-        exportFields.push(`${modelMeta.importExport.tableName}: 
-      data.${modelMeta.importExport.exportDataFullPropertyName} !== undefined ?
-        ${modelMeta.importExport.decoder.arrayEncoderFunctionName}(data.${modelMeta.importExport.exportDataFullPropertyName}) 
-        : undefined`);
-    }
-    return `
-import * as z from 'zod'
-
-import { uncapitalizeKeys } from '@postxl/runtime'
-
-${imports.generate()}
-
-export type ${encodedExcelDataTypeName} = {
-  ${importTypes.join(',\n')}
-}
-
-/**
- * Decoder that converts Excel data to model data
- */
-export const ${fullDecoderName} = z
-  .object({
-    ${decoderEntries.join(',\n')}
-  })
-  .transform(uncapitalizeKeys)
-
-export type ${decodedPXLModelDataTypeName} = z.infer<typeof excelDataDecoder>
-
-/**
- * Converts the model data to Excel format
- */
-export const ${fullEncoderFunctionName} = (data: ${decodedPXLModelDataTypeName}): ${encodedExcelDataTypeName} => ({
-  ${exportFields.join(',\n')}
-})
-`;
-}
-exports.generateImportExportDecoder = generateImportExportDecoder;

package/dist/lib/meta.d.ts

@@ -219,11 +219,11 @@ export type SchemaMetaData = {
         stubIndexFilePath: Types.FilePath;
     };
     /**
-     * Meta data for import/export operations.
+     * Meta data for import operations.
      */
-    importExport: {
+    import: {
         /**
-         * Path that may be used to import from the import-export module.
+         * Path that may be used to import from the import module.
          */
         moduleLocation: Types.ModuleLocation;
         /**
@@ -238,42 +238,11 @@ export type SchemaMetaData = {
              * Name of the data decoder function
              */
             fullDecoderName: Types.FunctionName;
-            /**
-             * Name of the data encoder function
-             */
-            fullEncoderFunctionName: Types.FunctionName;
-            /**
-             * Name of the type that represents the data in encoded Excel format
-             */
-            encodedExcelDataTypeName: Types.TypeName;
             /**
              * Name of the type that represents the data in the PXL model format
              */
             decodedPXLModelDataTypeName: Types.TypeName;
         };
-        /**
-         * Meta data for the exporter class.
-         */
-        exporterClass: {
-            /**
-             * Path to the file containing the exporter class.
-             */
-            location: Types.ModuleLocation;
-            /**
-             * The name of the exporter class.
-             */
-            name: Types.ClassName;
-        };
-        exportService: {
-            /**
-             * Path to the file containing the export service class.
-             */
-            location: Types.ModuleLocation;
-            /**
-             * The name of the export service class.
-             */
-            name: Types.ClassName;
-        };
         importService: {
             /**
              * Path to the file containing the import service class.
@@ -469,6 +438,55 @@ export type SchemaMetaData = {
             delta_Fields: Types.TypeName;
         };
     };
+    /**
+     * Meta data for export operations.
+     */
+    export: {
+        /**
+         * Path that may be used to import from the export module.
+         */
+        moduleLocation: Types.ModuleLocation;
+        /**
+         * Meta data for the exporter class.
+         */
+        exporterClass: {
+            /**
+             * Path to the file containing the exporter class.
+             */
+            location: Types.ModuleLocation;
+            /**
+             * The name of the exporter class.
+             */
+            name: Types.ClassName;
+        };
+        exportService: {
+            /**
+             * Path to the file containing the export service class.
+             */
+            location: Types.ModuleLocation;
+            /**
+             * The name of the export service class.
+             */
+            name: Types.ClassName;
+        };
+        /**
+         * Meta data for decoder functions.
+         */
+        encoder: {
+            /**
+             * Path to the file containing the data encoder
+             */
+            location: Types.ModuleLocation;
+            /**
+             * Name of the data encoder function
+             */
+            fullEncoderFunctionName: Types.FunctionName;
+            /**
+             * Name of the type that represents the data in encoded Excel format
+             */
+            encodedExcelDataTypeName: Types.TypeName;
+        };
+    };
     view: {
         /**
          * The name of the module class
@@ -730,9 +748,43 @@ export type ModelMetaData = {
         };
     };
     /**
-     *  Properties provided by the `importExport` generators
+     *  Properties provided by the `import` generators
+     */
+    import: {
+        /**
+         * The name of the export Excel table (e.g. `Aggregations`).
+         */
+        tableName: string;
+        /**
+         * Name of the model specific error type
+         */
+        delta_Model_Errors: Types.TypeName;
+        /**
+         * Meta data of the model's Excel decoders
+         */
+        decoder: {
+            /**
+             * Location of the file containing the model's Excel decoders.
+             */
+            location: Types.ModuleLocation;
+            /**
+             * Name of the decoder function that represents the Excel table import type (e.g. `aggregationExcelTableDecoder`.)
+             */
+            tableDecoder: Types.FunctionName;
+            /**
+             * Name of the array in the decoded data containing all entities of this model (e.g. `aggregations`.)
+             */
+            decodedModelArrayName: Types.VariableName;
+            /**
+             * Name of the function that decodes a model Excel row (not blank!) to a fully typed object
+             */
+            rowDecoderName: Types.FunctionName;
+        };
+    };
+    /**
+     *  Properties provided by the `export` generators
      */
-    importExport: {
+    export: {
         /**
          * Name of the data exports model property (e.g. `Aggregations`).
          */
@@ -753,30 +805,18 @@ export type ModelMetaData = {
          * The name of the export Excel table (e.g. `Aggregations`).
          */
         tableName: string;
-        /**
-         * Name of the model specific error type
-         */
-        delta_Model_Errors: Types.TypeName;
         /**
          * Meta data of the model's Excel decoders
          */
-        decoder: {
+        encoder: {
             /**
-             * Name of the file containing the model's Excel decoders.
+             * Location of the file containing the model's Excel encoders.
              */
-            fileName: Types.FileName;
-            /**
-             * Path to the file containing the model's Excel decoders.
-             */
-            filePath: Types.FilePath;
+            location: Types.ModuleLocation;
             /**
              * Name of the type that represents the model in Excel import/export (e.g. `Aggregation_EncodedExcelData`.)
              */
             encodedExcelType: Types.TypeName;
-            /**
-             * Name of the decoder function that represents the Excel table import type (e.g. `aggregationExcelTableDecoder`.)
-             */
-            tableDecoder: Types.FunctionName;
             /**
              * Name of the function that converts a model item to the Excel format (e.g. `encodeAggregation`.)
              */
@@ -785,10 +825,6 @@ export type ModelMetaData = {
              * Name of the function that converts an array of model items to the Excel format (e.g. `encodeAggregations`.)
              */
             arrayEncoderFunctionName: Types.FunctionName;
-            /**
-             * Name of the array in the decoded data containing all entities of this model (e.g. `aggregations`.)
-             */
-            decodedModelArrayName: Types.VariableName;
         };
     };
     /**