diff --git a/src/app/components/data-page/data-page.component.html b/src/app/components/data-page/data-page.component.html
index 4ff4910..2ac2568 100644
--- a/src/app/components/data-page/data-page.component.html
+++ b/src/app/components/data-page/data-page.component.html
@@ -18,8 +18,8 @@
       <app-cell
         *ngFor="let prop of object.properties"
         [editable]="data.isLockedByMe && !prop.readonly"
-        [(value)]="data[prop.name]"
-        [label]="prop.translation || prop.name"
+        [(value)]="data[prop.dataPath]"
+        [label]="prop.translation || prop.dataPath"
         [inputType]="prop.type"
       ></app-cell>
     </mat-card>
@@ -30,7 +30,7 @@
         [dataServiceThatProvidesThePossibleData]="object.dataService"
         [nameToShowInSelection]="object.nameToShowInSelection"
         [columnInfo]="object.columnInfo"
-        [data]="data[object.name]"
+        [data]="data[object.dataPath]"
         [editable]="data.isLockedByMe"
         [tableDataGQLType]="object.tableDataGQLType"
         (referenceIds)="addReferenceIdsToObject($event, object)"
diff --git a/src/app/components/data-page/data-page.component.ts b/src/app/components/data-page/data-page.component.ts
index 9998ffe..c2c26dd 100644
--- a/src/app/components/data-page/data-page.component.ts
+++ b/src/app/components/data-page/data-page.component.ts
@@ -5,7 +5,7 @@ import { flatten } from 'src/app/helperFunctions/flattenObject';
 import { SchemaService } from 'src/app/services/schema.service';
 
 interface PropertyTypeInfo {
-  name: string;
+  dataPath: string;
   translation: string;
   readonly?: boolean;
   type?: string;
@@ -19,7 +19,7 @@ interface PropertyGroupInfo {
 interface ReferenceTableInfo {
   type: string;
   title: string;
-  name: string;
+  dataPath: string;
   dataService: any;
   columnInfo: PropertyTypeInfo[];
   nameToShowInSelection: any;
@@ -84,18 +84,18 @@ export class DataPageComponent implements OnInit {
       } else if (prop.type === 'ReferenceTable') {
         prop.tableDataGQLType =
           prop.tableDataGQLType ||
-          this.schemaService.getTypeInformation(this.pageDataGQLType, prop.name)
+          this.schemaService.getTypeInformation(this.pageDataGQLType, prop.dataPath)
             .type;
         prop.referenceIds = [];
       } else {
         const typeInformation = this.schemaService.getTypeInformation(
           this.pageDataGQLType,
-          prop.name
+          prop.dataPath
         );
         prop.type = prop.type || typeInformation.type;
         const updateTypeInformation = this.schemaService.getTypeInformation(
           this.pageDataGQLUpdateInputType,
-          prop.name
+          prop.dataPath
         );
         prop.readonly = prop.readonly || !updateTypeInformation.isPartOfType;
       }
diff --git a/src/app/components/reference-table/reference-table.component.html b/src/app/components/reference-table/reference-table.component.html
index d6b7c5f..ed1260c 100644
--- a/src/app/components/reference-table/reference-table.component.html
+++ b/src/app/components/reference-table/reference-table.component.html
@@ -42,27 +42,27 @@
       <!-- Other Columns -->
       <ng-container
         *ngFor="let column of columnInfo"
-        [matColumnDef]="column.name"
-        [sticky]="isStickyColumn(column.name)"
+        [matColumnDef]="column.dataPath"
+        [sticky]="isStickyColumn(column.dataPath)"
       >
         <th mat-header-cell *matHeaderCellDef mat-sort-header>
-          {{ column.translation || column.name }}
+          {{ column.translation || column.dataPath }}
         </th>
         <td mat-cell *matCellDef="let element">
           <app-cell
             *ngIf="column.type === 'Boolean'; else stringValue"
             [editable]="false"
-            [(value)]="element[column.name]"
+            [(value)]="element[column.dataPath]"
             [inputType]="column.type"
           ></app-cell>
           <ng-template #stringValue>
-            <span *ngIf="!column.link">{{ element[column.name] }}</span>
+            <span *ngIf="!column.link">{{ element[column.dataPath] }}</span>
             <a
               mat-button
               color="primary"
               *ngIf="column.link"
               [routerLink]="column.link(element)"
-              >{{ element[column.name] }}</a
+              >{{ element[column.dataPath] }}</a
             >
           </ng-template>
         </td>
diff --git a/src/app/components/reference-table/reference-table.component.ts b/src/app/components/reference-table/reference-table.component.ts
index 356325b..6906a5a 100644
--- a/src/app/components/reference-table/reference-table.component.ts
+++ b/src/app/components/reference-table/reference-table.component.ts
@@ -22,7 +22,7 @@ export class ReferenceTableComponent {
   /** this array defines the columns and translations of the table and the order they are displayed  */
   @Input()
   columnInfo: {
-    name: string;
+    dataPath: string;
     translation: string;
     sticky?: boolean;
     type?: string;
@@ -85,7 +85,7 @@ export class ReferenceTableComponent {
   ngOnInit() {
     this.addColumnPropertiesFromGQLSchemaToColumnInfo();
     this.columnInfo.forEach((column) => {
-      this.displayedColumns.push(column.name);
+      this.displayedColumns.push(column.dataPath);
     });
     this.displayedColumns.push('buttons');
 
@@ -121,15 +121,15 @@ export class ReferenceTableComponent {
     for (const column of this.columnInfo) {
       const typeInformation = this.schemaService.getTypeInformation(
         this.tableDataGQLType,
-        column.name
+        column.dataPath
       );
       column.type = column.type || typeInformation.type;
     }
   }
 
-  isStickyColumn(propertyName: string) {
+  isStickyColumn(dataPath: string) {
     return (
-      this.columnInfo.find((column) => column.name === propertyName)?.sticky ||
+      this.columnInfo.find((column) => column.dataPath === dataPath)?.sticky ||
       false
     );
   }
diff --git a/src/app/components/table/table.component.html b/src/app/components/table/table.component.html
index de1a6b2..9b3a277 100644
--- a/src/app/components/table/table.component.html
+++ b/src/app/components/table/table.component.html
@@ -97,12 +97,12 @@
       <!-- Other Columns -->
       <ng-container
         *ngFor="let column of columnInfo"
-        [matColumnDef]="column.name"
-        [sticky]="isStickyColumn(column.name)"
+        [matColumnDef]="column.dataPath"
+        [sticky]="isStickyColumn(column.dataPath)"
       >
         <!-- add cdkDrag to make columns draggable-->
         <th mat-header-cell *matHeaderCellDef mat-sort-header>
-          {{ getTranslation(column.name) }}
+          {{ getTranslation(column.dataPath) }}
         </th>
         <td mat-cell *matCellDef="let element">
           <app-cell
@@ -117,19 +117,19 @@
               (!column.readonly && element.isLockedByMe)
             "
             [required]="element.newObject && column.requiredForCreation"
-            (validityChange)="validityChange(element, column.name, $event)"
-            [(value)]="element[column.name]"
+            (validityChange)="validityChange(element, column.dataPath, $event)"
+            [(value)]="element[column.dataPath]"
             [inputType]="column.type"
             [link]="column.link ? column.link(element) : null"
           ></app-cell>
           <ng-template #stringValue>
-            <span *ngIf="!column.link">{{ element[column.name] }}</span>
+            <span *ngIf="!column.link">{{ element[column.dataPath] }}</span>
             <a
               mat-button
               color="primary"
               *ngIf="column.link"
               [routerLink]="column.link(element)"
-              >{{ element[column.name] }}</a
+              >{{ element[column.dataPath] }}</a
             >
           </ng-template>
         </td>
diff --git a/src/app/components/table/table.component.ts b/src/app/components/table/table.component.ts
index 2f157af..6baceb4 100644
--- a/src/app/components/table/table.component.ts
+++ b/src/app/components/table/table.component.ts
@@ -28,7 +28,7 @@ export class TableComponent {
   /** this array defines the columns and translations of the table and the order they are displayed  */
   @Input()
   columnInfo: {
-    name: string;
+    dataPath: string;
     translation: string;
     acceptedForCreation?: boolean;
     requiredForCreation?: boolean;
@@ -107,7 +107,7 @@ export class TableComponent {
     };
 
     this.columnInfo.forEach((column) =>
-      this.displayedColumns.push(column.name)
+      this.displayedColumns.push(column.dataPath)
     );
     this.displayedColumns.unshift(this.additionalColumnsFront[0]);
     this.displayedColumns.push(this.additionalColumnsBack[0]);
@@ -165,37 +165,37 @@ export class TableComponent {
     for (const column of this.columnInfo) {
       const typeInformation = this.schemaService.getTypeInformation(
         this.tableDataGQLType,
-        column.name
+        column.dataPath
       );
       column.type = column.type || typeInformation.type;
     }
     for (const column of this.columnInfo) {
       const typeInformation = this.schemaService.getTypeInformation(
         this.tableDataGQLUpdateInputType,
-        column.name
+        column.dataPath
       );
       column.readonly = column.readonly || !typeInformation.isPartOfType;
     }
     for (const column of this.columnInfo) {
       const typeInformation = this.schemaService.getTypeInformation(
         this.tableDataGQLCreateInputType,
-        column.name
+        column.dataPath
       );
       column.requiredForCreation = column.requiredForCreation || typeInformation.isRequired;
       column.acceptedForCreation = column.acceptedForCreation || typeInformation.isPartOfType;
     }
   }
 
-  getTranslation(propertyName: string) {
+  getTranslation(dataPath: string) {
     return (
-      this.columnInfo.find((column) => column.name === propertyName)
-        ?.translation || propertyName
+      this.columnInfo.find((column) => column.dataPath === dataPath)
+        ?.translation || dataPath
     );
   }
 
-  isStickyColumn(propertyName: string) {
+  isStickyColumn(dataPath: string) {
     return (
-      this.columnInfo.find((column) => column.name === propertyName)?.sticky ||
+      this.columnInfo.find((column) => column.dataPath === dataPath)?.sticky ||
       false
     );
   }
diff --git a/src/app/pages/dataPages/bike/bike.component.ts b/src/app/pages/dataPages/bike/bike.component.ts
index 6355668..702e36f 100644
--- a/src/app/pages/dataPages/bike/bike.component.ts
+++ b/src/app/pages/dataPages/bike/bike.component.ts
@@ -13,10 +13,10 @@ export class BikeComponent implements OnInit {
       type: 'Group',
       title: 'Allgemein',
       properties: [
-        { name: 'name', translation: 'Name' },
-        { name: 'id', translation: 'ID', readonly: true },
-        { name: 'Group', translation: 'Gruppe' },
-        { name: 'modelName', translation: 'Modell' },
+        { dataPath: 'name', translation: 'Name' },
+        { dataPath: 'id', translation: 'ID', readonly: true },
+        { dataPath: 'Group', translation: 'Gruppe' },
+        { dataPath: 'modelName', translation: 'Modell' },
       ],
     },
     {
@@ -24,96 +24,96 @@ export class BikeComponent implements OnInit {
       title: 'Versicherungsdaten',
       properties: [
         {
-          name: 'insuranceData.billing',
+          dataPath: 'insuranceData.billing',
           translation: 'Versicherung Abrechnung',
         },
-        { name: 'insuranceData.hasFixedRate', translation: 'Pauschale j/n' },
-        { name: 'insuranceData.fixedRate', translation: 'Pauschale Betrag' },
-        { name: 'insuranceData.name', translation: 'Versicherer' },
-        { name: 'insuranceData.benefactor', translation: 'Kostenträger' },
-        { name: 'insuranceData.noPnP', translation: 'Nr. P&P' },
+        { dataPath: 'insuranceData.hasFixedRate', translation: 'Pauschale j/n' },
+        { dataPath: 'insuranceData.fixedRate', translation: 'Pauschale Betrag' },
+        { dataPath: 'insuranceData.name', translation: 'Versicherer' },
+        { dataPath: 'insuranceData.benefactor', translation: 'Kostenträger' },
+        { dataPath: 'insuranceData.noPnP', translation: 'Nr. P&P' },
         {
-          name: 'insuranceData.maintenanceResponsible',
+          dataPath: 'insuranceData.maintenanceResponsible',
           translation: 'Wartung zuständig',
         },
         {
-          name: 'insuranceData.maintenanceBenefactor',
+          dataPath: 'insuranceData.maintenanceBenefactor',
           translation: 'Wartung Kostenträger',
         },
         {
-          name: 'insuranceData.maintenanceAgreement',
+          dataPath: 'insuranceData.maintenanceAgreement',
           translation: 'Wartungsvereinbarung',
         },
         {
-          name: 'insuranceData.projectAllowance',
+          dataPath: 'insuranceData.projectAllowance',
           translation: 'Projektzuschuss',
         },
-        { name: 'insuranceData.notes', translation: 'Sonstiges' },
+        { dataPath: 'insuranceData.notes', translation: 'Sonstiges' },
       ],
     },
     {
       type: 'Group',
       title: 'Maße und Ladungen',
       properties: [
-        { name: 'dimensionsAndLoad.bikeLength', translation: 'Länge' },
-        { name: 'dimensionsAndLoad.bikeWeight', translation: 'Gewicht' },
-        { name: 'dimensionsAndLoad.bikeHeight', translation: 'Höhe' },
-        { name: 'dimensionsAndLoad.bikeWidth', translation: 'Breite' },
-        { name: 'dimensionsAndLoad.boxHeight', translation: 'Boxhöhe' },
-        { name: 'dimensionsAndLoad.boxLength', translation: 'Boxlänge' },
-        { name: 'dimensionsAndLoad.boxWidth', translation: 'Boxbreite' },
+        { dataPath: 'dimensionsAndLoad.bikeLength', translation: 'Länge' },
+        { dataPath: 'dimensionsAndLoad.bikeWeight', translation: 'Gewicht' },
+        { dataPath: 'dimensionsAndLoad.bikeHeight', translation: 'Höhe' },
+        { dataPath: 'dimensionsAndLoad.bikeWidth', translation: 'Breite' },
+        { dataPath: 'dimensionsAndLoad.boxHeight', translation: 'Boxhöhe' },
+        { dataPath: 'dimensionsAndLoad.boxLength', translation: 'Boxlänge' },
+        { dataPath: 'dimensionsAndLoad.boxWidth', translation: 'Boxbreite' },
         {
-          name: 'dimensionsAndLoad.hasCoverBox',
+          dataPath: 'dimensionsAndLoad.hasCoverBox',
           translation: 'Boxabdeckung j/n',
         },
-        { name: 'dimensionsAndLoad.lockable', translation: 'Box abschließbar' },
+        { dataPath: 'dimensionsAndLoad.lockable', translation: 'Box abschließbar' },
         {
-          name: 'dimensionsAndLoad.maxWeightBox',
+          dataPath: 'dimensionsAndLoad.maxWeightBox',
           translation: 'max Zuladung Box',
         },
         {
-          name: 'dimensionsAndLoad.maxWeightLuggageRack',
+          dataPath: 'dimensionsAndLoad.maxWeightLuggageRack',
           translation: 'max Zuladung Gepäckträger',
         },
         {
-          name: 'dimensionsAndLoad.maxWeightTotal',
+          dataPath: 'dimensionsAndLoad.maxWeightTotal',
           translation: 'max Gesamtgewicht',
         },
-        { name: 'numberOfChildren', translation: 'Anzahl Kinder' },
-        { name: 'numberOfWheels', translation: 'Anzahl Räder' },
-        { name: 'forCargo', translation: 'für Lasten j/n' },
-        { name: 'forChildren', translation: 'für Kinder j/n' },
+        { dataPath: 'numberOfChildren', translation: 'Anzahl Kinder' },
+        { dataPath: 'numberOfWheels', translation: 'Anzahl Räder' },
+        { dataPath: 'forCargo', translation: 'für Lasten j/n' },
+        { dataPath: 'forChildren', translation: 'für Kinder j/n' },
       ],
     },
     {
       type: 'Group',
       title: 'Sicherheitsinformationen',
       properties: [
-        { name: 'security.frameNumber', translation: 'Rahmennummer' },
-        { name: 'security.adfcCoding', translation: 'ADFC Codierung' },
+        { dataPath: 'security.frameNumber', translation: 'Rahmennummer' },
+        { dataPath: 'security.adfcCoding', translation: 'ADFC Codierung' },
         {
-          name: 'security.keyNumberAXAChain',
+          dataPath: 'security.keyNumberAXAChain',
           translation: 'Schlüsselnrummer Rahmenschloss',
         },
         {
-          name: 'security.keyNumberFrameLock',
+          dataPath: 'security.keyNumberFrameLock',
           translation: 'Schlüsselnrummer AXA-Kette',
         },
-        { name: 'security.policeCoding', translation: 'Polizei Codierung' },
+        { dataPath: 'security.policeCoding', translation: 'Polizei Codierung' },
       ],
     },
     {
       type: 'Group',
       title: 'Ausstattung',
       properties: [
-        { name: 'technicalEquipment.bicycleShift', translation: 'Schaltung' },
-        { name: 'technicalEquipment.isEBike', translation: 'E-Bike j/n' },
+        { dataPath: 'technicalEquipment.bicycleShift', translation: 'Schaltung' },
+        { dataPath: 'technicalEquipment.isEBike', translation: 'E-Bike j/n' },
         {
-          name: 'technicalEquipment.hasLightSystem',
+          dataPath: 'technicalEquipment.hasLightSystem',
           translation: 'Lichtanlage j/n',
         },
         {
-          name: 'technicalEquipment.specialFeatures',
+          dataPath: 'technicalEquipment.specialFeatures',
           translation: 'Besonderheiten',
         },
       ],
@@ -122,11 +122,11 @@ export class BikeComponent implements OnInit {
       type: 'Group',
       title: 'Sonstiges',
       properties: [
-        { name: 'stickerBikeNameState', translation: 'Aufkleber Status' },
-        { name: 'note', translation: 'Aufkleber Kommentar' },
-        { name: 'taxes.costCenter', translation: 'Steuern Kostenstelle' },
+        { dataPath: 'stickerBikeNameState', translation: 'Aufkleber Status' },
+        { dataPath: 'note', translation: 'Aufkleber Kommentar' },
+        { dataPath: 'taxes.costCenter', translation: 'Steuern Kostenstelle' },
         {
-          name: 'taxes.organisationArea',
+          dataPath: 'taxes.organisationArea',
           translation: 'Steuern Vereinsbereich',
         },
       ],
@@ -135,14 +135,14 @@ export class BikeComponent implements OnInit {
       type: 'Group',
       title: 'provider',
       properties: [
-        { name: 'provider.id', translation: '' },
-        { name: 'provider.formName', translation: '' },
-        { name: 'provider.privatePerson.id', translation: '' },
-        { name: 'provider.privatePerson.person.id', translation: '' },
-        { name: 'provider.privatePerson.person.name', translation: '' },
-        { name: 'provider.privatePerson.person.firstName', translation: '' },
+        { dataPath: 'provider.id', translation: '' },
+        { dataPath: 'provider.formName', translation: '' },
+        { dataPath: 'provider.privatePerson.id', translation: '' },
+        { dataPath: 'provider.privatePerson.person.id', translation: '' },
+        { dataPath: 'provider.privatePerson.person.name', translation: '' },
+        { dataPath: 'provider.privatePerson.person.firstName', translation: '' },
         {
-          name: 'provider.privatePerson.person.contactInformation.email',
+          dataPath: 'provider.privatePerson.person.contactInformation.email',
           translation: '',
         },
       ],
@@ -151,19 +151,19 @@ export class BikeComponent implements OnInit {
       type: 'Group',
       title: 'lendingstation',
       properties: [
-        { name: 'lendingStation.id', translation: '' },
-        { name: 'lendingStation.name', translation: '' },
-        { name: 'lendingStation.address.number', translation: '' },
-        { name: 'lendingStation.address.street', translation: '' },
-        { name: 'lendingStation.address.zip', translation: '' },
+        { dataPath: 'lendingStation.id', translation: '' },
+        { dataPath: 'lendingStation.name', translation: '' },
+        { dataPath: 'lendingStation.address.number', translation: '' },
+        { dataPath: 'lendingStation.address.street', translation: '' },
+        { dataPath: 'lendingStation.address.zip', translation: '' },
       ],
     },
     {
       type: 'ReferenceTable',
       title: 'Equipmenttypen',
-      name: 'equipmentType',
+      dataPath: 'equipmentType',
       dataService: null,
-      columnInfo: [{name: 'name', translation: "Name"}, {name: 'description', translation: "Beschreibung"}],
+      columnInfo: [{dataPath: 'name', translation: "Name"}, {dataPath: 'description', translation: "Beschreibung"}],
       nameToShowInSelection: (element) => {return element.name},
       propertyNameOfUpdateInput: "equipmentTypeIds"
     },
@@ -180,7 +180,7 @@ export class BikeComponent implements OnInit {
     private equipmentTypeService: EquipmentTypeService
   ) {
     this.propertiesInfo.find(
-      (prop) => prop.name === 'equipmentType'
+      (prop) => prop.dataPath === 'equipmentType'
     ).dataService = this.equipmentTypeService;
   }
 
diff --git a/src/app/pages/tables/bikes/bikes.component.ts b/src/app/pages/tables/bikes/bikes.component.ts
index 3bf81e5..9c4dc23 100644
--- a/src/app/pages/tables/bikes/bikes.component.ts
+++ b/src/app/pages/tables/bikes/bikes.component.ts
@@ -9,98 +9,113 @@ import { BikesService } from 'src/app/services/bikes.service';
 export class BikesComponent implements OnInit {
   columnInfo = [
     {
-      name: 'name',
+      dataPath: 'name',
       translation: 'Name',
       sticky: true,
       link: (row: any) => {
         return '/bike/' + row.id;
       },
     },
-    { name: 'id', translation: 'ID', readonly: true },
-    { name: 'group', translation: 'Gruppe' },
-    { name: 'modelName', translation: 'Modell' },
-    { name: 'insuranceData.billing', translation: 'Versicherung Abrechnung' },
-    { name: 'insuranceData.hasFixedRate', translation: 'Pauschale j/n' },
-    { name: 'insuranceData.fixedRate', translation: 'Pauschale Betrag' },
-    { name: 'insuranceData.name', translation: 'Versicherer' },
-    { name: 'insuranceData.benefactor', translation: 'Kostenträger' },
-    { name: 'insuranceData.noPnP', translation: 'Nr. P&P' },
-    {
-      name: 'insuranceData.maintenanceResponsible',
+    { dataPath: 'id', translation: 'ID', readonly: true },
+    { dataPath: 'group', translation: 'Gruppe' },
+    { dataPath: 'modelName', translation: 'Modell' },
+    {
+      dataPath: 'insuranceData.billing',
+      translation: 'Versicherung Abrechnung',
+    },
+    { dataPath: 'insuranceData.hasFixedRate', translation: 'Pauschale j/n' },
+    { dataPath: 'insuranceData.fixedRate', translation: 'Pauschale Betrag' },
+    { dataPath: 'insuranceData.name', translation: 'Versicherer' },
+    { dataPath: 'insuranceData.benefactor', translation: 'Kostenträger' },
+    { dataPath: 'insuranceData.noPnP', translation: 'Nr. P&P' },
+    {
+      dataPath: 'insuranceData.maintenanceResponsible',
       translation: 'Wartung zuständig',
     },
     {
-      name: 'insuranceData.maintenanceBenefactor',
+      dataPath: 'insuranceData.maintenanceBenefactor',
       translation: 'Wartung Kostenträger',
     },
     {
-      name: 'insuranceData.maintenanceAgreement',
+      dataPath: 'insuranceData.maintenanceAgreement',
       translation: 'Wartungsvereinbarung',
     },
-    { name: 'insuranceData.projectAllowance', translation: 'Projektzuschuss' },
-    { name: 'insuranceData.notes', translation: 'Sonstiges' },
-    { name: 'dimensionsAndLoad.bikeLength', translation: 'Länge' },
-    { name: 'dimensionsAndLoad.bikeWeight', translation: 'Gewicht' },
-    { name: 'dimensionsAndLoad.bikeHeight', translation: 'Höhe' },
-    { name: 'dimensionsAndLoad.bikeWidth', translation: 'Breite' },
-    { name: 'dimensionsAndLoad.boxHeight', translation: 'Boxhöhe' },
-    { name: 'dimensionsAndLoad.boxLength', translation: 'Boxlänge' },
-    { name: 'dimensionsAndLoad.boxWidth', translation: 'Boxbreite' },
-    { name: 'dimensionsAndLoad.hasCoverBox', translation: 'Boxabdeckung j/n' },
-    { name: 'dimensionsAndLoad.lockable', translation: 'Box abschließbar' },
-    { name: 'dimensionsAndLoad.maxWeightBox', translation: 'max Zuladung Box' },
-    {
-      name: 'dimensionsAndLoad.maxWeightLuggageRack',
+    {
+      dataPath: 'insuranceData.projectAllowance',
+      translation: 'Projektzuschuss',
+    },
+    { dataPath: 'insuranceData.notes', translation: 'Sonstiges' },
+    { dataPath: 'dimensionsAndLoad.bikeLength', translation: 'Länge' },
+    { dataPath: 'dimensionsAndLoad.bikeWeight', translation: 'Gewicht' },
+    { dataPath: 'dimensionsAndLoad.bikeHeight', translation: 'Höhe' },
+    { dataPath: 'dimensionsAndLoad.bikeWidth', translation: 'Breite' },
+    { dataPath: 'dimensionsAndLoad.boxHeight', translation: 'Boxhöhe' },
+    { dataPath: 'dimensionsAndLoad.boxLength', translation: 'Boxlänge' },
+    { dataPath: 'dimensionsAndLoad.boxWidth', translation: 'Boxbreite' },
+    {
+      dataPath: 'dimensionsAndLoad.hasCoverBox',
+      translation: 'Boxabdeckung j/n',
+    },
+    { dataPath: 'dimensionsAndLoad.lockable', translation: 'Box abschließbar' },
+    {
+      dataPath: 'dimensionsAndLoad.maxWeightBox',
+      translation: 'max Zuladung Box',
+    },
+    {
+      dataPath: 'dimensionsAndLoad.maxWeightLuggageRack',
       translation: 'max Zuladung Gepäckträger',
     },
     {
-      name: 'dimensionsAndLoad.maxWeightTotal',
+      dataPath: 'dimensionsAndLoad.maxWeightTotal',
       translation: 'max Gesamtgewicht',
     },
-    { name: 'numberOfChildren', translation: 'Anzahl Kinder' },
-    { name: 'numberOfWheels', translation: 'Anzahl Räder' },
-    { name: 'forCargo', translation: 'für Lasten j/n' },
-    { name: 'forChildren', translation: 'für Kinder j/n' },
-    { name: 'security.frameNumber', translation: 'Rahmennummer' },
-    { name: 'security.adfcCoding', translation: 'ADFC Codierung' },
+    { dataPath: 'numberOfChildren', translation: 'Anzahl Kinder' },
+    { dataPath: 'numberOfWheels', translation: 'Anzahl Räder' },
+    { dataPath: 'forCargo', translation: 'für Lasten j/n' },
+    { dataPath: 'forChildren', translation: 'für Kinder j/n' },
+    { dataPath: 'security.frameNumber', translation: 'Rahmennummer' },
+    { dataPath: 'security.adfcCoding', translation: 'ADFC Codierung' },
     {
-      name: 'security.keyNumberAXAChain',
+      dataPath: 'security.keyNumberAXAChain',
       translation: 'Schlüsselnrummer Rahmenschloss',
     },
     {
-      name: 'security.keyNumberFrameLock',
+      dataPath: 'security.keyNumberFrameLock',
       translation: 'Schlüsselnrummer AXA-Kette',
     },
-    { name: 'security.policeCoding', translation: 'Polizei Codierung' },
-    { name: 'technicalEquipment.bicycleShift', translation: 'Schaltung' },
-    { name: 'technicalEquipment.isEBike', translation: 'E-Bike j/n' },
+    { dataPath: 'security.policeCoding', translation: 'Polizei Codierung' },
+    { dataPath: 'technicalEquipment.bicycleShift', translation: 'Schaltung' },
+    { dataPath: 'technicalEquipment.isEBike', translation: 'E-Bike j/n' },
     {
-      name: 'technicalEquipment.hasLightSystem',
+      dataPath: 'technicalEquipment.hasLightSystem',
       translation: 'Lichtanlage j/n',
     },
     {
-      name: 'technicalEquipment.specialFeatures',
+      dataPath: 'technicalEquipment.specialFeatures',
       translation: 'Besonderheiten',
     },
-    { name: 'stickerBikeNameState', translation: 'Aufkleber Status' },
-    { name: 'note', translation: 'Aufkleber Kommentar' },
-    { name: 'taxes.costCenter', translation: 'Steuern Kostenstelle' },
-    { name: 'taxes.organisationArea', translation: 'Steuern Vereinsbereich' },
-    { name: 'provider.id', translation: '' },
-    { name: 'provider.formName', translation: '' },
-    { name: 'provider.privatePerson.id', translation: '' },
-    { name: 'provider.privatePerson.person.id', translation: '' },
-    { name: 'provider.privatePerson.person.name', translation: '' },
-    { name: 'provider.privatePerson.person.firstName', translation: '' },
-    {
-      name: 'provider.privatePerson.person.contactInformation.email',
+    { dataPath: 'stickerBikeNameState', translation: 'Aufkleber Status' },
+    { dataPath: 'note', translation: 'Aufkleber Kommentar' },
+    { dataPath: 'taxes.costCenter', translation: 'Steuern Kostenstelle' },
+    {
+      dataPath: 'taxes.organisationArea',
+      translation: 'Steuern Vereinsbereich',
+    },
+    { dataPath: 'provider.id', translation: '' },
+    { dataPath: 'provider.formName', translation: '' },
+    { dataPath: 'provider.privatePerson.id', translation: '' },
+    { dataPath: 'provider.privatePerson.person.id', translation: '' },
+    { dataPath: 'provider.privatePerson.person.name', translation: '' },
+    { dataPath: 'provider.privatePerson.person.firstName', translation: '' },
+    {
+      dataPath: 'provider.privatePerson.person.contactInformation.email',
       translation: '',
     },
-    { name: 'lendingStation.id', translation: '' },
-    { name: 'lendingStation.name', translation: '' },
-    { name: 'lendingStation.address.number', translation: '' },
-    { name: 'lendingStation.address.street', translation: '' },
-    { name: 'lendingStation.address.zip', translation: '' },
+    { dataPath: 'lendingStation.id', translation: '' },
+    { dataPath: 'lendingStation.name', translation: '' },
+    { dataPath: 'lendingStation.address.number', translation: '' },
+    { dataPath: 'lendingStation.address.street', translation: '' },
+    { dataPath: 'lendingStation.address.zip', translation: '' },
   ];
 
   dataService: any;
diff --git a/src/app/pages/tables/equipment-types/equipment-types.component.ts b/src/app/pages/tables/equipment-types/equipment-types.component.ts
index 09b3e9d..f8aaae1 100644
--- a/src/app/pages/tables/equipment-types/equipment-types.component.ts
+++ b/src/app/pages/tables/equipment-types/equipment-types.component.ts
@@ -10,9 +10,9 @@ export class EquipmentTypesComponent implements OnInit {
   headline = 'Ausstattungstypen';
 
   columnInfo = [
-    { name: 'id', translation: 'ID', readonly: true },
-    { name: 'name', translation: 'Name', requiredForCreation: true },
-    { name: 'description', translation: 'Beschreibung' },
+    { dataPath: 'id', translation: 'ID', readonly: true },
+    { dataPath: 'name', translation: 'Name', requiredForCreation: true },
+    { dataPath: 'description', translation: 'Beschreibung' },
   ];
 
   dataService: EquipmentTypeService;