From 423dc7a6bfd81eafb0ad9a144e5517c13a487de1 Mon Sep 17 00:00:00 2001
From: vabene1111 <vabene1234@googlemail.com>
Date: Sun, 1 Dec 2024 12:32:16 +0100
Subject: [PATCH] lots of shopping tweaks

---
 cookbook/serializer.py                        |    1 +
 cookbook/views/api.py                         |    1 +
 .../components/display/ShoppingListView.vue   |   35 +-
 vue3/src/openapi/.openapi-generator/FILES     |   20 +-
 vue3/src/openapi/apis/ApiApi.ts               | 1787 +++++++++++++++++
 vue3/src/openapi/models/AccessToken.ts        |   18 +-
 vue3/src/openapi/models/AuthToken.ts          |   18 +-
 vue3/src/openapi/models/AutoMealPlan.ts       |   19 +-
 vue3/src/openapi/models/Automation.ts         |   37 +-
 vue3/src/openapi/models/BookmarkletImport.ts  |   18 +-
 .../openapi/models/BookmarkletImportList.ts   |   18 +-
 .../openapi/models/ConnectorConfigConfig.ts   |   18 +-
 vue3/src/openapi/models/CookLog.ts            |   19 +-
 vue3/src/openapi/models/CustomFilter.ts       |   19 +-
 vue3/src/openapi/models/ExportLog.ts          |   18 +-
 vue3/src/openapi/models/Food.ts               |   24 +-
 vue3/src/openapi/models/FoodInheritField.ts   |   18 +-
 vue3/src/openapi/models/FoodShoppingUpdate.ts |   19 +-
 vue3/src/openapi/models/FoodSimple.ts         |   18 +-
 vue3/src/openapi/models/Group.ts              |   18 +-
 vue3/src/openapi/models/ImportImage.ts        |   18 +-
 vue3/src/openapi/models/ImportLog.ts          |   19 +-
 vue3/src/openapi/models/Ingredient.ts         |   20 +-
 vue3/src/openapi/models/IngredientString.ts   |   18 +-
 vue3/src/openapi/models/InviteLink.ts         |   19 +-
 vue3/src/openapi/models/Keyword.ts            |   18 +-
 vue3/src/openapi/models/KeywordLabel.ts       |   18 +-
 vue3/src/openapi/models/Localization.ts       |   18 +-
 vue3/src/openapi/models/MealPlan.ts           |   21 +-
 vue3/src/openapi/models/MealType.ts           |   18 +-
 .../openapi/models/NutritionInformation.ts    |   18 +-
 vue3/src/openapi/models/OpenDataCategory.ts   |   19 +-
 vue3/src/openapi/models/OpenDataConversion.ts |   21 +-
 vue3/src/openapi/models/OpenDataFood.ts       |   22 +-
 .../openapi/models/OpenDataFoodProperty.ts    |   19 +-
 vue3/src/openapi/models/OpenDataProperty.ts   |   19 +-
 vue3/src/openapi/models/OpenDataStore.ts      |   20 +-
 .../openapi/models/OpenDataStoreCategory.ts   |   19 +-
 vue3/src/openapi/models/OpenDataUnit.ts       |   21 +-
 vue3/src/openapi/models/OpenDataVersion.ts    |   18 +-
 .../openapi/models/PaginatedAutomationList.ts |   19 +-
 .../PaginatedBookmarkletImportListList.ts     |   19 +-
 .../openapi/models/PaginatedCookLogList.ts    |   19 +-
 .../models/PaginatedCustomFilterList.ts       |   19 +-
 .../openapi/models/PaginatedExportLogList.ts  |   19 +-
 vue3/src/openapi/models/PaginatedFoodList.ts  |   19 +-
 .../openapi/models/PaginatedImportLogList.ts  |   19 +-
 .../openapi/models/PaginatedIngredientList.ts |   19 +-
 .../openapi/models/PaginatedInviteLinkList.ts |   19 +-
 .../openapi/models/PaginatedKeywordList.ts    |   19 +-
 .../openapi/models/PaginatedMealPlanList.ts   |   19 +-
 .../openapi/models/PaginatedMealTypeList.ts   |   19 +-
 .../openapi/models/PaginatedPropertyList.ts   |   19 +-
 .../models/PaginatedPropertyTypeList.ts       |   19 +-
 .../models/PaginatedRecipeBookEntryList.ts    |   19 +-
 .../openapi/models/PaginatedRecipeBookList.ts |   19 +-
 .../models/PaginatedRecipeOverviewList.ts     |   19 +-
 .../models/PaginatedShoppingListEntryList.ts  |   19 +-
 .../models/PaginatedShoppingListRecipeList.ts |   19 +-
 vue3/src/openapi/models/PaginatedSpaceList.ts |   19 +-
 vue3/src/openapi/models/PaginatedStepList.ts  |   19 +-
 .../PaginatedSupermarketCategoryList.ts       |   19 +-
 ...aginatedSupermarketCategoryRelationList.ts |   19 +-
 .../models/PaginatedSupermarketList.ts        |   19 +-
 vue3/src/openapi/models/PaginatedSyncList.ts  |   19 +-
 .../openapi/models/PaginatedSyncLogList.ts    |   19 +-
 .../models/PaginatedUnitConversionList.ts     |   19 +-
 vue3/src/openapi/models/PaginatedUnitList.ts  |   19 +-
 .../openapi/models/PaginatedUserFileList.ts   |   19 +-
 .../openapi/models/PaginatedUserSpaceList.ts  |   19 +-
 .../openapi/models/PaginatedViewLogList.ts    |   19 +-
 vue3/src/openapi/models/ParsedIngredient.ts   |   18 +-
 vue3/src/openapi/models/PatchedAccessToken.ts |   18 +-
 vue3/src/openapi/models/PatchedAutomation.ts  |   37 +-
 .../models/PatchedBookmarkletImport.ts        |   18 +-
 .../models/PatchedConnectorConfigConfig.ts    |   18 +-
 vue3/src/openapi/models/PatchedCookLog.ts     |   19 +-
 .../src/openapi/models/PatchedCustomFilter.ts |   19 +-
 vue3/src/openapi/models/PatchedExportLog.ts   |   18 +-
 vue3/src/openapi/models/PatchedFood.ts        |   24 +-
 vue3/src/openapi/models/PatchedImportLog.ts   |   19 +-
 vue3/src/openapi/models/PatchedIngredient.ts  |   20 +-
 vue3/src/openapi/models/PatchedInviteLink.ts  |   19 +-
 vue3/src/openapi/models/PatchedKeyword.ts     |   18 +-
 vue3/src/openapi/models/PatchedMealPlan.ts    |   21 +-
 vue3/src/openapi/models/PatchedMealType.ts    |   18 +-
 .../openapi/models/PatchedOpenDataCategory.ts |   19 +-
 .../models/PatchedOpenDataConversion.ts       |   21 +-
 .../src/openapi/models/PatchedOpenDataFood.ts |   22 +-
 .../openapi/models/PatchedOpenDataProperty.ts |   19 +-
 .../openapi/models/PatchedOpenDataStore.ts    |   20 +-
 .../src/openapi/models/PatchedOpenDataUnit.ts |   21 +-
 .../openapi/models/PatchedOpenDataVersion.ts  |   18 +-
 vue3/src/openapi/models/PatchedProperty.ts    |   19 +-
 .../src/openapi/models/PatchedPropertyType.ts |   18 +-
 vue3/src/openapi/models/PatchedRecipe.ts      |   23 +-
 vue3/src/openapi/models/PatchedRecipeBook.ts  |   20 +-
 .../openapi/models/PatchedRecipeBookEntry.ts  |   20 +-
 .../models/PatchedShoppingListEntry.ts        |   22 +-
 .../models/PatchedShoppingListRecipe.ts       |   18 +-
 vue3/src/openapi/models/PatchedSpace.ts       |   23 +-
 vue3/src/openapi/models/PatchedStep.ts        |   20 +-
 vue3/src/openapi/models/PatchedStorage.ts     |   19 +-
 vue3/src/openapi/models/PatchedSupermarket.ts |   19 +-
 .../models/PatchedSupermarketCategory.ts      |   18 +-
 .../PatchedSupermarketCategoryRelation.ts     |   19 +-
 vue3/src/openapi/models/PatchedSync.ts        |   18 +-
 vue3/src/openapi/models/PatchedUnit.ts        |   18 +-
 .../openapi/models/PatchedUnitConversion.ts   |   20 +-
 vue3/src/openapi/models/PatchedUser.ts        |   18 +-
 .../openapi/models/PatchedUserPreference.ts   |   24 +-
 vue3/src/openapi/models/PatchedUserSpace.ts   |   20 +-
 vue3/src/openapi/models/PatchedViewLog.ts     |   18 +-
 vue3/src/openapi/models/Property.ts           |   19 +-
 vue3/src/openapi/models/PropertyType.ts       |   18 +-
 vue3/src/openapi/models/Recipe.ts             |   23 +-
 vue3/src/openapi/models/RecipeBook.ts         |   20 +-
 vue3/src/openapi/models/RecipeBookEntry.ts    |   20 +-
 vue3/src/openapi/models/RecipeFlat.ts         |   18 +-
 vue3/src/openapi/models/RecipeImage.ts        |   18 +-
 vue3/src/openapi/models/RecipeOverview.ts     |   19 +-
 .../openapi/models/RecipeShoppingUpdate.ts    |   18 +-
 vue3/src/openapi/models/RecipeSimple.ts       |   18 +-
 vue3/src/openapi/models/ServerSettings.ts     |   27 +-
 vue3/src/openapi/models/ShareLink.ts          |   18 +-
 vue3/src/openapi/models/ShoppingListEntry.ts  |   22 +-
 .../openapi/models/ShoppingListEntryBulk.ts   |   18 +-
 vue3/src/openapi/models/ShoppingListRecipe.ts |   18 +-
 vue3/src/openapi/models/Space.ts              |   23 +-
 vue3/src/openapi/models/Step.ts               |   20 +-
 vue3/src/openapi/models/Storage.ts            |   19 +-
 vue3/src/openapi/models/Supermarket.ts        |   19 +-
 .../src/openapi/models/SupermarketCategory.ts |   18 +-
 .../models/SupermarketCategoryRelation.ts     |   19 +-
 vue3/src/openapi/models/Sync.ts               |   18 +-
 vue3/src/openapi/models/SyncLog.ts            |   18 +-
 vue3/src/openapi/models/Unit.ts               |   18 +-
 vue3/src/openapi/models/UnitConversion.ts     |   20 +-
 vue3/src/openapi/models/User.ts               |   18 +-
 vue3/src/openapi/models/UserFile.ts           |   19 +-
 vue3/src/openapi/models/UserFileView.ts       |   19 +-
 vue3/src/openapi/models/UserPreference.ts     |   24 +-
 vue3/src/openapi/models/UserSpace.ts          |   20 +-
 vue3/src/openapi/models/ViewLog.ts            |   18 +-
 vue3/src/openapi/models/index.ts              |   20 +-
 vue3/src/stores/ShoppingListStore.js          |  487 -----
 vue3/src/stores/ShoppingStore.ts              |   52 +-
 vue3/src/stores/UserPreferenceStore.ts        |    5 +-
 vue3/src/types/Shopping.ts                    |    2 +-
 vue3/src/utils/logic_utils.ts                 |    2 +-
 150 files changed, 2918 insertions(+), 2207 deletions(-)
 delete mode 100644 vue3/src/stores/ShoppingListStore.js

diff --git a/cookbook/serializer.py b/cookbook/serializer.py
index 89314df01..04db8c1ad 100644
--- a/cookbook/serializer.py
+++ b/cookbook/serializer.py
@@ -1436,6 +1436,7 @@ class ServerSettingsSerializer(serializers.Serializer):
     privacy_url = serializers.CharField()
     imprint_url = serializers.CharField()
     hosted = serializers.BooleanField()
+    debug = serializers.BooleanField()
 
     class Meta:
         fields = '__ALL__'
diff --git a/cookbook/views/api.py b/cookbook/views/api.py
index b0c6a9b3c..afd414292 100644
--- a/cookbook/views/api.py
+++ b/cookbook/views/api.py
@@ -1980,6 +1980,7 @@ class ServerSettingsViewSet(viewsets.GenericViewSet):
         s['privacy_url'] = settings.PRIVACY_URL
         s['imprint_url'] = settings.IMPRINT_URL
         s['hosted'] = settings.HOSTED
+        s['debug'] = settings.DEBUG
 
         return Response(ServerSettingsSerializer(s, many=False).data)
 
diff --git a/vue3/src/components/display/ShoppingListView.vue b/vue3/src/components/display/ShoppingListView.vue
index 756adfe19..aebb315e2 100644
--- a/vue3/src/components/display/ShoppingListView.vue
+++ b/vue3/src/components/display/ShoppingListView.vue
@@ -2,8 +2,10 @@
     <v-tabs v-model="currentTab">
         <v-tab value="shopping"><i class="fas fa-fw"
                                    :class="{'fa-circle-notch fa-spin':useShoppingStore().currentlyUpdating, 'fa-shopping-cart ': !useShoppingStore().currentlyUpdating}"></i> <span
-            class="d-none d-md-block ms-1">{{ $t('Shopping_list') }} ({{useShoppingStore().stats.countUnchecked}})</span></v-tab>
-        <v-tab value="recipes"><i class="fas fa-book fa-fw"></i> <span class="d-none d-md-block ms-1">{{ $t('Recipes') }} ({{useShoppingStore().getAssociatedRecipes().length}})</span></v-tab>
+            class="d-none d-md-block ms-1">{{ $t('Shopping_list') }} ({{ useShoppingStore().stats.countUnchecked }})</span></v-tab>
+        <v-tab value="recipes"><i class="fas fa-book fa-fw"></i> <span class="d-none d-md-block ms-1">{{
+                $t('Recipes')
+            }} ({{ useShoppingStore().getAssociatedRecipes().length }})</span></v-tab>
 
         <v-menu :close-on-content-click="false">
             <template v-slot:activator="{ props }">
@@ -40,7 +42,7 @@
                     <v-switch color="primary" hide-details :label="$t('ShowRecentlyCompleted')"
                               v-model="useUserPreferenceStore().deviceSettings.shopping_show_checked_entries"></v-switch>
                 </v-list-item>
-                <v-list-subheader>{{$t('Information')}}</v-list-subheader>
+                <v-list-subheader>{{ $t('Information') }}</v-list-subheader>
                 <v-list-item>
                     <v-switch color="primary" hide-details :label="$t('Recipe')" v-model="useUserPreferenceStore().deviceSettings.shopping_item_info_recipe"></v-switch>
                 </v-list-item>
@@ -50,6 +52,9 @@
                 <v-list-item>
                     <v-switch color="primary" hide-details :label="$t('CreatedBy')" v-model="useUserPreferenceStore().deviceSettings.shopping_item_info_created_by"></v-switch>
                 </v-list-item>
+                <v-list-item v-if="useUserPreferenceStore().serverSettings.debug">
+                    <v-switch color="primary" hide-details label="Show Debug Info" v-model="useUserPreferenceStore().deviceSettings.shopping_show_debug"></v-switch>
+                </v-list-item>
 
             </v-list>
         </v-menu>
@@ -60,6 +65,16 @@
             <v-container>
                 <v-row>
                     <v-col>
+                        <v-alert v-if="useShoppingStore().hasFailedItems()" color="warning" class="mb-2">
+                            <template #prepend>
+                                <v-icon icon="fa-solid fa-link-slash"></v-icon>
+                            </template>
+                            {{ $t('ShoppingBackgroundSyncWarning') }}
+                            <template #append>
+                                {{ useShoppingStore().itemCheckSyncQueue.length }}
+                            </template>
+                        </v-alert>
+
                         <v-text-field :label="$t('Shopping_input_placeholder')" density="compact" @keyup.enter="addIngredient()" v-model="ingredientInput" hide-details>
                             <template #append>
                                 <v-btn
@@ -92,10 +107,11 @@
                     </v-col>
                 </v-row>
 
-                <v-row>
+                <v-row v-if="useUserPreferenceStore().deviceSettings.shopping_show_debug">
                     <v-col cols="12" md="4">
                         <v-card>
                             <v-card-title>Auto Sync Debug</v-card-title>
+                            <v-btn @click="useShoppingStore().autoSync()">Run Sync</v-btn>
                             <v-card-text>
                                 <v-list>
                                     <v-list-item>currentlyUpdating: {{ useShoppingStore().currentlyUpdating }}</v-list-item>
@@ -148,7 +164,7 @@
                                         {{ r.recipeName }}
                                         <template #append>
                                             <v-btn icon="$delete" color="delete"></v-btn>
-                                            <number-scaler-dialog ></number-scaler-dialog>
+                                            <number-scaler-dialog></number-scaler-dialog>
                                         </template>
                                     </v-list-item>
                                 </v-list>
@@ -208,6 +224,13 @@ onMounted(() => {
     useShoppingStore().refreshFromAPI()
 
     autoSyncLoop()
+
+    // refresh selected supermarket since category ordering might have changed
+    if (Object.keys(useUserPreferenceStore().deviceSettings.shopping_selected_supermarket).length > 0) {
+        new ApiApi().apiSupermarketRetrieve({id: useUserPreferenceStore().deviceSettings.shopping_selected_supermarket.id!}).then(r => {
+            useUserPreferenceStore().deviceSettings.shopping_selected_supermarket = r
+        })
+    }
 })
 
 /**
@@ -221,7 +244,7 @@ function addIngredient() {
             amount: Math.max(r.amount, 1),
             unit: (r.unit != null) ? {name: r.unit} as Unit : null,
             food: {name: r.food} as Food,
-        } as ShoppingListEntry)
+        } as ShoppingListEntry, true)
         ingredientInput.value = ''
 
         ingredientInputIcon.value = 'fa-solid fa-check'
diff --git a/vue3/src/openapi/.openapi-generator/FILES b/vue3/src/openapi/.openapi-generator/FILES
index d180dc90c..ffc2e29b5 100644
--- a/vue3/src/openapi/.openapi-generator/FILES
+++ b/vue3/src/openapi/.openapi-generator/FILES
@@ -7,6 +7,8 @@ models/AccessToken.ts
 models/AuthToken.ts
 models/AutoMealPlan.ts
 models/Automation.ts
+models/AutomationTypeEnum.ts
+models/BaseUnitEnum.ts
 models/BookmarkletImport.ts
 models/BookmarkletImportList.ts
 models/ConnectorConfigConfig.ts
@@ -32,6 +34,16 @@ models/MealPlan.ts
 models/MealType.ts
 models/MethodEnum.ts
 models/NutritionInformation.ts
+models/OpenDataCategory.ts
+models/OpenDataConversion.ts
+models/OpenDataFood.ts
+models/OpenDataFoodProperty.ts
+models/OpenDataProperty.ts
+models/OpenDataStore.ts
+models/OpenDataStoreCategory.ts
+models/OpenDataUnit.ts
+models/OpenDataUnitTypeEnum.ts
+models/OpenDataVersion.ts
 models/PaginatedAutomationList.ts
 models/PaginatedBookmarkletImportListList.ts
 models/PaginatedCookLogList.ts
@@ -78,6 +90,13 @@ models/PatchedInviteLink.ts
 models/PatchedKeyword.ts
 models/PatchedMealPlan.ts
 models/PatchedMealType.ts
+models/PatchedOpenDataCategory.ts
+models/PatchedOpenDataConversion.ts
+models/PatchedOpenDataFood.ts
+models/PatchedOpenDataProperty.ts
+models/PatchedOpenDataStore.ts
+models/PatchedOpenDataUnit.ts
+models/PatchedOpenDataVersion.ts
 models/PatchedProperty.ts
 models/PatchedPropertyType.ts
 models/PatchedRecipe.ts
@@ -124,7 +143,6 @@ models/SupermarketCategoryRelation.ts
 models/Sync.ts
 models/SyncLog.ts
 models/ThemeEnum.ts
-models/TypeEnum.ts
 models/Unit.ts
 models/UnitConversion.ts
 models/User.ts
diff --git a/vue3/src/openapi/apis/ApiApi.ts b/vue3/src/openapi/apis/ApiApi.ts
index 921b93506..99df18422 100644
--- a/vue3/src/openapi/apis/ApiApi.ts
+++ b/vue3/src/openapi/apis/ApiApi.ts
@@ -36,6 +36,13 @@ import type {
   Localization,
   MealPlan,
   MealType,
+  OpenDataCategory,
+  OpenDataConversion,
+  OpenDataFood,
+  OpenDataProperty,
+  OpenDataStore,
+  OpenDataUnit,
+  OpenDataVersion,
   PaginatedAutomationList,
   PaginatedBookmarkletImportListList,
   PaginatedCookLogList,
@@ -82,6 +89,13 @@ import type {
   PatchedKeyword,
   PatchedMealPlan,
   PatchedMealType,
+  PatchedOpenDataCategory,
+  PatchedOpenDataConversion,
+  PatchedOpenDataFood,
+  PatchedOpenDataProperty,
+  PatchedOpenDataStore,
+  PatchedOpenDataUnit,
+  PatchedOpenDataVersion,
   PatchedProperty,
   PatchedPropertyType,
   PatchedRecipe,
@@ -175,6 +189,20 @@ import {
     MealPlanToJSON,
     MealTypeFromJSON,
     MealTypeToJSON,
+    OpenDataCategoryFromJSON,
+    OpenDataCategoryToJSON,
+    OpenDataConversionFromJSON,
+    OpenDataConversionToJSON,
+    OpenDataFoodFromJSON,
+    OpenDataFoodToJSON,
+    OpenDataPropertyFromJSON,
+    OpenDataPropertyToJSON,
+    OpenDataStoreFromJSON,
+    OpenDataStoreToJSON,
+    OpenDataUnitFromJSON,
+    OpenDataUnitToJSON,
+    OpenDataVersionFromJSON,
+    OpenDataVersionToJSON,
     PaginatedAutomationListFromJSON,
     PaginatedAutomationListToJSON,
     PaginatedBookmarkletImportListListFromJSON,
@@ -267,6 +295,20 @@ import {
     PatchedMealPlanToJSON,
     PatchedMealTypeFromJSON,
     PatchedMealTypeToJSON,
+    PatchedOpenDataCategoryFromJSON,
+    PatchedOpenDataCategoryToJSON,
+    PatchedOpenDataConversionFromJSON,
+    PatchedOpenDataConversionToJSON,
+    PatchedOpenDataFoodFromJSON,
+    PatchedOpenDataFoodToJSON,
+    PatchedOpenDataPropertyFromJSON,
+    PatchedOpenDataPropertyToJSON,
+    PatchedOpenDataStoreFromJSON,
+    PatchedOpenDataStoreToJSON,
+    PatchedOpenDataUnitFromJSON,
+    PatchedOpenDataUnitToJSON,
+    PatchedOpenDataVersionFromJSON,
+    PatchedOpenDataVersionToJSON,
     PatchedPropertyFromJSON,
     PatchedPropertyToJSON,
     PatchedPropertyTypeFromJSON,
@@ -836,6 +878,164 @@ export interface ApiMealTypeUpdateRequest {
     mealType: Omit<MealType, 'created_by'>;
 }
 
+export interface ApiOpenDataCategoryCreateRequest {
+    openDataCategory: Omit<OpenDataCategory, 'created_by'>;
+}
+
+export interface ApiOpenDataCategoryDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataCategoryPartialUpdateRequest {
+    id: number;
+    patchedOpenDataCategory?: Omit<PatchedOpenDataCategory, 'created_by'>;
+}
+
+export interface ApiOpenDataCategoryRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataCategoryUpdateRequest {
+    id: number;
+    openDataCategory: Omit<OpenDataCategory, 'created_by'>;
+}
+
+export interface ApiOpenDataConversionCreateRequest {
+    openDataConversion: Omit<OpenDataConversion, 'created_by'>;
+}
+
+export interface ApiOpenDataConversionDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataConversionPartialUpdateRequest {
+    id: number;
+    patchedOpenDataConversion?: Omit<PatchedOpenDataConversion, 'created_by'>;
+}
+
+export interface ApiOpenDataConversionRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataConversionUpdateRequest {
+    id: number;
+    openDataConversion: Omit<OpenDataConversion, 'created_by'>;
+}
+
+export interface ApiOpenDataFDCRetrieveRequest {
+    id: string;
+}
+
+export interface ApiOpenDataFoodCreateRequest {
+    openDataFood: Omit<OpenDataFood, 'created_by'>;
+}
+
+export interface ApiOpenDataFoodDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataFoodPartialUpdateRequest {
+    id: number;
+    patchedOpenDataFood?: Omit<PatchedOpenDataFood, 'created_by'>;
+}
+
+export interface ApiOpenDataFoodRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataFoodUpdateRequest {
+    id: number;
+    openDataFood: Omit<OpenDataFood, 'created_by'>;
+}
+
+export interface ApiOpenDataPropertyCreateRequest {
+    openDataProperty: Omit<OpenDataProperty, 'created_by'>;
+}
+
+export interface ApiOpenDataPropertyDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataPropertyPartialUpdateRequest {
+    id: number;
+    patchedOpenDataProperty?: Omit<PatchedOpenDataProperty, 'created_by'>;
+}
+
+export interface ApiOpenDataPropertyRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataPropertyUpdateRequest {
+    id: number;
+    openDataProperty: Omit<OpenDataProperty, 'created_by'>;
+}
+
+export interface ApiOpenDataStoreCreateRequest {
+    openDataStore: Omit<OpenDataStore, 'created_by'>;
+}
+
+export interface ApiOpenDataStoreDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataStorePartialUpdateRequest {
+    id: number;
+    patchedOpenDataStore?: Omit<PatchedOpenDataStore, 'created_by'>;
+}
+
+export interface ApiOpenDataStoreRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataStoreUpdateRequest {
+    id: number;
+    openDataStore: Omit<OpenDataStore, 'created_by'>;
+}
+
+export interface ApiOpenDataUnitCreateRequest {
+    openDataUnit: Omit<OpenDataUnit, 'created_by'>;
+}
+
+export interface ApiOpenDataUnitDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataUnitPartialUpdateRequest {
+    id: number;
+    patchedOpenDataUnit?: Omit<PatchedOpenDataUnit, 'created_by'>;
+}
+
+export interface ApiOpenDataUnitRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataUnitUpdateRequest {
+    id: number;
+    openDataUnit: Omit<OpenDataUnit, 'created_by'>;
+}
+
+export interface ApiOpenDataVersionCreateRequest {
+    openDataVersion: OpenDataVersion;
+}
+
+export interface ApiOpenDataVersionDestroyRequest {
+    id: number;
+}
+
+export interface ApiOpenDataVersionPartialUpdateRequest {
+    id: number;
+    patchedOpenDataVersion?: PatchedOpenDataVersion;
+}
+
+export interface ApiOpenDataVersionRetrieveRequest {
+    id: number;
+}
+
+export interface ApiOpenDataVersionUpdateRequest {
+    id: number;
+    openDataVersion: OpenDataVersion;
+}
+
 export interface ApiPropertyCreateRequest {
     property: Property;
 }
@@ -5686,6 +5886,1593 @@ export class ApiApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     */
+    async apiOpenDataCategoryCreateRaw(requestParameters: ApiOpenDataCategoryCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
+        if (requestParameters['openDataCategory'] == null) {
+            throw new runtime.RequiredError(
+                'openDataCategory',
+                'Required parameter "openDataCategory" was null or undefined when calling apiOpenDataCategoryCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-category/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataCategoryToJSON(requestParameters['openDataCategory']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataCategoryFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryCreate(requestParameters: ApiOpenDataCategoryCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
+        const response = await this.apiOpenDataCategoryCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryDestroyRaw(requestParameters: ApiOpenDataCategoryDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataCategoryDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryDestroy(requestParameters: ApiOpenDataCategoryDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataCategoryDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataCategory>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-category/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataCategoryFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataCategory>> {
+        const response = await this.apiOpenDataCategoryListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryPartialUpdateRaw(requestParameters: ApiOpenDataCategoryPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataCategoryPartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataCategoryToJSON(requestParameters['patchedOpenDataCategory']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataCategoryFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryPartialUpdate(requestParameters: ApiOpenDataCategoryPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
+        const response = await this.apiOpenDataCategoryPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryRetrieveRaw(requestParameters: ApiOpenDataCategoryRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataCategoryRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataCategoryFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryRetrieve(requestParameters: ApiOpenDataCategoryRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
+        const response = await this.apiOpenDataCategoryRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryUpdateRaw(requestParameters: ApiOpenDataCategoryUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataCategoryUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataCategory'] == null) {
+            throw new runtime.RequiredError(
+                'openDataCategory',
+                'Required parameter "openDataCategory" was null or undefined when calling apiOpenDataCategoryUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataCategoryToJSON(requestParameters['openDataCategory']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataCategoryFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataCategoryUpdate(requestParameters: ApiOpenDataCategoryUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
+        const response = await this.apiOpenDataCategoryUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataConversionCreateRaw(requestParameters: ApiOpenDataConversionCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
+        if (requestParameters['openDataConversion'] == null) {
+            throw new runtime.RequiredError(
+                'openDataConversion',
+                'Required parameter "openDataConversion" was null or undefined when calling apiOpenDataConversionCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-conversion/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataConversionToJSON(requestParameters['openDataConversion']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataConversionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataConversionCreate(requestParameters: ApiOpenDataConversionCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
+        const response = await this.apiOpenDataConversionCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataConversionDestroyRaw(requestParameters: ApiOpenDataConversionDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataConversionDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataConversionDestroy(requestParameters: ApiOpenDataConversionDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataConversionDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataConversionListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataConversion>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-conversion/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataConversionFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataConversionList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataConversion>> {
+        const response = await this.apiOpenDataConversionListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataConversionPartialUpdateRaw(requestParameters: ApiOpenDataConversionPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataConversionPartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataConversionToJSON(requestParameters['patchedOpenDataConversion']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataConversionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataConversionPartialUpdate(requestParameters: ApiOpenDataConversionPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
+        const response = await this.apiOpenDataConversionPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataConversionRetrieveRaw(requestParameters: ApiOpenDataConversionRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataConversionRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataConversionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataConversionRetrieve(requestParameters: ApiOpenDataConversionRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
+        const response = await this.apiOpenDataConversionRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataConversionUpdateRaw(requestParameters: ApiOpenDataConversionUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataConversionUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataConversion'] == null) {
+            throw new runtime.RequiredError(
+                'openDataConversion',
+                'Required parameter "openDataConversion" was null or undefined when calling apiOpenDataConversionUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataConversionToJSON(requestParameters['openDataConversion']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataConversionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataConversionUpdate(requestParameters: ApiOpenDataConversionUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
+        const response = await this.apiOpenDataConversionUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataFDCRetrieveRaw(requestParameters: ApiOpenDataFDCRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataFDCRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-FDC/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataFDCRetrieve(requestParameters: ApiOpenDataFDCRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataFDCRetrieveRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataFoodCreateRaw(requestParameters: ApiOpenDataFoodCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
+        if (requestParameters['openDataFood'] == null) {
+            throw new runtime.RequiredError(
+                'openDataFood',
+                'Required parameter "openDataFood" was null or undefined when calling apiOpenDataFoodCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-food/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataFoodToJSON(requestParameters['openDataFood']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataFoodFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataFoodCreate(requestParameters: ApiOpenDataFoodCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
+        const response = await this.apiOpenDataFoodCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataFoodDestroyRaw(requestParameters: ApiOpenDataFoodDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataFoodDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataFoodDestroy(requestParameters: ApiOpenDataFoodDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataFoodDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataFoodListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataFood>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-food/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataFoodFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataFoodList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataFood>> {
+        const response = await this.apiOpenDataFoodListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataFoodPartialUpdateRaw(requestParameters: ApiOpenDataFoodPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataFoodPartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataFoodToJSON(requestParameters['patchedOpenDataFood']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataFoodFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataFoodPartialUpdate(requestParameters: ApiOpenDataFoodPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
+        const response = await this.apiOpenDataFoodPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataFoodRetrieveRaw(requestParameters: ApiOpenDataFoodRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataFoodRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataFoodFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataFoodRetrieve(requestParameters: ApiOpenDataFoodRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
+        const response = await this.apiOpenDataFoodRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataFoodUpdateRaw(requestParameters: ApiOpenDataFoodUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataFoodUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataFood'] == null) {
+            throw new runtime.RequiredError(
+                'openDataFood',
+                'Required parameter "openDataFood" was null or undefined when calling apiOpenDataFoodUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataFoodToJSON(requestParameters['openDataFood']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataFoodFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataFoodUpdate(requestParameters: ApiOpenDataFoodUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
+        const response = await this.apiOpenDataFoodUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyCreateRaw(requestParameters: ApiOpenDataPropertyCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
+        if (requestParameters['openDataProperty'] == null) {
+            throw new runtime.RequiredError(
+                'openDataProperty',
+                'Required parameter "openDataProperty" was null or undefined when calling apiOpenDataPropertyCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-property/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataPropertyToJSON(requestParameters['openDataProperty']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataPropertyFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyCreate(requestParameters: ApiOpenDataPropertyCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
+        const response = await this.apiOpenDataPropertyCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyDestroyRaw(requestParameters: ApiOpenDataPropertyDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataPropertyDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyDestroy(requestParameters: ApiOpenDataPropertyDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataPropertyDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataProperty>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-property/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataPropertyFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataProperty>> {
+        const response = await this.apiOpenDataPropertyListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyPartialUpdateRaw(requestParameters: ApiOpenDataPropertyPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataPropertyPartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataPropertyToJSON(requestParameters['patchedOpenDataProperty']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataPropertyFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyPartialUpdate(requestParameters: ApiOpenDataPropertyPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
+        const response = await this.apiOpenDataPropertyPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyRetrieveRaw(requestParameters: ApiOpenDataPropertyRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataPropertyRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataPropertyFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyRetrieve(requestParameters: ApiOpenDataPropertyRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
+        const response = await this.apiOpenDataPropertyRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyUpdateRaw(requestParameters: ApiOpenDataPropertyUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataPropertyUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataProperty'] == null) {
+            throw new runtime.RequiredError(
+                'openDataProperty',
+                'Required parameter "openDataProperty" was null or undefined when calling apiOpenDataPropertyUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataPropertyToJSON(requestParameters['openDataProperty']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataPropertyFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataPropertyUpdate(requestParameters: ApiOpenDataPropertyUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
+        const response = await this.apiOpenDataPropertyUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataStatsRetrieveRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-stats/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataStatsRetrieve(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataStatsRetrieveRaw(initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataStoreCreateRaw(requestParameters: ApiOpenDataStoreCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
+        if (requestParameters['openDataStore'] == null) {
+            throw new runtime.RequiredError(
+                'openDataStore',
+                'Required parameter "openDataStore" was null or undefined when calling apiOpenDataStoreCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-store/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataStoreToJSON(requestParameters['openDataStore']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataStoreFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataStoreCreate(requestParameters: ApiOpenDataStoreCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
+        const response = await this.apiOpenDataStoreCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataStoreDestroyRaw(requestParameters: ApiOpenDataStoreDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataStoreDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-store/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataStoreDestroy(requestParameters: ApiOpenDataStoreDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataStoreDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataStoreListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataStore>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-store/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataStoreFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataStoreList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataStore>> {
+        const response = await this.apiOpenDataStoreListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataStorePartialUpdateRaw(requestParameters: ApiOpenDataStorePartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataStorePartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-store/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataStoreToJSON(requestParameters['patchedOpenDataStore']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataStoreFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataStorePartialUpdate(requestParameters: ApiOpenDataStorePartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
+        const response = await this.apiOpenDataStorePartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataStoreRetrieveRaw(requestParameters: ApiOpenDataStoreRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataStoreRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-store/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataStoreFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataStoreRetrieve(requestParameters: ApiOpenDataStoreRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
+        const response = await this.apiOpenDataStoreRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataStoreUpdateRaw(requestParameters: ApiOpenDataStoreUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataStoreUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataStore'] == null) {
+            throw new runtime.RequiredError(
+                'openDataStore',
+                'Required parameter "openDataStore" was null or undefined when calling apiOpenDataStoreUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-store/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataStoreToJSON(requestParameters['openDataStore']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataStoreFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataStoreUpdate(requestParameters: ApiOpenDataStoreUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
+        const response = await this.apiOpenDataStoreUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataUnitCreateRaw(requestParameters: ApiOpenDataUnitCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
+        if (requestParameters['openDataUnit'] == null) {
+            throw new runtime.RequiredError(
+                'openDataUnit',
+                'Required parameter "openDataUnit" was null or undefined when calling apiOpenDataUnitCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-unit/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataUnitToJSON(requestParameters['openDataUnit']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataUnitFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataUnitCreate(requestParameters: ApiOpenDataUnitCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
+        const response = await this.apiOpenDataUnitCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataUnitDestroyRaw(requestParameters: ApiOpenDataUnitDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataUnitDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataUnitDestroy(requestParameters: ApiOpenDataUnitDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataUnitDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataUnitListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataUnit>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-unit/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataUnitFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataUnitList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataUnit>> {
+        const response = await this.apiOpenDataUnitListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataUnitPartialUpdateRaw(requestParameters: ApiOpenDataUnitPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataUnitPartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataUnitToJSON(requestParameters['patchedOpenDataUnit']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataUnitFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataUnitPartialUpdate(requestParameters: ApiOpenDataUnitPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
+        const response = await this.apiOpenDataUnitPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataUnitRetrieveRaw(requestParameters: ApiOpenDataUnitRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataUnitRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataUnitFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataUnitRetrieve(requestParameters: ApiOpenDataUnitRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
+        const response = await this.apiOpenDataUnitRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataUnitUpdateRaw(requestParameters: ApiOpenDataUnitUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataUnitUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataUnit'] == null) {
+            throw new runtime.RequiredError(
+                'openDataUnit',
+                'Required parameter "openDataUnit" was null or undefined when calling apiOpenDataUnitUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataUnitToJSON(requestParameters['openDataUnit']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataUnitFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataUnitUpdate(requestParameters: ApiOpenDataUnitUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
+        const response = await this.apiOpenDataUnitUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataVersionCreateRaw(requestParameters: ApiOpenDataVersionCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
+        if (requestParameters['openDataVersion'] == null) {
+            throw new runtime.RequiredError(
+                'openDataVersion',
+                'Required parameter "openDataVersion" was null or undefined when calling apiOpenDataVersionCreate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-version/`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataVersionToJSON(requestParameters['openDataVersion']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataVersionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataVersionCreate(requestParameters: ApiOpenDataVersionCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
+        const response = await this.apiOpenDataVersionCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataVersionDestroyRaw(requestParameters: ApiOpenDataVersionDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataVersionDestroy().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-version/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     */
+    async apiOpenDataVersionDestroy(requestParameters: ApiOpenDataVersionDestroyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.apiOpenDataVersionDestroyRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     */
+    async apiOpenDataVersionListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataVersion>>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-version/`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataVersionFromJSON));
+    }
+
+    /**
+     */
+    async apiOpenDataVersionList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataVersion>> {
+        const response = await this.apiOpenDataVersionListRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataVersionPartialUpdateRaw(requestParameters: ApiOpenDataVersionPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataVersionPartialUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-version/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PatchedOpenDataVersionToJSON(requestParameters['patchedOpenDataVersion']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataVersionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataVersionPartialUpdate(requestParameters: ApiOpenDataVersionPartialUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
+        const response = await this.apiOpenDataVersionPartialUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataVersionRetrieveRaw(requestParameters: ApiOpenDataVersionRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataVersionRetrieve().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-version/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataVersionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataVersionRetrieve(requestParameters: ApiOpenDataVersionRetrieveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
+        const response = await this.apiOpenDataVersionRetrieveRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataVersionUpdateRaw(requestParameters: ApiOpenDataVersionUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling apiOpenDataVersionUpdate().'
+            );
+        }
+
+        if (requestParameters['openDataVersion'] == null) {
+            throw new runtime.RequiredError(
+                'openDataVersion',
+                'Required parameter "openDataVersion" was null or undefined when calling apiOpenDataVersionUpdate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
+        }
+
+        const response = await this.request({
+            path: `/api/open-data-version/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataVersionToJSON(requestParameters['openDataVersion']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataVersionFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async apiOpenDataVersionUpdate(requestParameters: ApiOpenDataVersionUpdateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
+        const response = await this.apiOpenDataVersionUpdateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * logs request counts to redis cache total/per user/
      */
diff --git a/vue3/src/openapi/models/AccessToken.ts b/vue3/src/openapi/models/AccessToken.ts
index 865f19a70..5de40a500 100644
--- a/vue3/src/openapi/models/AccessToken.ts
+++ b/vue3/src/openapi/models/AccessToken.ts
@@ -87,10 +87,15 @@ export function AccessTokenFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function AccessTokenToJSON(value?: Omit<AccessToken, 'token'|'created'|'updated'> | null): any {
+export function AccessTokenToJSON(json: any): AccessToken {
+    return AccessTokenToJSONTyped(json, false);
+}
+
+export function AccessTokenToJSONTyped(value?: Omit<AccessToken, 'token'|'created'|'updated'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -98,15 +103,4 @@ export function AccessTokenToJSON(value?: Omit<AccessToken, 'token'|'created'|'u
         'scope': value['scope'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiAccessTokenListRequest, PaginatedAccessTokenList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiAccessTokenListRequest = {}): Promise<PaginatedAccessTokenList> {
-    const api = new ApiApi()
-    return api.apiAccessTokenList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/AuthToken.ts b/vue3/src/openapi/models/AuthToken.ts
index 1dfad6f1b..27a3b3eee 100644
--- a/vue3/src/openapi/models/AuthToken.ts
+++ b/vue3/src/openapi/models/AuthToken.ts
@@ -65,25 +65,19 @@ export function AuthTokenFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function AuthTokenToJSON(value?: Omit<AuthToken, 'token'> | null): any {
+export function AuthTokenToJSON(json: any): AuthToken {
+    return AuthTokenToJSONTyped(json, false);
+}
+
+export function AuthTokenToJSONTyped(value?: Omit<AuthToken, 'token'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'username': value['username'],
         'password': value['password'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiAuthTokenListRequest, PaginatedAuthTokenList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiAuthTokenListRequest = {}): Promise<PaginatedAuthTokenList> {
-    const api = new ApiApi()
-    return api.apiAuthTokenList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/AutoMealPlan.ts b/vue3/src/openapi/models/AutoMealPlan.ts
index 4e45145f5..3a953f50d 100644
--- a/vue3/src/openapi/models/AutoMealPlan.ts
+++ b/vue3/src/openapi/models/AutoMealPlan.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -103,10 +104,15 @@ export function AutoMealPlanFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function AutoMealPlanToJSON(value?: AutoMealPlan | null): any {
+export function AutoMealPlanToJSON(json: any): AutoMealPlan {
+    return AutoMealPlanToJSONTyped(json, false);
+}
+
+export function AutoMealPlanToJSONTyped(value?: AutoMealPlan | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'start_date': ((value['startDate']).toISOString().substring(0,10)),
@@ -118,15 +124,4 @@ export function AutoMealPlanToJSON(value?: AutoMealPlan | null): any {
         'addshopping': value['addshopping'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiAutoMealPlanListRequest, PaginatedAutoMealPlanList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiAutoMealPlanListRequest = {}): Promise<PaginatedAutoMealPlanList> {
-    const api = new ApiApi()
-    return api.apiAutoMealPlanList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Automation.ts b/vue3/src/openapi/models/Automation.ts
index 5c0dfd8f2..019419723 100644
--- a/vue3/src/openapi/models/Automation.ts
+++ b/vue3/src/openapi/models/Automation.ts
@@ -13,12 +13,13 @@
  */
 
 import { mapValues } from '../runtime';
-import type { TypeEnum } from './TypeEnum';
+import type { AutomationTypeEnum } from './AutomationTypeEnum';
 import {
-    TypeEnumFromJSON,
-    TypeEnumFromJSONTyped,
-    TypeEnumToJSON,
-} from './TypeEnum';
+    AutomationTypeEnumFromJSON,
+    AutomationTypeEnumFromJSONTyped,
+    AutomationTypeEnumToJSON,
+    AutomationTypeEnumToJSONTyped,
+} from './AutomationTypeEnum';
 
 /**
  * 
@@ -34,10 +35,10 @@ export interface Automation {
     id?: number;
     /**
      * 
-     * @type {TypeEnum}
+     * @type {AutomationTypeEnum}
      * @memberof Automation
      */
-    type: TypeEnum;
+    type: AutomationTypeEnum;
     /**
      * 
      * @type {string}
@@ -110,7 +111,7 @@ export function AutomationFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     return {
         
         'id': json['id'] == null ? undefined : json['id'],
-        'type': TypeEnumFromJSON(json['type']),
+        'type': AutomationTypeEnumFromJSON(json['type']),
         'name': json['name'] == null ? undefined : json['name'],
         'description': json['description'] == null ? undefined : json['description'],
         'param1': json['param_1'] == null ? undefined : json['param_1'],
@@ -122,14 +123,19 @@ export function AutomationFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     };
 }
 
-export function AutomationToJSON(value?: Omit<Automation, 'created_by'> | null): any {
+export function AutomationToJSON(json: any): Automation {
+    return AutomationToJSONTyped(json, false);
+}
+
+export function AutomationToJSONTyped(value?: Omit<Automation, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
-        'type': TypeEnumToJSON(value['type']),
+        'type': AutomationTypeEnumToJSON(value['type']),
         'name': value['name'],
         'description': value['description'],
         'param_1': value['param1'],
@@ -139,15 +145,4 @@ export function AutomationToJSON(value?: Omit<Automation, 'created_by'> | null):
         'disabled': value['disabled'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiAutomationListRequest, PaginatedAutomationList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiAutomationListRequest = {}): Promise<PaginatedAutomationList> {
-    const api = new ApiApi()
-    return api.apiAutomationList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/BookmarkletImport.ts b/vue3/src/openapi/models/BookmarkletImport.ts
index 955262e0e..5453478cd 100644
--- a/vue3/src/openapi/models/BookmarkletImport.ts
+++ b/vue3/src/openapi/models/BookmarkletImport.ts
@@ -79,10 +79,15 @@ export function BookmarkletImportFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function BookmarkletImportToJSON(value?: Omit<BookmarkletImport, 'created_by'|'created_at'> | null): any {
+export function BookmarkletImportToJSON(json: any): BookmarkletImport {
+    return BookmarkletImportToJSONTyped(json, false);
+}
+
+export function BookmarkletImportToJSONTyped(value?: Omit<BookmarkletImport, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -90,15 +95,4 @@ export function BookmarkletImportToJSON(value?: Omit<BookmarkletImport, 'created
         'html': value['html'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiBookmarkletImportListRequest, PaginatedBookmarkletImportList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiBookmarkletImportListRequest = {}): Promise<PaginatedBookmarkletImportList> {
-    const api = new ApiApi()
-    return api.apiBookmarkletImportList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/BookmarkletImportList.ts b/vue3/src/openapi/models/BookmarkletImportList.ts
index 2791d0ec7..b4d968c2e 100644
--- a/vue3/src/openapi/models/BookmarkletImportList.ts
+++ b/vue3/src/openapi/models/BookmarkletImportList.ts
@@ -71,25 +71,19 @@ export function BookmarkletImportListFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function BookmarkletImportListToJSON(value?: Omit<BookmarkletImportList, 'created_by'|'created_at'> | null): any {
+export function BookmarkletImportListToJSON(json: any): BookmarkletImportList {
+    return BookmarkletImportListToJSONTyped(json, false);
+}
+
+export function BookmarkletImportListToJSONTyped(value?: Omit<BookmarkletImportList, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
         'url': value['url'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiBookmarkletImportListListRequest, PaginatedBookmarkletImportListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiBookmarkletImportListListRequest = {}): Promise<PaginatedBookmarkletImportListList> {
-    const api = new ApiApi()
-    return api.apiBookmarkletImportListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ConnectorConfigConfig.ts b/vue3/src/openapi/models/ConnectorConfigConfig.ts
index 139162d8f..c0ecb9f9e 100644
--- a/vue3/src/openapi/models/ConnectorConfigConfig.ts
+++ b/vue3/src/openapi/models/ConnectorConfigConfig.ts
@@ -120,10 +120,15 @@ export function ConnectorConfigConfigFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function ConnectorConfigConfigToJSON(value?: Omit<ConnectorConfigConfig, 'created_by'> | null): any {
+export function ConnectorConfigConfigToJSON(json: any): ConnectorConfigConfig {
+    return ConnectorConfigConfigToJSONTyped(json, false);
+}
+
+export function ConnectorConfigConfigToJSONTyped(value?: Omit<ConnectorConfigConfig, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -138,15 +143,4 @@ export function ConnectorConfigConfigToJSON(value?: Omit<ConnectorConfigConfig,
         'supports_description_field': value['supportsDescriptionField'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiConnectorConfigConfigListRequest, PaginatedConnectorConfigConfigList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiConnectorConfigConfigListRequest = {}): Promise<PaginatedConnectorConfigConfigList> {
-    const api = new ApiApi()
-    return api.apiConnectorConfigConfigList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/CookLog.ts b/vue3/src/openapi/models/CookLog.ts
index 914f9bba9..3c562ef51 100644
--- a/vue3/src/openapi/models/CookLog.ts
+++ b/vue3/src/openapi/models/CookLog.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -107,10 +108,15 @@ export function CookLogFromJSONTyped(json: any, ignoreDiscriminator: boolean): C
     };
 }
 
-export function CookLogToJSON(value?: Omit<CookLog, 'created_by'|'updated_at'> | null): any {
+export function CookLogToJSON(json: any): CookLog {
+    return CookLogToJSONTyped(json, false);
+}
+
+export function CookLogToJSONTyped(value?: Omit<CookLog, 'created_by'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -121,15 +127,4 @@ export function CookLogToJSON(value?: Omit<CookLog, 'created_by'|'updated_at'> |
         'created_at': value['createdAt'] == null ? undefined : ((value['createdAt']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiCookLogListRequest, PaginatedCookLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiCookLogListRequest = {}): Promise<PaginatedCookLogList> {
-    const api = new ApiApi()
-    return api.apiCookLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/CustomFilter.ts b/vue3/src/openapi/models/CustomFilter.ts
index fed2d097f..fd48218a8 100644
--- a/vue3/src/openapi/models/CustomFilter.ts
+++ b/vue3/src/openapi/models/CustomFilter.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -86,10 +87,15 @@ export function CustomFilterFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function CustomFilterToJSON(value?: Omit<CustomFilter, 'created_by'> | null): any {
+export function CustomFilterToJSON(json: any): CustomFilter {
+    return CustomFilterToJSONTyped(json, false);
+}
+
+export function CustomFilterToJSONTyped(value?: Omit<CustomFilter, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -98,15 +104,4 @@ export function CustomFilterToJSON(value?: Omit<CustomFilter, 'created_by'> | nu
         'shared': value['shared'] == null ? undefined : ((value['shared'] as Array<any>).map(UserToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiCustomFilterListRequest, PaginatedCustomFilterList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiCustomFilterListRequest = {}): Promise<PaginatedCustomFilterList> {
-    const api = new ApiApi()
-    return api.apiCustomFilterList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ExportLog.ts b/vue3/src/openapi/models/ExportLog.ts
index 6e914fde0..c996651f2 100644
--- a/vue3/src/openapi/models/ExportLog.ts
+++ b/vue3/src/openapi/models/ExportLog.ts
@@ -114,10 +114,15 @@ export function ExportLogFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function ExportLogToJSON(value?: Omit<ExportLog, 'created_by'|'created_at'> | null): any {
+export function ExportLogToJSON(json: any): ExportLog {
+    return ExportLogToJSONTyped(json, false);
+}
+
+export function ExportLogToJSONTyped(value?: Omit<ExportLog, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -130,15 +135,4 @@ export function ExportLogToJSON(value?: Omit<ExportLog, 'created_by'|'created_at
         'possibly_not_expired': value['possiblyNotExpired'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiExportLogListRequest, PaginatedExportLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiExportLogListRequest = {}): Promise<PaginatedExportLogList> {
-    const api = new ApiApi()
-    return api.apiExportLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Food.ts b/vue3/src/openapi/models/Food.ts
index 06250a2f2..665d9af9f 100644
--- a/vue3/src/openapi/models/Food.ts
+++ b/vue3/src/openapi/models/Food.ts
@@ -18,36 +18,42 @@ import {
     SupermarketCategoryFromJSON,
     SupermarketCategoryFromJSONTyped,
     SupermarketCategoryToJSON,
+    SupermarketCategoryToJSONTyped,
 } from './SupermarketCategory';
 import type { Unit } from './Unit';
 import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Property } from './Property';
 import {
     PropertyFromJSON,
     PropertyFromJSONTyped,
     PropertyToJSON,
+    PropertyToJSONTyped,
 } from './Property';
 import type { FoodInheritField } from './FoodInheritField';
 import {
     FoodInheritFieldFromJSON,
     FoodInheritFieldFromJSONTyped,
     FoodInheritFieldToJSON,
+    FoodInheritFieldToJSONTyped,
 } from './FoodInheritField';
 import type { FoodSimple } from './FoodSimple';
 import {
     FoodSimpleFromJSON,
     FoodSimpleFromJSONTyped,
     FoodSimpleToJSON,
+    FoodSimpleToJSONTyped,
 } from './FoodSimple';
 import type { RecipeSimple } from './RecipeSimple';
 import {
     RecipeSimpleFromJSON,
     RecipeSimpleFromJSONTyped,
     RecipeSimpleToJSON,
+    RecipeSimpleToJSONTyped,
 } from './RecipeSimple';
 
 /**
@@ -287,10 +293,15 @@ export function FoodFromJSONTyped(json: any, ignoreDiscriminator: boolean): Food
     };
 }
 
-export function FoodToJSON(value?: Omit<Food, 'shopping'|'parent'|'numchild'|'full_name'|'substitute_onhand'> | null): any {
+export function FoodToJSON(json: any): Food {
+    return FoodToJSONTyped(json, false);
+}
+
+export function FoodToJSONTyped(value?: Omit<Food, 'shopping'|'parent'|'numchild'|'full_name'|'substitute_onhand'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -314,15 +325,4 @@ export function FoodToJSON(value?: Omit<Food, 'shopping'|'parent'|'numchild'|'fu
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiFoodListRequest, PaginatedFoodList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiFoodListRequest = {}): Promise<PaginatedFoodList> {
-    const api = new ApiApi()
-    return api.apiFoodList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/FoodInheritField.ts b/vue3/src/openapi/models/FoodInheritField.ts
index 1bf3b2e2a..7a9280861 100644
--- a/vue3/src/openapi/models/FoodInheritField.ts
+++ b/vue3/src/openapi/models/FoodInheritField.ts
@@ -96,10 +96,15 @@ export function FoodInheritFieldFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function FoodInheritFieldToJSON(value?: FoodInheritField | null): any {
+export function FoodInheritFieldToJSON(json: any): FoodInheritField {
+    return FoodInheritFieldToJSONTyped(json, false);
+}
+
+export function FoodInheritFieldToJSONTyped(value?: FoodInheritField | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -107,15 +112,4 @@ export function FoodInheritFieldToJSON(value?: FoodInheritField | null): any {
         'field': value['field'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiFoodInheritFieldListRequest, PaginatedFoodInheritFieldList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiFoodInheritFieldListRequest = {}): Promise<PaginatedFoodInheritFieldList> {
-    const api = new ApiApi()
-    return api.apiFoodInheritFieldList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/FoodShoppingUpdate.ts b/vue3/src/openapi/models/FoodShoppingUpdate.ts
index 0d3852e2d..32c1f9382 100644
--- a/vue3/src/openapi/models/FoodShoppingUpdate.ts
+++ b/vue3/src/openapi/models/FoodShoppingUpdate.ts
@@ -18,6 +18,7 @@ import {
     DeleteEnumFromJSON,
     DeleteEnumFromJSONTyped,
     DeleteEnumToJSON,
+    DeleteEnumToJSONTyped,
 } from './DeleteEnum';
 
 /**
@@ -81,10 +82,15 @@ export function FoodShoppingUpdateFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function FoodShoppingUpdateToJSON(value?: FoodShoppingUpdate | null): any {
+export function FoodShoppingUpdateToJSON(json: any): FoodShoppingUpdate {
+    return FoodShoppingUpdateToJSONTyped(json, false);
+}
+
+export function FoodShoppingUpdateToJSONTyped(value?: FoodShoppingUpdate | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -93,15 +99,4 @@ export function FoodShoppingUpdateToJSON(value?: FoodShoppingUpdate | null): any
         'delete': DeleteEnumToJSON(value['_delete']),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiFoodShoppingUpdateListRequest, PaginatedFoodShoppingUpdateList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiFoodShoppingUpdateListRequest = {}): Promise<PaginatedFoodShoppingUpdateList> {
-    const api = new ApiApi()
-    return api.apiFoodShoppingUpdateList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/FoodSimple.ts b/vue3/src/openapi/models/FoodSimple.ts
index 24d5d8ac4..c25ab4055 100644
--- a/vue3/src/openapi/models/FoodSimple.ts
+++ b/vue3/src/openapi/models/FoodSimple.ts
@@ -63,10 +63,15 @@ export function FoodSimpleFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     };
 }
 
-export function FoodSimpleToJSON(value?: FoodSimple | null): any {
+export function FoodSimpleToJSON(json: any): FoodSimple {
+    return FoodSimpleToJSONTyped(json, false);
+}
+
+export function FoodSimpleToJSONTyped(value?: FoodSimple | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -74,15 +79,4 @@ export function FoodSimpleToJSON(value?: FoodSimple | null): any {
         'plural_name': value['pluralName'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiFoodSimpleListRequest, PaginatedFoodSimpleList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiFoodSimpleListRequest = {}): Promise<PaginatedFoodSimpleList> {
-    const api = new ApiApi()
-    return api.apiFoodSimpleList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Group.ts b/vue3/src/openapi/models/Group.ts
index da190cea5..73a0e7af3 100644
--- a/vue3/src/openapi/models/Group.ts
+++ b/vue3/src/openapi/models/Group.ts
@@ -90,25 +90,19 @@ export function GroupFromJSONTyped(json: any, ignoreDiscriminator: boolean): Gro
     };
 }
 
-export function GroupToJSON(value?: Group | null): any {
+export function GroupToJSON(json: any): Group {
+    return GroupToJSONTyped(json, false);
+}
+
+export function GroupToJSONTyped(value?: Group | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
         'name': value['name'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiGroupListRequest, PaginatedGroupList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiGroupListRequest = {}): Promise<PaginatedGroupList> {
-    const api = new ApiApi()
-    return api.apiGroupList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ImportImage.ts b/vue3/src/openapi/models/ImportImage.ts
index d271c6083..c6a776ac9 100644
--- a/vue3/src/openapi/models/ImportImage.ts
+++ b/vue3/src/openapi/models/ImportImage.ts
@@ -49,24 +49,18 @@ export function ImportImageFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function ImportImageToJSON(value?: ImportImage | null): any {
+export function ImportImageToJSON(json: any): ImportImage {
+    return ImportImageToJSONTyped(json, false);
+}
+
+export function ImportImageToJSONTyped(value?: ImportImage | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'image': value['image'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiImportImageListRequest, PaginatedImportImageList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiImportImageListRequest = {}): Promise<PaginatedImportImageList> {
-    const api = new ApiApi()
-    return api.apiImportImageList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ImportLog.ts b/vue3/src/openapi/models/ImportLog.ts
index f01eadc51..65f083364 100644
--- a/vue3/src/openapi/models/ImportLog.ts
+++ b/vue3/src/openapi/models/ImportLog.ts
@@ -18,6 +18,7 @@ import {
     KeywordFromJSON,
     KeywordFromJSONTyped,
     KeywordToJSON,
+    KeywordToJSONTyped,
 } from './Keyword';
 
 /**
@@ -115,10 +116,15 @@ export function ImportLogFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function ImportLogToJSON(value?: Omit<ImportLog, 'keyword'|'created_by'|'created_at'> | null): any {
+export function ImportLogToJSON(json: any): ImportLog {
+    return ImportLogToJSONTyped(json, false);
+}
+
+export function ImportLogToJSONTyped(value?: Omit<ImportLog, 'keyword'|'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -129,15 +135,4 @@ export function ImportLogToJSON(value?: Omit<ImportLog, 'keyword'|'created_by'|'
         'imported_recipes': value['importedRecipes'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiImportLogListRequest, PaginatedImportLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiImportLogListRequest = {}): Promise<PaginatedImportLogList> {
-    const api = new ApiApi()
-    return api.apiImportLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Ingredient.ts b/vue3/src/openapi/models/Ingredient.ts
index 9526303fc..40994230f 100644
--- a/vue3/src/openapi/models/Ingredient.ts
+++ b/vue3/src/openapi/models/Ingredient.ts
@@ -18,12 +18,14 @@ import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Food } from './Food';
 import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -150,10 +152,15 @@ export function IngredientFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     };
 }
 
-export function IngredientToJSON(value?: Omit<Ingredient, 'conversions'|'used_in_recipes'> | null): any {
+export function IngredientToJSON(json: any): Ingredient {
+    return IngredientToJSONTyped(json, false);
+}
+
+export function IngredientToJSONTyped(value?: Omit<Ingredient, 'conversions'|'used_in_recipes'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -169,15 +176,4 @@ export function IngredientToJSON(value?: Omit<Ingredient, 'conversions'|'used_in
         'always_use_plural_food': value['alwaysUsePluralFood'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiIngredientListRequest, PaginatedIngredientList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiIngredientListRequest = {}): Promise<PaginatedIngredientList> {
-    const api = new ApiApi()
-    return api.apiIngredientList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/IngredientString.ts b/vue3/src/openapi/models/IngredientString.ts
index 5cbe0e607..3e4a3c2e0 100644
--- a/vue3/src/openapi/models/IngredientString.ts
+++ b/vue3/src/openapi/models/IngredientString.ts
@@ -49,24 +49,18 @@ export function IngredientStringFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function IngredientStringToJSON(value?: IngredientString | null): any {
+export function IngredientStringToJSON(json: any): IngredientString {
+    return IngredientStringToJSONTyped(json, false);
+}
+
+export function IngredientStringToJSONTyped(value?: IngredientString | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'text': value['text'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiIngredientStringListRequest, PaginatedIngredientStringList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiIngredientStringListRequest = {}): Promise<PaginatedIngredientStringList> {
-    const api = new ApiApi()
-    return api.apiIngredientStringList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/InviteLink.ts b/vue3/src/openapi/models/InviteLink.ts
index c3a33d7bd..894fe2bb9 100644
--- a/vue3/src/openapi/models/InviteLink.ts
+++ b/vue3/src/openapi/models/InviteLink.ts
@@ -18,6 +18,7 @@ import {
     GroupFromJSON,
     GroupFromJSONTyped,
     GroupToJSON,
+    GroupToJSONTyped,
 } from './Group';
 
 /**
@@ -122,10 +123,15 @@ export function InviteLinkFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     };
 }
 
-export function InviteLinkToJSON(value?: Omit<InviteLink, 'uuid'|'created_by'|'created_at'> | null): any {
+export function InviteLinkToJSON(json: any): InviteLink {
+    return InviteLinkToJSONTyped(json, false);
+}
+
+export function InviteLinkToJSONTyped(value?: Omit<InviteLink, 'uuid'|'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -137,15 +143,4 @@ export function InviteLinkToJSON(value?: Omit<InviteLink, 'uuid'|'created_by'|'c
         'internal_note': value['internalNote'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiInviteLinkListRequest, PaginatedInviteLinkList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiInviteLinkListRequest = {}): Promise<PaginatedInviteLinkList> {
-    const api = new ApiApi()
-    return api.apiInviteLinkList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Keyword.ts b/vue3/src/openapi/models/Keyword.ts
index 520100ed8..d4336b2d0 100644
--- a/vue3/src/openapi/models/Keyword.ts
+++ b/vue3/src/openapi/models/Keyword.ts
@@ -146,10 +146,15 @@ export function KeywordFromJSONTyped(json: any, ignoreDiscriminator: boolean): K
     };
 }
 
-export function KeywordToJSON(value?: Omit<Keyword, 'label'|'parent'|'numchild'|'created_at'|'updated_at'|'full_name'> | null): any {
+export function KeywordToJSON(json: any): Keyword {
+    return KeywordToJSONTyped(json, false);
+}
+
+export function KeywordToJSONTyped(value?: Omit<Keyword, 'label'|'parent'|'numchild'|'created_at'|'updated_at'|'full_name'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -157,15 +162,4 @@ export function KeywordToJSON(value?: Omit<Keyword, 'label'|'parent'|'numchild'|
         'description': value['description'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiKeywordListRequest, PaginatedKeywordList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiKeywordListRequest = {}): Promise<PaginatedKeywordList> {
-    const api = new ApiApi()
-    return api.apiKeywordList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/KeywordLabel.ts b/vue3/src/openapi/models/KeywordLabel.ts
index 8cc89ea8b..cbde934b2 100644
--- a/vue3/src/openapi/models/KeywordLabel.ts
+++ b/vue3/src/openapi/models/KeywordLabel.ts
@@ -56,24 +56,18 @@ export function KeywordLabelFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function KeywordLabelToJSON(value?: Omit<KeywordLabel, 'label'> | null): any {
+export function KeywordLabelToJSON(json: any): KeywordLabel {
+    return KeywordLabelToJSONTyped(json, false);
+}
+
+export function KeywordLabelToJSONTyped(value?: Omit<KeywordLabel, 'label'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiKeywordLabelListRequest, PaginatedKeywordLabelList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiKeywordLabelListRequest = {}): Promise<PaginatedKeywordLabelList> {
-    const api = new ApiApi()
-    return api.apiKeywordLabelList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Localization.ts b/vue3/src/openapi/models/Localization.ts
index 1a758047a..128b8a36d 100644
--- a/vue3/src/openapi/models/Localization.ts
+++ b/vue3/src/openapi/models/Localization.ts
@@ -57,23 +57,17 @@ export function LocalizationFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function LocalizationToJSON(value?: Omit<Localization, 'code'|'language'> | null): any {
+export function LocalizationToJSON(json: any): Localization {
+    return LocalizationToJSONTyped(json, false);
+}
+
+export function LocalizationToJSONTyped(value?: Omit<Localization, 'code'|'language'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiLocalizationListRequest, PaginatedLocalizationList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiLocalizationListRequest = {}): Promise<PaginatedLocalizationList> {
-    const api = new ApiApi()
-    return api.apiLocalizationList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/MealPlan.ts b/vue3/src/openapi/models/MealPlan.ts
index 0570d26d2..da9b4f172 100644
--- a/vue3/src/openapi/models/MealPlan.ts
+++ b/vue3/src/openapi/models/MealPlan.ts
@@ -18,18 +18,21 @@ import {
     MealTypeFromJSON,
     MealTypeFromJSONTyped,
     MealTypeToJSON,
+    MealTypeToJSONTyped,
 } from './MealType';
 import type { User } from './User';
 import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { RecipeOverview } from './RecipeOverview';
 import {
     RecipeOverviewFromJSON,
     RecipeOverviewFromJSONTyped,
     RecipeOverviewToJSON,
+    RecipeOverviewToJSONTyped,
 } from './RecipeOverview';
 
 /**
@@ -166,10 +169,15 @@ export function MealPlanFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function MealPlanToJSON(value?: Omit<MealPlan, 'note_markdown'|'created_by'|'recipe_name'|'meal_type_name'|'shopping'> | null): any {
+export function MealPlanToJSON(json: any): MealPlan {
+    return MealPlanToJSONTyped(json, false);
+}
+
+export function MealPlanToJSONTyped(value?: Omit<MealPlan, 'note_markdown'|'created_by'|'recipe_name'|'meal_type_name'|'shopping'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -183,15 +191,4 @@ export function MealPlanToJSON(value?: Omit<MealPlan, 'note_markdown'|'created_b
         'shared': value['shared'] == null ? undefined : ((value['shared'] as Array<any>).map(UserToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiMealPlanListRequest, PaginatedMealPlanList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiMealPlanListRequest = {}): Promise<PaginatedMealPlanList> {
-    const api = new ApiApi()
-    return api.apiMealPlanList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/MealType.ts b/vue3/src/openapi/models/MealType.ts
index b0e791c6b..b44f1a9a9 100644
--- a/vue3/src/openapi/models/MealType.ts
+++ b/vue3/src/openapi/models/MealType.ts
@@ -92,10 +92,15 @@ export function MealTypeFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function MealTypeToJSON(value?: Omit<MealType, 'created_by'> | null): any {
+export function MealTypeToJSON(json: any): MealType {
+    return MealTypeToJSONTyped(json, false);
+}
+
+export function MealTypeToJSONTyped(value?: Omit<MealType, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -106,15 +111,4 @@ export function MealTypeToJSON(value?: Omit<MealType, 'created_by'> | null): any
         'default': value['_default'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiMealTypeListRequest, PaginatedMealTypeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiMealTypeListRequest = {}): Promise<PaginatedMealTypeList> {
-    const api = new ApiApi()
-    return api.apiMealTypeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/NutritionInformation.ts b/vue3/src/openapi/models/NutritionInformation.ts
index 2886f65c7..abaa2e40c 100644
--- a/vue3/src/openapi/models/NutritionInformation.ts
+++ b/vue3/src/openapi/models/NutritionInformation.ts
@@ -87,10 +87,15 @@ export function NutritionInformationFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function NutritionInformationToJSON(value?: NutritionInformation | null): any {
+export function NutritionInformationToJSON(json: any): NutritionInformation {
+    return NutritionInformationToJSONTyped(json, false);
+}
+
+export function NutritionInformationToJSONTyped(value?: NutritionInformation | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -101,15 +106,4 @@ export function NutritionInformationToJSON(value?: NutritionInformation | null):
         'source': value['source'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiNutritionInformationListRequest, PaginatedNutritionInformationList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiNutritionInformationListRequest = {}): Promise<PaginatedNutritionInformationList> {
-    const api = new ApiApi()
-    return api.apiNutritionInformationList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataCategory.ts b/vue3/src/openapi/models/OpenDataCategory.ts
index e7be0a72f..a46f3cfba 100644
--- a/vue3/src/openapi/models/OpenDataCategory.ts
+++ b/vue3/src/openapi/models/OpenDataCategory.ts
@@ -18,6 +18,7 @@ import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -135,10 +136,15 @@ export function OpenDataCategoryFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function OpenDataCategoryToJSON(value?: Omit<OpenDataCategory, 'created_by'> | null): any {
+export function OpenDataCategoryToJSON(json: any): OpenDataCategory {
+    return OpenDataCategoryToJSONTyped(json, false);
+}
+
+export function OpenDataCategoryToJSONTyped(value?: Omit<OpenDataCategory, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -149,15 +155,4 @@ export function OpenDataCategoryToJSON(value?: Omit<OpenDataCategory, 'created_b
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataCategoryListRequest, PaginatedOpenDataCategoryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataCategoryListRequest = {}): Promise<PaginatedOpenDataCategoryList> {
-    const api = new ApiApi()
-    return api.apiOpenDataCategoryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataConversion.ts b/vue3/src/openapi/models/OpenDataConversion.ts
index 878d84b72..22f4dc89e 100644
--- a/vue3/src/openapi/models/OpenDataConversion.ts
+++ b/vue3/src/openapi/models/OpenDataConversion.ts
@@ -18,18 +18,21 @@ import {
     OpenDataUnitFromJSON,
     OpenDataUnitFromJSONTyped,
     OpenDataUnitToJSON,
+    OpenDataUnitToJSONTyped,
 } from './OpenDataUnit';
 import type { OpenDataFood } from './OpenDataFood';
 import {
     OpenDataFoodFromJSON,
     OpenDataFoodFromJSONTyped,
     OpenDataFoodToJSON,
+    OpenDataFoodToJSONTyped,
 } from './OpenDataFood';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -146,10 +149,15 @@ export function OpenDataConversionFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function OpenDataConversionToJSON(value?: Omit<OpenDataConversion, 'created_by'> | null): any {
+export function OpenDataConversionToJSON(json: any): OpenDataConversion {
+    return OpenDataConversionToJSONTyped(json, false);
+}
+
+export function OpenDataConversionToJSONTyped(value?: Omit<OpenDataConversion, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -164,15 +172,4 @@ export function OpenDataConversionToJSON(value?: Omit<OpenDataConversion, 'creat
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataConversionListRequest, PaginatedOpenDataConversionList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataConversionListRequest = {}): Promise<PaginatedOpenDataConversionList> {
-    const api = new ApiApi()
-    return api.apiOpenDataConversionList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataFood.ts b/vue3/src/openapi/models/OpenDataFood.ts
index 74e1086c7..5c46f1619 100644
--- a/vue3/src/openapi/models/OpenDataFood.ts
+++ b/vue3/src/openapi/models/OpenDataFood.ts
@@ -18,24 +18,28 @@ import {
     OpenDataFoodPropertyFromJSON,
     OpenDataFoodPropertyFromJSONTyped,
     OpenDataFoodPropertyToJSON,
+    OpenDataFoodPropertyToJSONTyped,
 } from './OpenDataFoodProperty';
 import type { OpenDataUnit } from './OpenDataUnit';
 import {
     OpenDataUnitFromJSON,
     OpenDataUnitFromJSONTyped,
     OpenDataUnitToJSON,
+    OpenDataUnitToJSONTyped,
 } from './OpenDataUnit';
 import type { OpenDataCategory } from './OpenDataCategory';
 import {
     OpenDataCategoryFromJSON,
     OpenDataCategoryFromJSONTyped,
     OpenDataCategoryToJSON,
+    OpenDataCategoryToJSONTyped,
 } from './OpenDataCategory';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -228,10 +232,15 @@ export function OpenDataFoodFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function OpenDataFoodToJSON(value?: Omit<OpenDataFood, 'created_by'> | null): any {
+export function OpenDataFoodToJSON(json: any): OpenDataFood {
+    return OpenDataFoodToJSONTyped(json, false);
+}
+
+export function OpenDataFoodToJSONTyped(value?: Omit<OpenDataFood, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -252,15 +261,4 @@ export function OpenDataFoodToJSON(value?: Omit<OpenDataFood, 'created_by'> | nu
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataFoodListRequest, PaginatedOpenDataFoodList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataFoodListRequest = {}): Promise<PaginatedOpenDataFoodList> {
-    const api = new ApiApi()
-    return api.apiOpenDataFoodList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataFoodProperty.ts b/vue3/src/openapi/models/OpenDataFoodProperty.ts
index c2a1ce96a..271d0f745 100644
--- a/vue3/src/openapi/models/OpenDataFoodProperty.ts
+++ b/vue3/src/openapi/models/OpenDataFoodProperty.ts
@@ -18,6 +18,7 @@ import {
     OpenDataPropertyFromJSON,
     OpenDataPropertyFromJSONTyped,
     OpenDataPropertyToJSON,
+    OpenDataPropertyToJSONTyped,
 } from './OpenDataProperty';
 
 /**
@@ -71,10 +72,15 @@ export function OpenDataFoodPropertyFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function OpenDataFoodPropertyToJSON(value?: OpenDataFoodProperty | null): any {
+export function OpenDataFoodPropertyToJSON(json: any): OpenDataFoodProperty {
+    return OpenDataFoodPropertyToJSONTyped(json, false);
+}
+
+export function OpenDataFoodPropertyToJSONTyped(value?: OpenDataFoodProperty | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -82,15 +88,4 @@ export function OpenDataFoodPropertyToJSON(value?: OpenDataFoodProperty | null):
         'property_amount': value['propertyAmount'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataFoodPropertyListRequest, PaginatedOpenDataFoodPropertyList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataFoodPropertyListRequest = {}): Promise<PaginatedOpenDataFoodPropertyList> {
-    const api = new ApiApi()
-    return api.apiOpenDataFoodPropertyList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataProperty.ts b/vue3/src/openapi/models/OpenDataProperty.ts
index 852441dd8..610757eef 100644
--- a/vue3/src/openapi/models/OpenDataProperty.ts
+++ b/vue3/src/openapi/models/OpenDataProperty.ts
@@ -18,6 +18,7 @@ import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -142,10 +143,15 @@ export function OpenDataPropertyFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function OpenDataPropertyToJSON(value?: Omit<OpenDataProperty, 'created_by'> | null): any {
+export function OpenDataPropertyToJSON(json: any): OpenDataProperty {
+    return OpenDataPropertyToJSONTyped(json, false);
+}
+
+export function OpenDataPropertyToJSONTyped(value?: Omit<OpenDataProperty, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -157,15 +163,4 @@ export function OpenDataPropertyToJSON(value?: Omit<OpenDataProperty, 'created_b
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataPropertyListRequest, PaginatedOpenDataPropertyList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataPropertyListRequest = {}): Promise<PaginatedOpenDataPropertyList> {
-    const api = new ApiApi()
-    return api.apiOpenDataPropertyList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataStore.ts b/vue3/src/openapi/models/OpenDataStore.ts
index 31c9af123..93a37d8c1 100644
--- a/vue3/src/openapi/models/OpenDataStore.ts
+++ b/vue3/src/openapi/models/OpenDataStore.ts
@@ -18,12 +18,14 @@ import {
     OpenDataStoreCategoryFromJSON,
     OpenDataStoreCategoryFromJSONTyped,
     OpenDataStoreCategoryToJSON,
+    OpenDataStoreCategoryToJSONTyped,
 } from './OpenDataStoreCategory';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -108,10 +110,15 @@ export function OpenDataStoreFromJSONTyped(json: any, ignoreDiscriminator: boole
     };
 }
 
-export function OpenDataStoreToJSON(value?: Omit<OpenDataStore, 'created_by'> | null): any {
+export function OpenDataStoreToJSON(json: any): OpenDataStore {
+    return OpenDataStoreToJSONTyped(json, false);
+}
+
+export function OpenDataStoreToJSONTyped(value?: Omit<OpenDataStore, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -122,15 +129,4 @@ export function OpenDataStoreToJSON(value?: Omit<OpenDataStore, 'created_by'> |
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataStoreListRequest, PaginatedOpenDataStoreList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataStoreListRequest = {}): Promise<PaginatedOpenDataStoreList> {
-    const api = new ApiApi()
-    return api.apiOpenDataStoreList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataStoreCategory.ts b/vue3/src/openapi/models/OpenDataStoreCategory.ts
index 8be7d9333..ce97df853 100644
--- a/vue3/src/openapi/models/OpenDataStoreCategory.ts
+++ b/vue3/src/openapi/models/OpenDataStoreCategory.ts
@@ -18,6 +18,7 @@ import {
     OpenDataCategoryFromJSON,
     OpenDataCategoryFromJSONTyped,
     OpenDataCategoryToJSON,
+    OpenDataCategoryToJSONTyped,
 } from './OpenDataCategory';
 
 /**
@@ -78,10 +79,15 @@ export function OpenDataStoreCategoryFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function OpenDataStoreCategoryToJSON(value?: OpenDataStoreCategory | null): any {
+export function OpenDataStoreCategoryToJSON(json: any): OpenDataStoreCategory {
+    return OpenDataStoreCategoryToJSONTyped(json, false);
+}
+
+export function OpenDataStoreCategoryToJSONTyped(value?: OpenDataStoreCategory | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -90,15 +96,4 @@ export function OpenDataStoreCategoryToJSON(value?: OpenDataStoreCategory | null
         'order': value['order'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataStoreCategoryListRequest, PaginatedOpenDataStoreCategoryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataStoreCategoryListRequest = {}): Promise<PaginatedOpenDataStoreCategoryList> {
-    const api = new ApiApi()
-    return api.apiOpenDataStoreCategoryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataUnit.ts b/vue3/src/openapi/models/OpenDataUnit.ts
index 86ea02cb8..07533ff2a 100644
--- a/vue3/src/openapi/models/OpenDataUnit.ts
+++ b/vue3/src/openapi/models/OpenDataUnit.ts
@@ -18,18 +18,21 @@ import {
     BaseUnitEnumFromJSON,
     BaseUnitEnumFromJSONTyped,
     BaseUnitEnumToJSON,
+    BaseUnitEnumToJSONTyped,
 } from './BaseUnitEnum';
 import type { OpenDataUnitTypeEnum } from './OpenDataUnitTypeEnum';
 import {
     OpenDataUnitTypeEnumFromJSON,
     OpenDataUnitTypeEnumFromJSONTyped,
     OpenDataUnitTypeEnumToJSON,
+    OpenDataUnitTypeEnumToJSONTyped,
 } from './OpenDataUnitTypeEnum';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -164,10 +167,15 @@ export function OpenDataUnitFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function OpenDataUnitToJSON(value?: Omit<OpenDataUnit, 'created_by'> | null): any {
+export function OpenDataUnitToJSON(json: any): OpenDataUnit {
+    return OpenDataUnitToJSONTyped(json, false);
+}
+
+export function OpenDataUnitToJSONTyped(value?: Omit<OpenDataUnit, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -180,15 +188,4 @@ export function OpenDataUnitToJSON(value?: Omit<OpenDataUnit, 'created_by'> | nu
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataUnitListRequest, PaginatedOpenDataUnitList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataUnitListRequest = {}): Promise<PaginatedOpenDataUnitList> {
-    const api = new ApiApi()
-    return api.apiOpenDataUnitList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/OpenDataVersion.ts b/vue3/src/openapi/models/OpenDataVersion.ts
index 6218f7c55..5bff7bd14 100644
--- a/vue3/src/openapi/models/OpenDataVersion.ts
+++ b/vue3/src/openapi/models/OpenDataVersion.ts
@@ -105,10 +105,15 @@ export function OpenDataVersionFromJSONTyped(json: any, ignoreDiscriminator: boo
     };
 }
 
-export function OpenDataVersionToJSON(value?: OpenDataVersion | null): any {
+export function OpenDataVersionToJSON(json: any): OpenDataVersion {
+    return OpenDataVersionToJSONTyped(json, false);
+}
+
+export function OpenDataVersionToJSONTyped(value?: OpenDataVersion | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -117,15 +122,4 @@ export function OpenDataVersionToJSON(value?: OpenDataVersion | null): any {
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiOpenDataVersionListRequest, PaginatedOpenDataVersionList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiOpenDataVersionListRequest = {}): Promise<PaginatedOpenDataVersionList> {
-    const api = new ApiApi()
-    return api.apiOpenDataVersionList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedAutomationList.ts b/vue3/src/openapi/models/PaginatedAutomationList.ts
index b59d84ca5..59b5ffd7a 100644
--- a/vue3/src/openapi/models/PaginatedAutomationList.ts
+++ b/vue3/src/openapi/models/PaginatedAutomationList.ts
@@ -18,6 +18,7 @@ import {
     AutomationFromJSON,
     AutomationFromJSONTyped,
     AutomationToJSON,
+    AutomationToJSONTyped,
 } from './Automation';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedAutomationListFromJSONTyped(json: any, ignoreDiscrimina
     };
 }
 
-export function PaginatedAutomationListToJSON(value?: PaginatedAutomationList | null): any {
+export function PaginatedAutomationListToJSON(json: any): PaginatedAutomationList {
+    return PaginatedAutomationListToJSONTyped(json, false);
+}
+
+export function PaginatedAutomationListToJSONTyped(value?: PaginatedAutomationList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedAutomationListToJSON(value?: PaginatedAutomationList |
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedAutomationListListRequest, PaginatedPaginatedAutomationListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedAutomationListListRequest = {}): Promise<PaginatedPaginatedAutomationListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedAutomationListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedBookmarkletImportListList.ts b/vue3/src/openapi/models/PaginatedBookmarkletImportListList.ts
index f5b1591d9..a86f45808 100644
--- a/vue3/src/openapi/models/PaginatedBookmarkletImportListList.ts
+++ b/vue3/src/openapi/models/PaginatedBookmarkletImportListList.ts
@@ -18,6 +18,7 @@ import {
     BookmarkletImportListFromJSON,
     BookmarkletImportListFromJSONTyped,
     BookmarkletImportListToJSON,
+    BookmarkletImportListToJSONTyped,
 } from './BookmarkletImportList';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedBookmarkletImportListListFromJSONTyped(json: any, ignor
     };
 }
 
-export function PaginatedBookmarkletImportListListToJSON(value?: PaginatedBookmarkletImportListList | null): any {
+export function PaginatedBookmarkletImportListListToJSON(json: any): PaginatedBookmarkletImportListList {
+    return PaginatedBookmarkletImportListListToJSONTyped(json, false);
+}
+
+export function PaginatedBookmarkletImportListListToJSONTyped(value?: PaginatedBookmarkletImportListList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedBookmarkletImportListListToJSON(value?: PaginatedBookma
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedBookmarkletImportListListListRequest, PaginatedPaginatedBookmarkletImportListListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedBookmarkletImportListListListRequest = {}): Promise<PaginatedPaginatedBookmarkletImportListListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedBookmarkletImportListListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedCookLogList.ts b/vue3/src/openapi/models/PaginatedCookLogList.ts
index 06491f66d..e2380f6cc 100644
--- a/vue3/src/openapi/models/PaginatedCookLogList.ts
+++ b/vue3/src/openapi/models/PaginatedCookLogList.ts
@@ -18,6 +18,7 @@ import {
     CookLogFromJSON,
     CookLogFromJSONTyped,
     CookLogToJSON,
+    CookLogToJSONTyped,
 } from './CookLog';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedCookLogListFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function PaginatedCookLogListToJSON(value?: PaginatedCookLogList | null): any {
+export function PaginatedCookLogListToJSON(json: any): PaginatedCookLogList {
+    return PaginatedCookLogListToJSONTyped(json, false);
+}
+
+export function PaginatedCookLogListToJSONTyped(value?: PaginatedCookLogList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedCookLogListToJSON(value?: PaginatedCookLogList | null):
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedCookLogListListRequest, PaginatedPaginatedCookLogListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedCookLogListListRequest = {}): Promise<PaginatedPaginatedCookLogListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedCookLogListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedCustomFilterList.ts b/vue3/src/openapi/models/PaginatedCustomFilterList.ts
index e8b68264c..6a197d482 100644
--- a/vue3/src/openapi/models/PaginatedCustomFilterList.ts
+++ b/vue3/src/openapi/models/PaginatedCustomFilterList.ts
@@ -18,6 +18,7 @@ import {
     CustomFilterFromJSON,
     CustomFilterFromJSONTyped,
     CustomFilterToJSON,
+    CustomFilterToJSONTyped,
 } from './CustomFilter';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedCustomFilterListFromJSONTyped(json: any, ignoreDiscrimi
     };
 }
 
-export function PaginatedCustomFilterListToJSON(value?: PaginatedCustomFilterList | null): any {
+export function PaginatedCustomFilterListToJSON(json: any): PaginatedCustomFilterList {
+    return PaginatedCustomFilterListToJSONTyped(json, false);
+}
+
+export function PaginatedCustomFilterListToJSONTyped(value?: PaginatedCustomFilterList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedCustomFilterListToJSON(value?: PaginatedCustomFilterLis
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedCustomFilterListListRequest, PaginatedPaginatedCustomFilterListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedCustomFilterListListRequest = {}): Promise<PaginatedPaginatedCustomFilterListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedCustomFilterListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedExportLogList.ts b/vue3/src/openapi/models/PaginatedExportLogList.ts
index b60bd8dab..e9a9f75b6 100644
--- a/vue3/src/openapi/models/PaginatedExportLogList.ts
+++ b/vue3/src/openapi/models/PaginatedExportLogList.ts
@@ -18,6 +18,7 @@ import {
     ExportLogFromJSON,
     ExportLogFromJSONTyped,
     ExportLogToJSON,
+    ExportLogToJSONTyped,
 } from './ExportLog';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedExportLogListFromJSONTyped(json: any, ignoreDiscriminat
     };
 }
 
-export function PaginatedExportLogListToJSON(value?: PaginatedExportLogList | null): any {
+export function PaginatedExportLogListToJSON(json: any): PaginatedExportLogList {
+    return PaginatedExportLogListToJSONTyped(json, false);
+}
+
+export function PaginatedExportLogListToJSONTyped(value?: PaginatedExportLogList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedExportLogListToJSON(value?: PaginatedExportLogList | nu
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedExportLogListListRequest, PaginatedPaginatedExportLogListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedExportLogListListRequest = {}): Promise<PaginatedPaginatedExportLogListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedExportLogListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedFoodList.ts b/vue3/src/openapi/models/PaginatedFoodList.ts
index 512866f70..264bdcb76 100644
--- a/vue3/src/openapi/models/PaginatedFoodList.ts
+++ b/vue3/src/openapi/models/PaginatedFoodList.ts
@@ -18,6 +18,7 @@ import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedFoodListFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PaginatedFoodListToJSON(value?: PaginatedFoodList | null): any {
+export function PaginatedFoodListToJSON(json: any): PaginatedFoodList {
+    return PaginatedFoodListToJSONTyped(json, false);
+}
+
+export function PaginatedFoodListToJSONTyped(value?: PaginatedFoodList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedFoodListToJSON(value?: PaginatedFoodList | null): any {
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedFoodListListRequest, PaginatedPaginatedFoodListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedFoodListListRequest = {}): Promise<PaginatedPaginatedFoodListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedFoodListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedImportLogList.ts b/vue3/src/openapi/models/PaginatedImportLogList.ts
index b275a2de0..153c1382d 100644
--- a/vue3/src/openapi/models/PaginatedImportLogList.ts
+++ b/vue3/src/openapi/models/PaginatedImportLogList.ts
@@ -18,6 +18,7 @@ import {
     ImportLogFromJSON,
     ImportLogFromJSONTyped,
     ImportLogToJSON,
+    ImportLogToJSONTyped,
 } from './ImportLog';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedImportLogListFromJSONTyped(json: any, ignoreDiscriminat
     };
 }
 
-export function PaginatedImportLogListToJSON(value?: PaginatedImportLogList | null): any {
+export function PaginatedImportLogListToJSON(json: any): PaginatedImportLogList {
+    return PaginatedImportLogListToJSONTyped(json, false);
+}
+
+export function PaginatedImportLogListToJSONTyped(value?: PaginatedImportLogList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedImportLogListToJSON(value?: PaginatedImportLogList | nu
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedImportLogListListRequest, PaginatedPaginatedImportLogListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedImportLogListListRequest = {}): Promise<PaginatedPaginatedImportLogListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedImportLogListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedIngredientList.ts b/vue3/src/openapi/models/PaginatedIngredientList.ts
index d86b62862..d4329fd58 100644
--- a/vue3/src/openapi/models/PaginatedIngredientList.ts
+++ b/vue3/src/openapi/models/PaginatedIngredientList.ts
@@ -18,6 +18,7 @@ import {
     IngredientFromJSON,
     IngredientFromJSONTyped,
     IngredientToJSON,
+    IngredientToJSONTyped,
 } from './Ingredient';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedIngredientListFromJSONTyped(json: any, ignoreDiscrimina
     };
 }
 
-export function PaginatedIngredientListToJSON(value?: PaginatedIngredientList | null): any {
+export function PaginatedIngredientListToJSON(json: any): PaginatedIngredientList {
+    return PaginatedIngredientListToJSONTyped(json, false);
+}
+
+export function PaginatedIngredientListToJSONTyped(value?: PaginatedIngredientList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedIngredientListToJSON(value?: PaginatedIngredientList |
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedIngredientListListRequest, PaginatedPaginatedIngredientListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedIngredientListListRequest = {}): Promise<PaginatedPaginatedIngredientListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedIngredientListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedInviteLinkList.ts b/vue3/src/openapi/models/PaginatedInviteLinkList.ts
index e294beb47..92a8ab666 100644
--- a/vue3/src/openapi/models/PaginatedInviteLinkList.ts
+++ b/vue3/src/openapi/models/PaginatedInviteLinkList.ts
@@ -18,6 +18,7 @@ import {
     InviteLinkFromJSON,
     InviteLinkFromJSONTyped,
     InviteLinkToJSON,
+    InviteLinkToJSONTyped,
 } from './InviteLink';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedInviteLinkListFromJSONTyped(json: any, ignoreDiscrimina
     };
 }
 
-export function PaginatedInviteLinkListToJSON(value?: PaginatedInviteLinkList | null): any {
+export function PaginatedInviteLinkListToJSON(json: any): PaginatedInviteLinkList {
+    return PaginatedInviteLinkListToJSONTyped(json, false);
+}
+
+export function PaginatedInviteLinkListToJSONTyped(value?: PaginatedInviteLinkList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedInviteLinkListToJSON(value?: PaginatedInviteLinkList |
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedInviteLinkListListRequest, PaginatedPaginatedInviteLinkListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedInviteLinkListListRequest = {}): Promise<PaginatedPaginatedInviteLinkListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedInviteLinkListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedKeywordList.ts b/vue3/src/openapi/models/PaginatedKeywordList.ts
index e9a59a8b8..bd6ed2bac 100644
--- a/vue3/src/openapi/models/PaginatedKeywordList.ts
+++ b/vue3/src/openapi/models/PaginatedKeywordList.ts
@@ -18,6 +18,7 @@ import {
     KeywordFromJSON,
     KeywordFromJSONTyped,
     KeywordToJSON,
+    KeywordToJSONTyped,
 } from './Keyword';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedKeywordListFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function PaginatedKeywordListToJSON(value?: PaginatedKeywordList | null): any {
+export function PaginatedKeywordListToJSON(json: any): PaginatedKeywordList {
+    return PaginatedKeywordListToJSONTyped(json, false);
+}
+
+export function PaginatedKeywordListToJSONTyped(value?: PaginatedKeywordList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedKeywordListToJSON(value?: PaginatedKeywordList | null):
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedKeywordListListRequest, PaginatedPaginatedKeywordListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedKeywordListListRequest = {}): Promise<PaginatedPaginatedKeywordListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedKeywordListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedMealPlanList.ts b/vue3/src/openapi/models/PaginatedMealPlanList.ts
index e16162ad8..a9d9157e8 100644
--- a/vue3/src/openapi/models/PaginatedMealPlanList.ts
+++ b/vue3/src/openapi/models/PaginatedMealPlanList.ts
@@ -18,6 +18,7 @@ import {
     MealPlanFromJSON,
     MealPlanFromJSONTyped,
     MealPlanToJSON,
+    MealPlanToJSONTyped,
 } from './MealPlan';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedMealPlanListFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function PaginatedMealPlanListToJSON(value?: PaginatedMealPlanList | null): any {
+export function PaginatedMealPlanListToJSON(json: any): PaginatedMealPlanList {
+    return PaginatedMealPlanListToJSONTyped(json, false);
+}
+
+export function PaginatedMealPlanListToJSONTyped(value?: PaginatedMealPlanList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedMealPlanListToJSON(value?: PaginatedMealPlanList | null
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedMealPlanListListRequest, PaginatedPaginatedMealPlanListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedMealPlanListListRequest = {}): Promise<PaginatedPaginatedMealPlanListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedMealPlanListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedMealTypeList.ts b/vue3/src/openapi/models/PaginatedMealTypeList.ts
index 986f11b12..bce883ac1 100644
--- a/vue3/src/openapi/models/PaginatedMealTypeList.ts
+++ b/vue3/src/openapi/models/PaginatedMealTypeList.ts
@@ -18,6 +18,7 @@ import {
     MealTypeFromJSON,
     MealTypeFromJSONTyped,
     MealTypeToJSON,
+    MealTypeToJSONTyped,
 } from './MealType';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedMealTypeListFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function PaginatedMealTypeListToJSON(value?: PaginatedMealTypeList | null): any {
+export function PaginatedMealTypeListToJSON(json: any): PaginatedMealTypeList {
+    return PaginatedMealTypeListToJSONTyped(json, false);
+}
+
+export function PaginatedMealTypeListToJSONTyped(value?: PaginatedMealTypeList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedMealTypeListToJSON(value?: PaginatedMealTypeList | null
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedMealTypeListListRequest, PaginatedPaginatedMealTypeListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedMealTypeListListRequest = {}): Promise<PaginatedPaginatedMealTypeListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedMealTypeListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedPropertyList.ts b/vue3/src/openapi/models/PaginatedPropertyList.ts
index 521239ec0..88ca5aea7 100644
--- a/vue3/src/openapi/models/PaginatedPropertyList.ts
+++ b/vue3/src/openapi/models/PaginatedPropertyList.ts
@@ -18,6 +18,7 @@ import {
     PropertyFromJSON,
     PropertyFromJSONTyped,
     PropertyToJSON,
+    PropertyToJSONTyped,
 } from './Property';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedPropertyListFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function PaginatedPropertyListToJSON(value?: PaginatedPropertyList | null): any {
+export function PaginatedPropertyListToJSON(json: any): PaginatedPropertyList {
+    return PaginatedPropertyListToJSONTyped(json, false);
+}
+
+export function PaginatedPropertyListToJSONTyped(value?: PaginatedPropertyList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedPropertyListToJSON(value?: PaginatedPropertyList | null
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedPropertyListListRequest, PaginatedPaginatedPropertyListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedPropertyListListRequest = {}): Promise<PaginatedPaginatedPropertyListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedPropertyListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedPropertyTypeList.ts b/vue3/src/openapi/models/PaginatedPropertyTypeList.ts
index 32c7aa0aa..99bd75bcc 100644
--- a/vue3/src/openapi/models/PaginatedPropertyTypeList.ts
+++ b/vue3/src/openapi/models/PaginatedPropertyTypeList.ts
@@ -18,6 +18,7 @@ import {
     PropertyTypeFromJSON,
     PropertyTypeFromJSONTyped,
     PropertyTypeToJSON,
+    PropertyTypeToJSONTyped,
 } from './PropertyType';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedPropertyTypeListFromJSONTyped(json: any, ignoreDiscrimi
     };
 }
 
-export function PaginatedPropertyTypeListToJSON(value?: PaginatedPropertyTypeList | null): any {
+export function PaginatedPropertyTypeListToJSON(json: any): PaginatedPropertyTypeList {
+    return PaginatedPropertyTypeListToJSONTyped(json, false);
+}
+
+export function PaginatedPropertyTypeListToJSONTyped(value?: PaginatedPropertyTypeList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedPropertyTypeListToJSON(value?: PaginatedPropertyTypeLis
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedPropertyTypeListListRequest, PaginatedPaginatedPropertyTypeListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedPropertyTypeListListRequest = {}): Promise<PaginatedPaginatedPropertyTypeListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedPropertyTypeListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedRecipeBookEntryList.ts b/vue3/src/openapi/models/PaginatedRecipeBookEntryList.ts
index b9cb781d2..b357f0194 100644
--- a/vue3/src/openapi/models/PaginatedRecipeBookEntryList.ts
+++ b/vue3/src/openapi/models/PaginatedRecipeBookEntryList.ts
@@ -18,6 +18,7 @@ import {
     RecipeBookEntryFromJSON,
     RecipeBookEntryFromJSONTyped,
     RecipeBookEntryToJSON,
+    RecipeBookEntryToJSONTyped,
 } from './RecipeBookEntry';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedRecipeBookEntryListFromJSONTyped(json: any, ignoreDiscr
     };
 }
 
-export function PaginatedRecipeBookEntryListToJSON(value?: PaginatedRecipeBookEntryList | null): any {
+export function PaginatedRecipeBookEntryListToJSON(json: any): PaginatedRecipeBookEntryList {
+    return PaginatedRecipeBookEntryListToJSONTyped(json, false);
+}
+
+export function PaginatedRecipeBookEntryListToJSONTyped(value?: PaginatedRecipeBookEntryList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedRecipeBookEntryListToJSON(value?: PaginatedRecipeBookEn
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedRecipeBookEntryListListRequest, PaginatedPaginatedRecipeBookEntryListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedRecipeBookEntryListListRequest = {}): Promise<PaginatedPaginatedRecipeBookEntryListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedRecipeBookEntryListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedRecipeBookList.ts b/vue3/src/openapi/models/PaginatedRecipeBookList.ts
index 91280941c..a8e6cc000 100644
--- a/vue3/src/openapi/models/PaginatedRecipeBookList.ts
+++ b/vue3/src/openapi/models/PaginatedRecipeBookList.ts
@@ -18,6 +18,7 @@ import {
     RecipeBookFromJSON,
     RecipeBookFromJSONTyped,
     RecipeBookToJSON,
+    RecipeBookToJSONTyped,
 } from './RecipeBook';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedRecipeBookListFromJSONTyped(json: any, ignoreDiscrimina
     };
 }
 
-export function PaginatedRecipeBookListToJSON(value?: PaginatedRecipeBookList | null): any {
+export function PaginatedRecipeBookListToJSON(json: any): PaginatedRecipeBookList {
+    return PaginatedRecipeBookListToJSONTyped(json, false);
+}
+
+export function PaginatedRecipeBookListToJSONTyped(value?: PaginatedRecipeBookList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedRecipeBookListToJSON(value?: PaginatedRecipeBookList |
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedRecipeBookListListRequest, PaginatedPaginatedRecipeBookListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedRecipeBookListListRequest = {}): Promise<PaginatedPaginatedRecipeBookListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedRecipeBookListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedRecipeOverviewList.ts b/vue3/src/openapi/models/PaginatedRecipeOverviewList.ts
index 4d4fb7ca8..19a8e3169 100644
--- a/vue3/src/openapi/models/PaginatedRecipeOverviewList.ts
+++ b/vue3/src/openapi/models/PaginatedRecipeOverviewList.ts
@@ -18,6 +18,7 @@ import {
     RecipeOverviewFromJSON,
     RecipeOverviewFromJSONTyped,
     RecipeOverviewToJSON,
+    RecipeOverviewToJSONTyped,
 } from './RecipeOverview';
 
 /**
@@ -78,10 +79,15 @@ export function PaginatedRecipeOverviewListFromJSONTyped(json: any, ignoreDiscri
     };
 }
 
-export function PaginatedRecipeOverviewListToJSON(value?: PaginatedRecipeOverviewList | null): any {
+export function PaginatedRecipeOverviewListToJSON(json: any): PaginatedRecipeOverviewList {
+    return PaginatedRecipeOverviewListToJSONTyped(json, false);
+}
+
+export function PaginatedRecipeOverviewListToJSONTyped(value?: PaginatedRecipeOverviewList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -90,15 +96,4 @@ export function PaginatedRecipeOverviewListToJSON(value?: PaginatedRecipeOvervie
         'results': ((value['results'] as Array<any>).map(RecipeOverviewToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedRecipeOverviewListListRequest, PaginatedPaginatedRecipeOverviewListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedRecipeOverviewListListRequest = {}): Promise<PaginatedPaginatedRecipeOverviewListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedRecipeOverviewListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedShoppingListEntryList.ts b/vue3/src/openapi/models/PaginatedShoppingListEntryList.ts
index 5bab91737..fa412d919 100644
--- a/vue3/src/openapi/models/PaginatedShoppingListEntryList.ts
+++ b/vue3/src/openapi/models/PaginatedShoppingListEntryList.ts
@@ -18,6 +18,7 @@ import {
     ShoppingListEntryFromJSON,
     ShoppingListEntryFromJSONTyped,
     ShoppingListEntryToJSON,
+    ShoppingListEntryToJSONTyped,
 } from './ShoppingListEntry';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedShoppingListEntryListFromJSONTyped(json: any, ignoreDis
     };
 }
 
-export function PaginatedShoppingListEntryListToJSON(value?: PaginatedShoppingListEntryList | null): any {
+export function PaginatedShoppingListEntryListToJSON(json: any): PaginatedShoppingListEntryList {
+    return PaginatedShoppingListEntryListToJSONTyped(json, false);
+}
+
+export function PaginatedShoppingListEntryListToJSONTyped(value?: PaginatedShoppingListEntryList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedShoppingListEntryListToJSON(value?: PaginatedShoppingLi
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedShoppingListEntryListListRequest, PaginatedPaginatedShoppingListEntryListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedShoppingListEntryListListRequest = {}): Promise<PaginatedPaginatedShoppingListEntryListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedShoppingListEntryListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedShoppingListRecipeList.ts b/vue3/src/openapi/models/PaginatedShoppingListRecipeList.ts
index bc48e8f0b..b88404d19 100644
--- a/vue3/src/openapi/models/PaginatedShoppingListRecipeList.ts
+++ b/vue3/src/openapi/models/PaginatedShoppingListRecipeList.ts
@@ -18,6 +18,7 @@ import {
     ShoppingListRecipeFromJSON,
     ShoppingListRecipeFromJSONTyped,
     ShoppingListRecipeToJSON,
+    ShoppingListRecipeToJSONTyped,
 } from './ShoppingListRecipe';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedShoppingListRecipeListFromJSONTyped(json: any, ignoreDi
     };
 }
 
-export function PaginatedShoppingListRecipeListToJSON(value?: PaginatedShoppingListRecipeList | null): any {
+export function PaginatedShoppingListRecipeListToJSON(json: any): PaginatedShoppingListRecipeList {
+    return PaginatedShoppingListRecipeListToJSONTyped(json, false);
+}
+
+export function PaginatedShoppingListRecipeListToJSONTyped(value?: PaginatedShoppingListRecipeList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedShoppingListRecipeListToJSON(value?: PaginatedShoppingL
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedShoppingListRecipeListListRequest, PaginatedPaginatedShoppingListRecipeListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedShoppingListRecipeListListRequest = {}): Promise<PaginatedPaginatedShoppingListRecipeListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedShoppingListRecipeListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedSpaceList.ts b/vue3/src/openapi/models/PaginatedSpaceList.ts
index c1a37af1d..ab62b794d 100644
--- a/vue3/src/openapi/models/PaginatedSpaceList.ts
+++ b/vue3/src/openapi/models/PaginatedSpaceList.ts
@@ -18,6 +18,7 @@ import {
     SpaceFromJSON,
     SpaceFromJSONTyped,
     SpaceToJSON,
+    SpaceToJSONTyped,
 } from './Space';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedSpaceListFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PaginatedSpaceListToJSON(value?: PaginatedSpaceList | null): any {
+export function PaginatedSpaceListToJSON(json: any): PaginatedSpaceList {
+    return PaginatedSpaceListToJSONTyped(json, false);
+}
+
+export function PaginatedSpaceListToJSONTyped(value?: PaginatedSpaceList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedSpaceListToJSON(value?: PaginatedSpaceList | null): any
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedSpaceListListRequest, PaginatedPaginatedSpaceListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedSpaceListListRequest = {}): Promise<PaginatedPaginatedSpaceListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedSpaceListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedStepList.ts b/vue3/src/openapi/models/PaginatedStepList.ts
index d80863059..0e8d2e86c 100644
--- a/vue3/src/openapi/models/PaginatedStepList.ts
+++ b/vue3/src/openapi/models/PaginatedStepList.ts
@@ -18,6 +18,7 @@ import {
     StepFromJSON,
     StepFromJSONTyped,
     StepToJSON,
+    StepToJSONTyped,
 } from './Step';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedStepListFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PaginatedStepListToJSON(value?: PaginatedStepList | null): any {
+export function PaginatedStepListToJSON(json: any): PaginatedStepList {
+    return PaginatedStepListToJSONTyped(json, false);
+}
+
+export function PaginatedStepListToJSONTyped(value?: PaginatedStepList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedStepListToJSON(value?: PaginatedStepList | null): any {
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedStepListListRequest, PaginatedPaginatedStepListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedStepListListRequest = {}): Promise<PaginatedPaginatedStepListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedStepListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedSupermarketCategoryList.ts b/vue3/src/openapi/models/PaginatedSupermarketCategoryList.ts
index a8876dc88..9c25989c7 100644
--- a/vue3/src/openapi/models/PaginatedSupermarketCategoryList.ts
+++ b/vue3/src/openapi/models/PaginatedSupermarketCategoryList.ts
@@ -18,6 +18,7 @@ import {
     SupermarketCategoryFromJSON,
     SupermarketCategoryFromJSONTyped,
     SupermarketCategoryToJSON,
+    SupermarketCategoryToJSONTyped,
 } from './SupermarketCategory';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedSupermarketCategoryListFromJSONTyped(json: any, ignoreD
     };
 }
 
-export function PaginatedSupermarketCategoryListToJSON(value?: PaginatedSupermarketCategoryList | null): any {
+export function PaginatedSupermarketCategoryListToJSON(json: any): PaginatedSupermarketCategoryList {
+    return PaginatedSupermarketCategoryListToJSONTyped(json, false);
+}
+
+export function PaginatedSupermarketCategoryListToJSONTyped(value?: PaginatedSupermarketCategoryList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedSupermarketCategoryListToJSON(value?: PaginatedSupermar
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedSupermarketCategoryListListRequest, PaginatedPaginatedSupermarketCategoryListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedSupermarketCategoryListListRequest = {}): Promise<PaginatedPaginatedSupermarketCategoryListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedSupermarketCategoryListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedSupermarketCategoryRelationList.ts b/vue3/src/openapi/models/PaginatedSupermarketCategoryRelationList.ts
index 454b87c98..2629b84db 100644
--- a/vue3/src/openapi/models/PaginatedSupermarketCategoryRelationList.ts
+++ b/vue3/src/openapi/models/PaginatedSupermarketCategoryRelationList.ts
@@ -18,6 +18,7 @@ import {
     SupermarketCategoryRelationFromJSON,
     SupermarketCategoryRelationFromJSONTyped,
     SupermarketCategoryRelationToJSON,
+    SupermarketCategoryRelationToJSONTyped,
 } from './SupermarketCategoryRelation';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedSupermarketCategoryRelationListFromJSONTyped(json: any,
     };
 }
 
-export function PaginatedSupermarketCategoryRelationListToJSON(value?: PaginatedSupermarketCategoryRelationList | null): any {
+export function PaginatedSupermarketCategoryRelationListToJSON(json: any): PaginatedSupermarketCategoryRelationList {
+    return PaginatedSupermarketCategoryRelationListToJSONTyped(json, false);
+}
+
+export function PaginatedSupermarketCategoryRelationListToJSONTyped(value?: PaginatedSupermarketCategoryRelationList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedSupermarketCategoryRelationListToJSON(value?: Paginated
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedSupermarketCategoryRelationListListRequest, PaginatedPaginatedSupermarketCategoryRelationListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedSupermarketCategoryRelationListListRequest = {}): Promise<PaginatedPaginatedSupermarketCategoryRelationListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedSupermarketCategoryRelationListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedSupermarketList.ts b/vue3/src/openapi/models/PaginatedSupermarketList.ts
index 9deec64f3..6e02a7209 100644
--- a/vue3/src/openapi/models/PaginatedSupermarketList.ts
+++ b/vue3/src/openapi/models/PaginatedSupermarketList.ts
@@ -18,6 +18,7 @@ import {
     SupermarketFromJSON,
     SupermarketFromJSONTyped,
     SupermarketToJSON,
+    SupermarketToJSONTyped,
 } from './Supermarket';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedSupermarketListFromJSONTyped(json: any, ignoreDiscrimin
     };
 }
 
-export function PaginatedSupermarketListToJSON(value?: PaginatedSupermarketList | null): any {
+export function PaginatedSupermarketListToJSON(json: any): PaginatedSupermarketList {
+    return PaginatedSupermarketListToJSONTyped(json, false);
+}
+
+export function PaginatedSupermarketListToJSONTyped(value?: PaginatedSupermarketList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedSupermarketListToJSON(value?: PaginatedSupermarketList
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedSupermarketListListRequest, PaginatedPaginatedSupermarketListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedSupermarketListListRequest = {}): Promise<PaginatedPaginatedSupermarketListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedSupermarketListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedSyncList.ts b/vue3/src/openapi/models/PaginatedSyncList.ts
index 447441df3..f54e968c2 100644
--- a/vue3/src/openapi/models/PaginatedSyncList.ts
+++ b/vue3/src/openapi/models/PaginatedSyncList.ts
@@ -18,6 +18,7 @@ import {
     SyncFromJSON,
     SyncFromJSONTyped,
     SyncToJSON,
+    SyncToJSONTyped,
 } from './Sync';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedSyncListFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PaginatedSyncListToJSON(value?: PaginatedSyncList | null): any {
+export function PaginatedSyncListToJSON(json: any): PaginatedSyncList {
+    return PaginatedSyncListToJSONTyped(json, false);
+}
+
+export function PaginatedSyncListToJSONTyped(value?: PaginatedSyncList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedSyncListToJSON(value?: PaginatedSyncList | null): any {
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedSyncListListRequest, PaginatedPaginatedSyncListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedSyncListListRequest = {}): Promise<PaginatedPaginatedSyncListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedSyncListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedSyncLogList.ts b/vue3/src/openapi/models/PaginatedSyncLogList.ts
index cca33deec..4f161d989 100644
--- a/vue3/src/openapi/models/PaginatedSyncLogList.ts
+++ b/vue3/src/openapi/models/PaginatedSyncLogList.ts
@@ -18,6 +18,7 @@ import {
     SyncLogFromJSON,
     SyncLogFromJSONTyped,
     SyncLogToJSON,
+    SyncLogToJSONTyped,
 } from './SyncLog';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedSyncLogListFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function PaginatedSyncLogListToJSON(value?: PaginatedSyncLogList | null): any {
+export function PaginatedSyncLogListToJSON(json: any): PaginatedSyncLogList {
+    return PaginatedSyncLogListToJSONTyped(json, false);
+}
+
+export function PaginatedSyncLogListToJSONTyped(value?: PaginatedSyncLogList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedSyncLogListToJSON(value?: PaginatedSyncLogList | null):
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedSyncLogListListRequest, PaginatedPaginatedSyncLogListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedSyncLogListListRequest = {}): Promise<PaginatedPaginatedSyncLogListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedSyncLogListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedUnitConversionList.ts b/vue3/src/openapi/models/PaginatedUnitConversionList.ts
index 07efd956c..e2f8b7679 100644
--- a/vue3/src/openapi/models/PaginatedUnitConversionList.ts
+++ b/vue3/src/openapi/models/PaginatedUnitConversionList.ts
@@ -18,6 +18,7 @@ import {
     UnitConversionFromJSON,
     UnitConversionFromJSONTyped,
     UnitConversionToJSON,
+    UnitConversionToJSONTyped,
 } from './UnitConversion';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedUnitConversionListFromJSONTyped(json: any, ignoreDiscri
     };
 }
 
-export function PaginatedUnitConversionListToJSON(value?: PaginatedUnitConversionList | null): any {
+export function PaginatedUnitConversionListToJSON(json: any): PaginatedUnitConversionList {
+    return PaginatedUnitConversionListToJSONTyped(json, false);
+}
+
+export function PaginatedUnitConversionListToJSONTyped(value?: PaginatedUnitConversionList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedUnitConversionListToJSON(value?: PaginatedUnitConversio
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedUnitConversionListListRequest, PaginatedPaginatedUnitConversionListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedUnitConversionListListRequest = {}): Promise<PaginatedPaginatedUnitConversionListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedUnitConversionListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedUnitList.ts b/vue3/src/openapi/models/PaginatedUnitList.ts
index ff5b45f4a..71b9c8b8a 100644
--- a/vue3/src/openapi/models/PaginatedUnitList.ts
+++ b/vue3/src/openapi/models/PaginatedUnitList.ts
@@ -18,6 +18,7 @@ import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedUnitListFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PaginatedUnitListToJSON(value?: PaginatedUnitList | null): any {
+export function PaginatedUnitListToJSON(json: any): PaginatedUnitList {
+    return PaginatedUnitListToJSONTyped(json, false);
+}
+
+export function PaginatedUnitListToJSONTyped(value?: PaginatedUnitList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedUnitListToJSON(value?: PaginatedUnitList | null): any {
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedUnitListListRequest, PaginatedPaginatedUnitListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedUnitListListRequest = {}): Promise<PaginatedPaginatedUnitListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedUnitListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedUserFileList.ts b/vue3/src/openapi/models/PaginatedUserFileList.ts
index 115c3953f..7d91cfbdf 100644
--- a/vue3/src/openapi/models/PaginatedUserFileList.ts
+++ b/vue3/src/openapi/models/PaginatedUserFileList.ts
@@ -18,6 +18,7 @@ import {
     UserFileFromJSON,
     UserFileFromJSONTyped,
     UserFileToJSON,
+    UserFileToJSONTyped,
 } from './UserFile';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedUserFileListFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function PaginatedUserFileListToJSON(value?: PaginatedUserFileList | null): any {
+export function PaginatedUserFileListToJSON(json: any): PaginatedUserFileList {
+    return PaginatedUserFileListToJSONTyped(json, false);
+}
+
+export function PaginatedUserFileListToJSONTyped(value?: PaginatedUserFileList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedUserFileListToJSON(value?: PaginatedUserFileList | null
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedUserFileListListRequest, PaginatedPaginatedUserFileListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedUserFileListListRequest = {}): Promise<PaginatedPaginatedUserFileListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedUserFileListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedUserSpaceList.ts b/vue3/src/openapi/models/PaginatedUserSpaceList.ts
index ae5b69a7f..7a6582806 100644
--- a/vue3/src/openapi/models/PaginatedUserSpaceList.ts
+++ b/vue3/src/openapi/models/PaginatedUserSpaceList.ts
@@ -18,6 +18,7 @@ import {
     UserSpaceFromJSON,
     UserSpaceFromJSONTyped,
     UserSpaceToJSON,
+    UserSpaceToJSONTyped,
 } from './UserSpace';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedUserSpaceListFromJSONTyped(json: any, ignoreDiscriminat
     };
 }
 
-export function PaginatedUserSpaceListToJSON(value?: PaginatedUserSpaceList | null): any {
+export function PaginatedUserSpaceListToJSON(json: any): PaginatedUserSpaceList {
+    return PaginatedUserSpaceListToJSONTyped(json, false);
+}
+
+export function PaginatedUserSpaceListToJSONTyped(value?: PaginatedUserSpaceList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedUserSpaceListToJSON(value?: PaginatedUserSpaceList | nu
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedUserSpaceListListRequest, PaginatedPaginatedUserSpaceListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedUserSpaceListListRequest = {}): Promise<PaginatedPaginatedUserSpaceListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedUserSpaceListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PaginatedViewLogList.ts b/vue3/src/openapi/models/PaginatedViewLogList.ts
index ff9bbd174..8f3e3217a 100644
--- a/vue3/src/openapi/models/PaginatedViewLogList.ts
+++ b/vue3/src/openapi/models/PaginatedViewLogList.ts
@@ -18,6 +18,7 @@ import {
     ViewLogFromJSON,
     ViewLogFromJSONTyped,
     ViewLogToJSON,
+    ViewLogToJSONTyped,
 } from './ViewLog';
 
 /**
@@ -85,10 +86,15 @@ export function PaginatedViewLogListFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function PaginatedViewLogListToJSON(value?: PaginatedViewLogList | null): any {
+export function PaginatedViewLogListToJSON(json: any): PaginatedViewLogList {
+    return PaginatedViewLogListToJSONTyped(json, false);
+}
+
+export function PaginatedViewLogListToJSONTyped(value?: PaginatedViewLogList | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'count': value['count'],
@@ -98,15 +104,4 @@ export function PaginatedViewLogListToJSON(value?: PaginatedViewLogList | null):
         'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPaginatedViewLogListListRequest, PaginatedPaginatedViewLogListList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPaginatedViewLogListListRequest = {}): Promise<PaginatedPaginatedViewLogListList> {
-    const api = new ApiApi()
-    return api.apiPaginatedViewLogListList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ParsedIngredient.ts b/vue3/src/openapi/models/ParsedIngredient.ts
index 1b2f0ecaa..a794fc244 100644
--- a/vue3/src/openapi/models/ParsedIngredient.ts
+++ b/vue3/src/openapi/models/ParsedIngredient.ts
@@ -73,10 +73,15 @@ export function ParsedIngredientFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function ParsedIngredientToJSON(value?: ParsedIngredient | null): any {
+export function ParsedIngredientToJSON(json: any): ParsedIngredient {
+    return ParsedIngredientToJSONTyped(json, false);
+}
+
+export function ParsedIngredientToJSONTyped(value?: ParsedIngredient | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'amount': value['amount'],
@@ -85,15 +90,4 @@ export function ParsedIngredientToJSON(value?: ParsedIngredient | null): any {
         'note': value['note'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiParsedIngredientListRequest, PaginatedParsedIngredientList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiParsedIngredientListRequest = {}): Promise<PaginatedParsedIngredientList> {
-    const api = new ApiApi()
-    return api.apiParsedIngredientList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedAccessToken.ts b/vue3/src/openapi/models/PatchedAccessToken.ts
index 273162eed..ab268d5e7 100644
--- a/vue3/src/openapi/models/PatchedAccessToken.ts
+++ b/vue3/src/openapi/models/PatchedAccessToken.ts
@@ -83,10 +83,15 @@ export function PatchedAccessTokenFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PatchedAccessTokenToJSON(value?: Omit<PatchedAccessToken, 'token'|'created'|'updated'> | null): any {
+export function PatchedAccessTokenToJSON(json: any): PatchedAccessToken {
+    return PatchedAccessTokenToJSONTyped(json, false);
+}
+
+export function PatchedAccessTokenToJSONTyped(value?: Omit<PatchedAccessToken, 'token'|'created'|'updated'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -94,15 +99,4 @@ export function PatchedAccessTokenToJSON(value?: Omit<PatchedAccessToken, 'token
         'scope': value['scope'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedAccessTokenListRequest, PaginatedPatchedAccessTokenList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedAccessTokenListRequest = {}): Promise<PaginatedPatchedAccessTokenList> {
-    const api = new ApiApi()
-    return api.apiPatchedAccessTokenList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedAutomation.ts b/vue3/src/openapi/models/PatchedAutomation.ts
index a07c9922a..d91854c63 100644
--- a/vue3/src/openapi/models/PatchedAutomation.ts
+++ b/vue3/src/openapi/models/PatchedAutomation.ts
@@ -13,12 +13,13 @@
  */
 
 import { mapValues } from '../runtime';
-import type { TypeEnum } from './TypeEnum';
+import type { AutomationTypeEnum } from './AutomationTypeEnum';
 import {
-    TypeEnumFromJSON,
-    TypeEnumFromJSONTyped,
-    TypeEnumToJSON,
-} from './TypeEnum';
+    AutomationTypeEnumFromJSON,
+    AutomationTypeEnumFromJSONTyped,
+    AutomationTypeEnumToJSON,
+    AutomationTypeEnumToJSONTyped,
+} from './AutomationTypeEnum';
 
 /**
  * 
@@ -34,10 +35,10 @@ export interface PatchedAutomation {
     id?: number;
     /**
      * 
-     * @type {TypeEnum}
+     * @type {AutomationTypeEnum}
      * @memberof PatchedAutomation
      */
-    type?: TypeEnum;
+    type?: AutomationTypeEnum;
     /**
      * 
      * @type {string}
@@ -108,7 +109,7 @@ export function PatchedAutomationFromJSONTyped(json: any, ignoreDiscriminator: b
     return {
         
         'id': json['id'] == null ? undefined : json['id'],
-        'type': json['type'] == null ? undefined : TypeEnumFromJSON(json['type']),
+        'type': json['type'] == null ? undefined : AutomationTypeEnumFromJSON(json['type']),
         'name': json['name'] == null ? undefined : json['name'],
         'description': json['description'] == null ? undefined : json['description'],
         'param1': json['param_1'] == null ? undefined : json['param_1'],
@@ -120,14 +121,19 @@ export function PatchedAutomationFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PatchedAutomationToJSON(value?: Omit<PatchedAutomation, 'created_by'> | null): any {
+export function PatchedAutomationToJSON(json: any): PatchedAutomation {
+    return PatchedAutomationToJSONTyped(json, false);
+}
+
+export function PatchedAutomationToJSONTyped(value?: Omit<PatchedAutomation, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
-        'type': TypeEnumToJSON(value['type']),
+        'type': AutomationTypeEnumToJSON(value['type']),
         'name': value['name'],
         'description': value['description'],
         'param_1': value['param1'],
@@ -137,15 +143,4 @@ export function PatchedAutomationToJSON(value?: Omit<PatchedAutomation, 'created
         'disabled': value['disabled'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedAutomationListRequest, PaginatedPatchedAutomationList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedAutomationListRequest = {}): Promise<PaginatedPatchedAutomationList> {
-    const api = new ApiApi()
-    return api.apiPatchedAutomationList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedBookmarkletImport.ts b/vue3/src/openapi/models/PatchedBookmarkletImport.ts
index e9432286c..a78a0606e 100644
--- a/vue3/src/openapi/models/PatchedBookmarkletImport.ts
+++ b/vue3/src/openapi/models/PatchedBookmarkletImport.ts
@@ -76,10 +76,15 @@ export function PatchedBookmarkletImportFromJSONTyped(json: any, ignoreDiscrimin
     };
 }
 
-export function PatchedBookmarkletImportToJSON(value?: Omit<PatchedBookmarkletImport, 'created_by'|'created_at'> | null): any {
+export function PatchedBookmarkletImportToJSON(json: any): PatchedBookmarkletImport {
+    return PatchedBookmarkletImportToJSONTyped(json, false);
+}
+
+export function PatchedBookmarkletImportToJSONTyped(value?: Omit<PatchedBookmarkletImport, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -87,15 +92,4 @@ export function PatchedBookmarkletImportToJSON(value?: Omit<PatchedBookmarkletIm
         'html': value['html'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedBookmarkletImportListRequest, PaginatedPatchedBookmarkletImportList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedBookmarkletImportListRequest = {}): Promise<PaginatedPatchedBookmarkletImportList> {
-    const api = new ApiApi()
-    return api.apiPatchedBookmarkletImportList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedConnectorConfigConfig.ts b/vue3/src/openapi/models/PatchedConnectorConfigConfig.ts
index a585092ce..ef5a632a7 100644
--- a/vue3/src/openapi/models/PatchedConnectorConfigConfig.ts
+++ b/vue3/src/openapi/models/PatchedConnectorConfigConfig.ts
@@ -118,10 +118,15 @@ export function PatchedConnectorConfigConfigFromJSONTyped(json: any, ignoreDiscr
     };
 }
 
-export function PatchedConnectorConfigConfigToJSON(value?: Omit<PatchedConnectorConfigConfig, 'created_by'> | null): any {
+export function PatchedConnectorConfigConfigToJSON(json: any): PatchedConnectorConfigConfig {
+    return PatchedConnectorConfigConfigToJSONTyped(json, false);
+}
+
+export function PatchedConnectorConfigConfigToJSONTyped(value?: Omit<PatchedConnectorConfigConfig, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -136,15 +141,4 @@ export function PatchedConnectorConfigConfigToJSON(value?: Omit<PatchedConnector
         'supports_description_field': value['supportsDescriptionField'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedConnectorConfigConfigListRequest, PaginatedPatchedConnectorConfigConfigList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedConnectorConfigConfigListRequest = {}): Promise<PaginatedPatchedConnectorConfigConfigList> {
-    const api = new ApiApi()
-    return api.apiPatchedConnectorConfigConfigList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedCookLog.ts b/vue3/src/openapi/models/PatchedCookLog.ts
index 98a5701cc..51cbbec15 100644
--- a/vue3/src/openapi/models/PatchedCookLog.ts
+++ b/vue3/src/openapi/models/PatchedCookLog.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -104,10 +105,15 @@ export function PatchedCookLogFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function PatchedCookLogToJSON(value?: Omit<PatchedCookLog, 'created_by'|'updated_at'> | null): any {
+export function PatchedCookLogToJSON(json: any): PatchedCookLog {
+    return PatchedCookLogToJSONTyped(json, false);
+}
+
+export function PatchedCookLogToJSONTyped(value?: Omit<PatchedCookLog, 'created_by'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -118,15 +124,4 @@ export function PatchedCookLogToJSON(value?: Omit<PatchedCookLog, 'created_by'|'
         'created_at': value['createdAt'] == null ? undefined : ((value['createdAt']).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedCookLogListRequest, PaginatedPatchedCookLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedCookLogListRequest = {}): Promise<PaginatedPatchedCookLogList> {
-    const api = new ApiApi()
-    return api.apiPatchedCookLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedCustomFilter.ts b/vue3/src/openapi/models/PatchedCustomFilter.ts
index 2e76d0922..165b95992 100644
--- a/vue3/src/openapi/models/PatchedCustomFilter.ts
+++ b/vue3/src/openapi/models/PatchedCustomFilter.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -83,10 +84,15 @@ export function PatchedCustomFilterFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PatchedCustomFilterToJSON(value?: Omit<PatchedCustomFilter, 'created_by'> | null): any {
+export function PatchedCustomFilterToJSON(json: any): PatchedCustomFilter {
+    return PatchedCustomFilterToJSONTyped(json, false);
+}
+
+export function PatchedCustomFilterToJSONTyped(value?: Omit<PatchedCustomFilter, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -95,15 +101,4 @@ export function PatchedCustomFilterToJSON(value?: Omit<PatchedCustomFilter, 'cre
         'shared': value['shared'] == null ? undefined : ((value['shared'] as Array<any>).map(UserToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedCustomFilterListRequest, PaginatedPatchedCustomFilterList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedCustomFilterListRequest = {}): Promise<PaginatedPatchedCustomFilterList> {
-    const api = new ApiApi()
-    return api.apiPatchedCustomFilterList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedExportLog.ts b/vue3/src/openapi/models/PatchedExportLog.ts
index 76536d195..ade8a44a6 100644
--- a/vue3/src/openapi/models/PatchedExportLog.ts
+++ b/vue3/src/openapi/models/PatchedExportLog.ts
@@ -111,10 +111,15 @@ export function PatchedExportLogFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function PatchedExportLogToJSON(value?: Omit<PatchedExportLog, 'created_by'|'created_at'> | null): any {
+export function PatchedExportLogToJSON(json: any): PatchedExportLog {
+    return PatchedExportLogToJSONTyped(json, false);
+}
+
+export function PatchedExportLogToJSONTyped(value?: Omit<PatchedExportLog, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -127,15 +132,4 @@ export function PatchedExportLogToJSON(value?: Omit<PatchedExportLog, 'created_b
         'possibly_not_expired': value['possiblyNotExpired'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedExportLogListRequest, PaginatedPatchedExportLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedExportLogListRequest = {}): Promise<PaginatedPatchedExportLogList> {
-    const api = new ApiApi()
-    return api.apiPatchedExportLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedFood.ts b/vue3/src/openapi/models/PatchedFood.ts
index bd409eb5d..d437bb1e3 100644
--- a/vue3/src/openapi/models/PatchedFood.ts
+++ b/vue3/src/openapi/models/PatchedFood.ts
@@ -18,36 +18,42 @@ import {
     SupermarketCategoryFromJSON,
     SupermarketCategoryFromJSONTyped,
     SupermarketCategoryToJSON,
+    SupermarketCategoryToJSONTyped,
 } from './SupermarketCategory';
 import type { Unit } from './Unit';
 import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Property } from './Property';
 import {
     PropertyFromJSON,
     PropertyFromJSONTyped,
     PropertyToJSON,
+    PropertyToJSONTyped,
 } from './Property';
 import type { FoodInheritField } from './FoodInheritField';
 import {
     FoodInheritFieldFromJSON,
     FoodInheritFieldFromJSONTyped,
     FoodInheritFieldToJSON,
+    FoodInheritFieldToJSONTyped,
 } from './FoodInheritField';
 import type { FoodSimple } from './FoodSimple';
 import {
     FoodSimpleFromJSON,
     FoodSimpleFromJSONTyped,
     FoodSimpleToJSON,
+    FoodSimpleToJSONTyped,
 } from './FoodSimple';
 import type { RecipeSimple } from './RecipeSimple';
 import {
     RecipeSimpleFromJSON,
     RecipeSimpleFromJSONTyped,
     RecipeSimpleToJSON,
+    RecipeSimpleToJSONTyped,
 } from './RecipeSimple';
 
 /**
@@ -281,10 +287,15 @@ export function PatchedFoodFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function PatchedFoodToJSON(value?: Omit<PatchedFood, 'shopping'|'parent'|'numchild'|'full_name'|'substitute_onhand'> | null): any {
+export function PatchedFoodToJSON(json: any): PatchedFood {
+    return PatchedFoodToJSONTyped(json, false);
+}
+
+export function PatchedFoodToJSONTyped(value?: Omit<PatchedFood, 'shopping'|'parent'|'numchild'|'full_name'|'substitute_onhand'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -308,15 +319,4 @@ export function PatchedFoodToJSON(value?: Omit<PatchedFood, 'shopping'|'parent'|
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedFoodListRequest, PaginatedPatchedFoodList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedFoodListRequest = {}): Promise<PaginatedPatchedFoodList> {
-    const api = new ApiApi()
-    return api.apiPatchedFoodList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedImportLog.ts b/vue3/src/openapi/models/PatchedImportLog.ts
index 2ca5bd076..85da2a7b9 100644
--- a/vue3/src/openapi/models/PatchedImportLog.ts
+++ b/vue3/src/openapi/models/PatchedImportLog.ts
@@ -18,6 +18,7 @@ import {
     KeywordFromJSON,
     KeywordFromJSONTyped,
     KeywordToJSON,
+    KeywordToJSONTyped,
 } from './Keyword';
 
 /**
@@ -111,10 +112,15 @@ export function PatchedImportLogFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function PatchedImportLogToJSON(value?: Omit<PatchedImportLog, 'keyword'|'created_by'|'created_at'> | null): any {
+export function PatchedImportLogToJSON(json: any): PatchedImportLog {
+    return PatchedImportLogToJSONTyped(json, false);
+}
+
+export function PatchedImportLogToJSONTyped(value?: Omit<PatchedImportLog, 'keyword'|'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -125,15 +131,4 @@ export function PatchedImportLogToJSON(value?: Omit<PatchedImportLog, 'keyword'|
         'imported_recipes': value['importedRecipes'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedImportLogListRequest, PaginatedPatchedImportLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedImportLogListRequest = {}): Promise<PaginatedPatchedImportLogList> {
-    const api = new ApiApi()
-    return api.apiPatchedImportLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedIngredient.ts b/vue3/src/openapi/models/PatchedIngredient.ts
index 571838130..6269b5421 100644
--- a/vue3/src/openapi/models/PatchedIngredient.ts
+++ b/vue3/src/openapi/models/PatchedIngredient.ts
@@ -18,12 +18,14 @@ import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Food } from './Food';
 import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -145,10 +147,15 @@ export function PatchedIngredientFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PatchedIngredientToJSON(value?: Omit<PatchedIngredient, 'conversions'|'used_in_recipes'> | null): any {
+export function PatchedIngredientToJSON(json: any): PatchedIngredient {
+    return PatchedIngredientToJSONTyped(json, false);
+}
+
+export function PatchedIngredientToJSONTyped(value?: Omit<PatchedIngredient, 'conversions'|'used_in_recipes'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -164,15 +171,4 @@ export function PatchedIngredientToJSON(value?: Omit<PatchedIngredient, 'convers
         'always_use_plural_food': value['alwaysUsePluralFood'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedIngredientListRequest, PaginatedPatchedIngredientList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedIngredientListRequest = {}): Promise<PaginatedPatchedIngredientList> {
-    const api = new ApiApi()
-    return api.apiPatchedIngredientList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedInviteLink.ts b/vue3/src/openapi/models/PatchedInviteLink.ts
index dd2820fd9..785811f37 100644
--- a/vue3/src/openapi/models/PatchedInviteLink.ts
+++ b/vue3/src/openapi/models/PatchedInviteLink.ts
@@ -18,6 +18,7 @@ import {
     GroupFromJSON,
     GroupFromJSONTyped,
     GroupToJSON,
+    GroupToJSONTyped,
 } from './Group';
 
 /**
@@ -118,10 +119,15 @@ export function PatchedInviteLinkFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PatchedInviteLinkToJSON(value?: Omit<PatchedInviteLink, 'uuid'|'created_by'|'created_at'> | null): any {
+export function PatchedInviteLinkToJSON(json: any): PatchedInviteLink {
+    return PatchedInviteLinkToJSONTyped(json, false);
+}
+
+export function PatchedInviteLinkToJSONTyped(value?: Omit<PatchedInviteLink, 'uuid'|'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -133,15 +139,4 @@ export function PatchedInviteLinkToJSON(value?: Omit<PatchedInviteLink, 'uuid'|'
         'internal_note': value['internalNote'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedInviteLinkListRequest, PaginatedPatchedInviteLinkList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedInviteLinkListRequest = {}): Promise<PaginatedPatchedInviteLinkList> {
-    const api = new ApiApi()
-    return api.apiPatchedInviteLinkList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedKeyword.ts b/vue3/src/openapi/models/PatchedKeyword.ts
index e953bee28..0df1f9ce2 100644
--- a/vue3/src/openapi/models/PatchedKeyword.ts
+++ b/vue3/src/openapi/models/PatchedKeyword.ts
@@ -139,10 +139,15 @@ export function PatchedKeywordFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function PatchedKeywordToJSON(value?: Omit<PatchedKeyword, 'label'|'parent'|'numchild'|'created_at'|'updated_at'|'full_name'> | null): any {
+export function PatchedKeywordToJSON(json: any): PatchedKeyword {
+    return PatchedKeywordToJSONTyped(json, false);
+}
+
+export function PatchedKeywordToJSONTyped(value?: Omit<PatchedKeyword, 'label'|'parent'|'numchild'|'created_at'|'updated_at'|'full_name'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -150,15 +155,4 @@ export function PatchedKeywordToJSON(value?: Omit<PatchedKeyword, 'label'|'paren
         'description': value['description'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedKeywordListRequest, PaginatedPatchedKeywordList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedKeywordListRequest = {}): Promise<PaginatedPatchedKeywordList> {
-    const api = new ApiApi()
-    return api.apiPatchedKeywordList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedMealPlan.ts b/vue3/src/openapi/models/PatchedMealPlan.ts
index 048505f49..9344eda5c 100644
--- a/vue3/src/openapi/models/PatchedMealPlan.ts
+++ b/vue3/src/openapi/models/PatchedMealPlan.ts
@@ -18,18 +18,21 @@ import {
     MealTypeFromJSON,
     MealTypeFromJSONTyped,
     MealTypeToJSON,
+    MealTypeToJSONTyped,
 } from './MealType';
 import type { User } from './User';
 import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { RecipeOverview } from './RecipeOverview';
 import {
     RecipeOverviewFromJSON,
     RecipeOverviewFromJSONTyped,
     RecipeOverviewToJSON,
+    RecipeOverviewToJSONTyped,
 } from './RecipeOverview';
 
 /**
@@ -158,10 +161,15 @@ export function PatchedMealPlanFromJSONTyped(json: any, ignoreDiscriminator: boo
     };
 }
 
-export function PatchedMealPlanToJSON(value?: Omit<PatchedMealPlan, 'note_markdown'|'created_by'|'recipe_name'|'meal_type_name'|'shopping'> | null): any {
+export function PatchedMealPlanToJSON(json: any): PatchedMealPlan {
+    return PatchedMealPlanToJSONTyped(json, false);
+}
+
+export function PatchedMealPlanToJSONTyped(value?: Omit<PatchedMealPlan, 'note_markdown'|'created_by'|'recipe_name'|'meal_type_name'|'shopping'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -175,15 +183,4 @@ export function PatchedMealPlanToJSON(value?: Omit<PatchedMealPlan, 'note_markdo
         'shared': value['shared'] == null ? undefined : ((value['shared'] as Array<any>).map(UserToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedMealPlanListRequest, PaginatedPatchedMealPlanList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedMealPlanListRequest = {}): Promise<PaginatedPatchedMealPlanList> {
-    const api = new ApiApi()
-    return api.apiPatchedMealPlanList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedMealType.ts b/vue3/src/openapi/models/PatchedMealType.ts
index e2900c12f..5e525fad7 100644
--- a/vue3/src/openapi/models/PatchedMealType.ts
+++ b/vue3/src/openapi/models/PatchedMealType.ts
@@ -90,10 +90,15 @@ export function PatchedMealTypeFromJSONTyped(json: any, ignoreDiscriminator: boo
     };
 }
 
-export function PatchedMealTypeToJSON(value?: Omit<PatchedMealType, 'created_by'> | null): any {
+export function PatchedMealTypeToJSON(json: any): PatchedMealType {
+    return PatchedMealTypeToJSONTyped(json, false);
+}
+
+export function PatchedMealTypeToJSONTyped(value?: Omit<PatchedMealType, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -104,15 +109,4 @@ export function PatchedMealTypeToJSON(value?: Omit<PatchedMealType, 'created_by'
         'default': value['_default'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedMealTypeListRequest, PaginatedPatchedMealTypeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedMealTypeListRequest = {}): Promise<PaginatedPatchedMealTypeList> {
-    const api = new ApiApi()
-    return api.apiPatchedMealTypeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataCategory.ts b/vue3/src/openapi/models/PatchedOpenDataCategory.ts
index 311935c51..61956a1af 100644
--- a/vue3/src/openapi/models/PatchedOpenDataCategory.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataCategory.ts
@@ -18,6 +18,7 @@ import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -131,10 +132,15 @@ export function PatchedOpenDataCategoryFromJSONTyped(json: any, ignoreDiscrimina
     };
 }
 
-export function PatchedOpenDataCategoryToJSON(value?: Omit<PatchedOpenDataCategory, 'created_by'> | null): any {
+export function PatchedOpenDataCategoryToJSON(json: any): PatchedOpenDataCategory {
+    return PatchedOpenDataCategoryToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataCategoryToJSONTyped(value?: Omit<PatchedOpenDataCategory, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -145,15 +151,4 @@ export function PatchedOpenDataCategoryToJSON(value?: Omit<PatchedOpenDataCatego
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataCategoryListRequest, PaginatedPatchedOpenDataCategoryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataCategoryListRequest = {}): Promise<PaginatedPatchedOpenDataCategoryList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataCategoryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataConversion.ts b/vue3/src/openapi/models/PatchedOpenDataConversion.ts
index 57d6567f3..38f2670a5 100644
--- a/vue3/src/openapi/models/PatchedOpenDataConversion.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataConversion.ts
@@ -18,18 +18,21 @@ import {
     OpenDataUnitFromJSON,
     OpenDataUnitFromJSONTyped,
     OpenDataUnitToJSON,
+    OpenDataUnitToJSONTyped,
 } from './OpenDataUnit';
 import type { OpenDataFood } from './OpenDataFood';
 import {
     OpenDataFoodFromJSON,
     OpenDataFoodFromJSONTyped,
     OpenDataFoodToJSON,
+    OpenDataFoodToJSONTyped,
 } from './OpenDataFood';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -137,10 +140,15 @@ export function PatchedOpenDataConversionFromJSONTyped(json: any, ignoreDiscrimi
     };
 }
 
-export function PatchedOpenDataConversionToJSON(value?: Omit<PatchedOpenDataConversion, 'created_by'> | null): any {
+export function PatchedOpenDataConversionToJSON(json: any): PatchedOpenDataConversion {
+    return PatchedOpenDataConversionToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataConversionToJSONTyped(value?: Omit<PatchedOpenDataConversion, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -155,15 +163,4 @@ export function PatchedOpenDataConversionToJSON(value?: Omit<PatchedOpenDataConv
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataConversionListRequest, PaginatedPatchedOpenDataConversionList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataConversionListRequest = {}): Promise<PaginatedPatchedOpenDataConversionList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataConversionList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataFood.ts b/vue3/src/openapi/models/PatchedOpenDataFood.ts
index c49283bb7..73bb60cdb 100644
--- a/vue3/src/openapi/models/PatchedOpenDataFood.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataFood.ts
@@ -18,24 +18,28 @@ import {
     OpenDataFoodPropertyFromJSON,
     OpenDataFoodPropertyFromJSONTyped,
     OpenDataFoodPropertyToJSON,
+    OpenDataFoodPropertyToJSONTyped,
 } from './OpenDataFoodProperty';
 import type { OpenDataUnit } from './OpenDataUnit';
 import {
     OpenDataUnitFromJSON,
     OpenDataUnitFromJSONTyped,
     OpenDataUnitToJSON,
+    OpenDataUnitToJSONTyped,
 } from './OpenDataUnit';
 import type { OpenDataCategory } from './OpenDataCategory';
 import {
     OpenDataCategoryFromJSON,
     OpenDataCategoryFromJSONTyped,
     OpenDataCategoryToJSON,
+    OpenDataCategoryToJSONTyped,
 } from './OpenDataCategory';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -219,10 +223,15 @@ export function PatchedOpenDataFoodFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PatchedOpenDataFoodToJSON(value?: Omit<PatchedOpenDataFood, 'created_by'> | null): any {
+export function PatchedOpenDataFoodToJSON(json: any): PatchedOpenDataFood {
+    return PatchedOpenDataFoodToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataFoodToJSONTyped(value?: Omit<PatchedOpenDataFood, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -243,15 +252,4 @@ export function PatchedOpenDataFoodToJSON(value?: Omit<PatchedOpenDataFood, 'cre
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataFoodListRequest, PaginatedPatchedOpenDataFoodList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataFoodListRequest = {}): Promise<PaginatedPatchedOpenDataFoodList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataFoodList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataProperty.ts b/vue3/src/openapi/models/PatchedOpenDataProperty.ts
index 221f41c04..30782e34f 100644
--- a/vue3/src/openapi/models/PatchedOpenDataProperty.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataProperty.ts
@@ -18,6 +18,7 @@ import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -138,10 +139,15 @@ export function PatchedOpenDataPropertyFromJSONTyped(json: any, ignoreDiscrimina
     };
 }
 
-export function PatchedOpenDataPropertyToJSON(value?: Omit<PatchedOpenDataProperty, 'created_by'> | null): any {
+export function PatchedOpenDataPropertyToJSON(json: any): PatchedOpenDataProperty {
+    return PatchedOpenDataPropertyToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataPropertyToJSONTyped(value?: Omit<PatchedOpenDataProperty, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -153,15 +159,4 @@ export function PatchedOpenDataPropertyToJSON(value?: Omit<PatchedOpenDataProper
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataPropertyListRequest, PaginatedPatchedOpenDataPropertyList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataPropertyListRequest = {}): Promise<PaginatedPatchedOpenDataPropertyList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataPropertyList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataStore.ts b/vue3/src/openapi/models/PatchedOpenDataStore.ts
index 4c8cc05e8..f256aec26 100644
--- a/vue3/src/openapi/models/PatchedOpenDataStore.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataStore.ts
@@ -18,12 +18,14 @@ import {
     OpenDataStoreCategoryFromJSON,
     OpenDataStoreCategoryFromJSONTyped,
     OpenDataStoreCategoryToJSON,
+    OpenDataStoreCategoryToJSONTyped,
 } from './OpenDataStoreCategory';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -103,10 +105,15 @@ export function PatchedOpenDataStoreFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function PatchedOpenDataStoreToJSON(value?: Omit<PatchedOpenDataStore, 'created_by'> | null): any {
+export function PatchedOpenDataStoreToJSON(json: any): PatchedOpenDataStore {
+    return PatchedOpenDataStoreToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataStoreToJSONTyped(value?: Omit<PatchedOpenDataStore, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -117,15 +124,4 @@ export function PatchedOpenDataStoreToJSON(value?: Omit<PatchedOpenDataStore, 'c
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataStoreListRequest, PaginatedPatchedOpenDataStoreList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataStoreListRequest = {}): Promise<PaginatedPatchedOpenDataStoreList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataStoreList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataUnit.ts b/vue3/src/openapi/models/PatchedOpenDataUnit.ts
index de74ef0cb..3a68b9637 100644
--- a/vue3/src/openapi/models/PatchedOpenDataUnit.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataUnit.ts
@@ -18,18 +18,21 @@ import {
     BaseUnitEnumFromJSON,
     BaseUnitEnumFromJSONTyped,
     BaseUnitEnumToJSON,
+    BaseUnitEnumToJSONTyped,
 } from './BaseUnitEnum';
 import type { OpenDataUnitTypeEnum } from './OpenDataUnitTypeEnum';
 import {
     OpenDataUnitTypeEnumFromJSON,
     OpenDataUnitTypeEnumFromJSONTyped,
     OpenDataUnitTypeEnumToJSON,
+    OpenDataUnitTypeEnumToJSONTyped,
 } from './OpenDataUnitTypeEnum';
 import type { OpenDataVersion } from './OpenDataVersion';
 import {
     OpenDataVersionFromJSON,
     OpenDataVersionFromJSONTyped,
     OpenDataVersionToJSON,
+    OpenDataVersionToJSONTyped,
 } from './OpenDataVersion';
 
 /**
@@ -159,10 +162,15 @@ export function PatchedOpenDataUnitFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PatchedOpenDataUnitToJSON(value?: Omit<PatchedOpenDataUnit, 'created_by'> | null): any {
+export function PatchedOpenDataUnitToJSON(json: any): PatchedOpenDataUnit {
+    return PatchedOpenDataUnitToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataUnitToJSONTyped(value?: Omit<PatchedOpenDataUnit, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -175,15 +183,4 @@ export function PatchedOpenDataUnitToJSON(value?: Omit<PatchedOpenDataUnit, 'cre
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataUnitListRequest, PaginatedPatchedOpenDataUnitList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataUnitListRequest = {}): Promise<PaginatedPatchedOpenDataUnitList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataUnitList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedOpenDataVersion.ts b/vue3/src/openapi/models/PatchedOpenDataVersion.ts
index a10b0d458..038ae566c 100644
--- a/vue3/src/openapi/models/PatchedOpenDataVersion.ts
+++ b/vue3/src/openapi/models/PatchedOpenDataVersion.ts
@@ -103,10 +103,15 @@ export function PatchedOpenDataVersionFromJSONTyped(json: any, ignoreDiscriminat
     };
 }
 
-export function PatchedOpenDataVersionToJSON(value?: PatchedOpenDataVersion | null): any {
+export function PatchedOpenDataVersionToJSON(json: any): PatchedOpenDataVersion {
+    return PatchedOpenDataVersionToJSONTyped(json, false);
+}
+
+export function PatchedOpenDataVersionToJSONTyped(value?: PatchedOpenDataVersion | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -115,15 +120,4 @@ export function PatchedOpenDataVersionToJSON(value?: PatchedOpenDataVersion | nu
         'comment': value['comment'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedOpenDataVersionListRequest, PaginatedPatchedOpenDataVersionList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedOpenDataVersionListRequest = {}): Promise<PaginatedPatchedOpenDataVersionList> {
-    const api = new ApiApi()
-    return api.apiPatchedOpenDataVersionList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedProperty.ts b/vue3/src/openapi/models/PatchedProperty.ts
index caec1f650..42225374d 100644
--- a/vue3/src/openapi/models/PatchedProperty.ts
+++ b/vue3/src/openapi/models/PatchedProperty.ts
@@ -18,6 +18,7 @@ import {
     PropertyTypeFromJSON,
     PropertyTypeFromJSONTyped,
     PropertyTypeToJSON,
+    PropertyTypeToJSONTyped,
 } from './PropertyType';
 
 /**
@@ -103,10 +104,15 @@ export function PatchedPropertyFromJSONTyped(json: any, ignoreDiscriminator: boo
     };
 }
 
-export function PatchedPropertyToJSON(value?: PatchedProperty | null): any {
+export function PatchedPropertyToJSON(json: any): PatchedProperty {
+    return PatchedPropertyToJSONTyped(json, false);
+}
+
+export function PatchedPropertyToJSONTyped(value?: PatchedProperty | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -114,15 +120,4 @@ export function PatchedPropertyToJSON(value?: PatchedProperty | null): any {
         'property_type': PropertyTypeToJSON(value['propertyType']),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedPropertyListRequest, PaginatedPatchedPropertyList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedPropertyListRequest = {}): Promise<PaginatedPatchedPropertyList> {
-    const api = new ApiApi()
-    return api.apiPatchedPropertyList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedPropertyType.ts b/vue3/src/openapi/models/PatchedPropertyType.ts
index fba3297ac..813393633 100644
--- a/vue3/src/openapi/models/PatchedPropertyType.ts
+++ b/vue3/src/openapi/models/PatchedPropertyType.ts
@@ -90,10 +90,15 @@ export function PatchedPropertyTypeFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PatchedPropertyTypeToJSON(value?: PatchedPropertyType | null): any {
+export function PatchedPropertyTypeToJSON(json: any): PatchedPropertyType {
+    return PatchedPropertyTypeToJSONTyped(json, false);
+}
+
+export function PatchedPropertyTypeToJSONTyped(value?: PatchedPropertyType | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -105,15 +110,4 @@ export function PatchedPropertyTypeToJSON(value?: PatchedPropertyType | null): a
         'fdc_id': value['fdcId'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedPropertyTypeListRequest, PaginatedPatchedPropertyTypeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedPropertyTypeListRequest = {}): Promise<PaginatedPatchedPropertyTypeList> {
-    const api = new ApiApi()
-    return api.apiPatchedPropertyTypeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedRecipe.ts b/vue3/src/openapi/models/PatchedRecipe.ts
index 333c74888..83b48bdc0 100644
--- a/vue3/src/openapi/models/PatchedRecipe.ts
+++ b/vue3/src/openapi/models/PatchedRecipe.ts
@@ -18,30 +18,35 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { Keyword } from './Keyword';
 import {
     KeywordFromJSON,
     KeywordFromJSONTyped,
     KeywordToJSON,
+    KeywordToJSONTyped,
 } from './Keyword';
 import type { Step } from './Step';
 import {
     StepFromJSON,
     StepFromJSONTyped,
     StepToJSON,
+    StepToJSONTyped,
 } from './Step';
 import type { Property } from './Property';
 import {
     PropertyFromJSON,
     PropertyFromJSONTyped,
     PropertyToJSON,
+    PropertyToJSONTyped,
 } from './Property';
 import type { NutritionInformation } from './NutritionInformation';
 import {
     NutritionInformationFromJSON,
     NutritionInformationFromJSONTyped,
     NutritionInformationToJSON,
+    NutritionInformationToJSONTyped,
 } from './NutritionInformation';
 
 /**
@@ -240,10 +245,15 @@ export function PatchedRecipeFromJSONTyped(json: any, ignoreDiscriminator: boole
     };
 }
 
-export function PatchedRecipeToJSON(value?: Omit<PatchedRecipe, 'image'|'created_by'|'created_at'|'updated_at'|'food_properties'|'rating'|'last_cooked'> | null): any {
+export function PatchedRecipeToJSON(json: any): PatchedRecipe {
+    return PatchedRecipeToJSONTyped(json, false);
+}
+
+export function PatchedRecipeToJSONTyped(value?: Omit<PatchedRecipe, 'image'|'created_by'|'created_at'|'updated_at'|'food_properties'|'rating'|'last_cooked'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -265,15 +275,4 @@ export function PatchedRecipeToJSON(value?: Omit<PatchedRecipe, 'image'|'created
         'shared': value['shared'] == null ? undefined : ((value['shared'] as Array<any>).map(UserToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedRecipeListRequest, PaginatedPatchedRecipeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedRecipeListRequest = {}): Promise<PaginatedPatchedRecipeList> {
-    const api = new ApiApi()
-    return api.apiPatchedRecipeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedRecipeBook.ts b/vue3/src/openapi/models/PatchedRecipeBook.ts
index 476b465e0..620f995ad 100644
--- a/vue3/src/openapi/models/PatchedRecipeBook.ts
+++ b/vue3/src/openapi/models/PatchedRecipeBook.ts
@@ -18,12 +18,14 @@ import {
     CustomFilterFromJSON,
     CustomFilterFromJSONTyped,
     CustomFilterToJSON,
+    CustomFilterToJSONTyped,
 } from './CustomFilter';
 import type { User } from './User';
 import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -103,10 +105,15 @@ export function PatchedRecipeBookFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function PatchedRecipeBookToJSON(value?: Omit<PatchedRecipeBook, 'created_by'> | null): any {
+export function PatchedRecipeBookToJSON(json: any): PatchedRecipeBook {
+    return PatchedRecipeBookToJSONTyped(json, false);
+}
+
+export function PatchedRecipeBookToJSONTyped(value?: Omit<PatchedRecipeBook, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -117,15 +124,4 @@ export function PatchedRecipeBookToJSON(value?: Omit<PatchedRecipeBook, 'created
         'order': value['order'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedRecipeBookListRequest, PaginatedPatchedRecipeBookList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedRecipeBookListRequest = {}): Promise<PaginatedPatchedRecipeBookList> {
-    const api = new ApiApi()
-    return api.apiPatchedRecipeBookList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedRecipeBookEntry.ts b/vue3/src/openapi/models/PatchedRecipeBookEntry.ts
index 3a52e7192..462690216 100644
--- a/vue3/src/openapi/models/PatchedRecipeBookEntry.ts
+++ b/vue3/src/openapi/models/PatchedRecipeBookEntry.ts
@@ -18,12 +18,14 @@ import {
     RecipeBookFromJSON,
     RecipeBookFromJSONTyped,
     RecipeBookToJSON,
+    RecipeBookToJSONTyped,
 } from './RecipeBook';
 import type { RecipeOverview } from './RecipeOverview';
 import {
     RecipeOverviewFromJSON,
     RecipeOverviewFromJSONTyped,
     RecipeOverviewToJSON,
+    RecipeOverviewToJSONTyped,
 } from './RecipeOverview';
 
 /**
@@ -89,10 +91,15 @@ export function PatchedRecipeBookEntryFromJSONTyped(json: any, ignoreDiscriminat
     };
 }
 
-export function PatchedRecipeBookEntryToJSON(value?: Omit<PatchedRecipeBookEntry, 'book_content'|'recipe_content'> | null): any {
+export function PatchedRecipeBookEntryToJSON(json: any): PatchedRecipeBookEntry {
+    return PatchedRecipeBookEntryToJSONTyped(json, false);
+}
+
+export function PatchedRecipeBookEntryToJSONTyped(value?: Omit<PatchedRecipeBookEntry, 'book_content'|'recipe_content'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -100,15 +107,4 @@ export function PatchedRecipeBookEntryToJSON(value?: Omit<PatchedRecipeBookEntry
         'recipe': value['recipe'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedRecipeBookEntryListRequest, PaginatedPatchedRecipeBookEntryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedRecipeBookEntryListRequest = {}): Promise<PaginatedPatchedRecipeBookEntryList> {
-    const api = new ApiApi()
-    return api.apiPatchedRecipeBookEntryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedShoppingListEntry.ts b/vue3/src/openapi/models/PatchedShoppingListEntry.ts
index 61327bd92..48b19cfa2 100644
--- a/vue3/src/openapi/models/PatchedShoppingListEntry.ts
+++ b/vue3/src/openapi/models/PatchedShoppingListEntry.ts
@@ -18,24 +18,28 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { ShoppingListRecipe } from './ShoppingListRecipe';
 import {
     ShoppingListRecipeFromJSON,
     ShoppingListRecipeFromJSONTyped,
     ShoppingListRecipeToJSON,
+    ShoppingListRecipeToJSONTyped,
 } from './ShoppingListRecipe';
 import type { Unit } from './Unit';
 import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Food } from './Food';
 import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -157,10 +161,15 @@ export function PatchedShoppingListEntryFromJSONTyped(json: any, ignoreDiscrimin
     };
 }
 
-export function PatchedShoppingListEntryToJSON(value?: Omit<PatchedShoppingListEntry, 'recipe_mealplan'|'created_by'|'created_at'|'updated_at'> | null): any {
+export function PatchedShoppingListEntryToJSON(json: any): PatchedShoppingListEntry {
+    return PatchedShoppingListEntryToJSONTyped(json, false);
+}
+
+export function PatchedShoppingListEntryToJSONTyped(value?: Omit<PatchedShoppingListEntry, 'recipe_mealplan'|'created_by'|'created_at'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -174,15 +183,4 @@ export function PatchedShoppingListEntryToJSON(value?: Omit<PatchedShoppingListE
         'delay_until': value['delayUntil'] == null ? undefined : ((value['delayUntil'] as any).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedShoppingListEntryListRequest, PaginatedPatchedShoppingListEntryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedShoppingListEntryListRequest = {}): Promise<PaginatedPatchedShoppingListEntryList> {
-    const api = new ApiApi()
-    return api.apiPatchedShoppingListEntryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedShoppingListRecipe.ts b/vue3/src/openapi/models/PatchedShoppingListRecipe.ts
index 8cf38e04d..08921084a 100644
--- a/vue3/src/openapi/models/PatchedShoppingListRecipe.ts
+++ b/vue3/src/openapi/models/PatchedShoppingListRecipe.ts
@@ -104,10 +104,15 @@ export function PatchedShoppingListRecipeFromJSONTyped(json: any, ignoreDiscrimi
     };
 }
 
-export function PatchedShoppingListRecipeToJSON(value?: Omit<PatchedShoppingListRecipe, 'recipe_name'|'name'|'mealplan_note'|'mealplan_from_date'|'mealplan_type'> | null): any {
+export function PatchedShoppingListRecipeToJSON(json: any): PatchedShoppingListRecipe {
+    return PatchedShoppingListRecipeToJSONTyped(json, false);
+}
+
+export function PatchedShoppingListRecipeToJSONTyped(value?: Omit<PatchedShoppingListRecipe, 'recipe_name'|'name'|'mealplan_note'|'mealplan_from_date'|'mealplan_type'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -116,15 +121,4 @@ export function PatchedShoppingListRecipeToJSON(value?: Omit<PatchedShoppingList
         'servings': value['servings'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedShoppingListRecipeListRequest, PaginatedPatchedShoppingListRecipeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedShoppingListRecipeListRequest = {}): Promise<PaginatedPatchedShoppingListRecipeList> {
-    const api = new ApiApi()
-    return api.apiPatchedShoppingListRecipeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedSpace.ts b/vue3/src/openapi/models/PatchedSpace.ts
index ceb0fe7df..935e0da40 100644
--- a/vue3/src/openapi/models/PatchedSpace.ts
+++ b/vue3/src/openapi/models/PatchedSpace.ts
@@ -18,30 +18,35 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { UserFileView } from './UserFileView';
 import {
     UserFileViewFromJSON,
     UserFileViewFromJSONTyped,
     UserFileViewToJSON,
+    UserFileViewToJSONTyped,
 } from './UserFileView';
 import type { SpaceNavTextColorEnum } from './SpaceNavTextColorEnum';
 import {
     SpaceNavTextColorEnumFromJSON,
     SpaceNavTextColorEnumFromJSONTyped,
     SpaceNavTextColorEnumToJSON,
+    SpaceNavTextColorEnumToJSONTyped,
 } from './SpaceNavTextColorEnum';
 import type { FoodInheritField } from './FoodInheritField';
 import {
     FoodInheritFieldFromJSON,
     FoodInheritFieldFromJSONTyped,
     FoodInheritFieldToJSON,
+    FoodInheritFieldToJSONTyped,
 } from './FoodInheritField';
 import type { SpaceThemeEnum } from './SpaceThemeEnum';
 import {
     SpaceThemeEnumFromJSON,
     SpaceThemeEnumFromJSONTyped,
     SpaceThemeEnumToJSON,
+    SpaceThemeEnumToJSONTyped,
 } from './SpaceThemeEnum';
 
 /**
@@ -263,10 +268,15 @@ export function PatchedSpaceFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function PatchedSpaceToJSON(value?: Omit<PatchedSpace, 'created_by'|'created_at'|'max_recipes'|'max_file_storage_mb'|'max_users'|'allow_sharing'|'demo'|'user_count'|'recipe_count'|'file_size_mb'> | null): any {
+export function PatchedSpaceToJSON(json: any): PatchedSpace {
+    return PatchedSpaceToJSONTyped(json, false);
+}
+
+export function PatchedSpaceToJSONTyped(value?: Omit<PatchedSpace, 'created_by'|'created_at'|'max_recipes'|'max_file_storage_mb'|'max_users'|'allow_sharing'|'demo'|'user_count'|'recipe_count'|'file_size_mb'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -288,15 +298,4 @@ export function PatchedSpaceToJSON(value?: Omit<PatchedSpace, 'created_by'|'crea
         'logo_color_svg': UserFileViewToJSON(value['logoColorSvg']),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedSpaceListRequest, PaginatedPatchedSpaceList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedSpaceListRequest = {}): Promise<PaginatedPatchedSpaceList> {
-    const api = new ApiApi()
-    return api.apiPatchedSpaceList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedStep.ts b/vue3/src/openapi/models/PatchedStep.ts
index 3bccbef3b..0245cbda2 100644
--- a/vue3/src/openapi/models/PatchedStep.ts
+++ b/vue3/src/openapi/models/PatchedStep.ts
@@ -18,12 +18,14 @@ import {
     UserFileViewFromJSON,
     UserFileViewFromJSONTyped,
     UserFileViewToJSON,
+    UserFileViewToJSONTyped,
 } from './UserFileView';
 import type { Ingredient } from './Ingredient';
 import {
     IngredientFromJSON,
     IngredientFromJSONTyped,
     IngredientToJSON,
+    IngredientToJSONTyped,
 } from './Ingredient';
 
 /**
@@ -145,10 +147,15 @@ export function PatchedStepFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function PatchedStepToJSON(value?: Omit<PatchedStep, 'instructions_markdown'|'step_recipe_data'|'numrecipe'> | null): any {
+export function PatchedStepToJSON(json: any): PatchedStep {
+    return PatchedStepToJSONTyped(json, false);
+}
+
+export function PatchedStepToJSONTyped(value?: Omit<PatchedStep, 'instructions_markdown'|'step_recipe_data'|'numrecipe'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -163,15 +170,4 @@ export function PatchedStepToJSON(value?: Omit<PatchedStep, 'instructions_markdo
         'show_ingredients_table': value['showIngredientsTable'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedStepListRequest, PaginatedPatchedStepList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedStepListRequest = {}): Promise<PaginatedPatchedStepList> {
-    const api = new ApiApi()
-    return api.apiPatchedStepList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedStorage.ts b/vue3/src/openapi/models/PatchedStorage.ts
index 8094a0690..bf7019f23 100644
--- a/vue3/src/openapi/models/PatchedStorage.ts
+++ b/vue3/src/openapi/models/PatchedStorage.ts
@@ -18,6 +18,7 @@ import {
     MethodEnumFromJSON,
     MethodEnumFromJSONTyped,
     MethodEnumToJSON,
+    MethodEnumToJSONTyped,
 } from './MethodEnum';
 
 /**
@@ -99,10 +100,15 @@ export function PatchedStorageFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function PatchedStorageToJSON(value?: Omit<PatchedStorage, 'created_by'> | null): any {
+export function PatchedStorageToJSON(json: any): PatchedStorage {
+    return PatchedStorageToJSONTyped(json, false);
+}
+
+export function PatchedStorageToJSONTyped(value?: Omit<PatchedStorage, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -113,15 +119,4 @@ export function PatchedStorageToJSON(value?: Omit<PatchedStorage, 'created_by'>
         'token': value['token'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedStorageListRequest, PaginatedPatchedStorageList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedStorageListRequest = {}): Promise<PaginatedPatchedStorageList> {
-    const api = new ApiApi()
-    return api.apiPatchedStorageList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedSupermarket.ts b/vue3/src/openapi/models/PatchedSupermarket.ts
index d60bc2935..62ffa63d9 100644
--- a/vue3/src/openapi/models/PatchedSupermarket.ts
+++ b/vue3/src/openapi/models/PatchedSupermarket.ts
@@ -18,6 +18,7 @@ import {
     SupermarketCategoryRelationFromJSON,
     SupermarketCategoryRelationFromJSONTyped,
     SupermarketCategoryRelationToJSON,
+    SupermarketCategoryRelationToJSONTyped,
 } from './SupermarketCategoryRelation';
 
 /**
@@ -117,10 +118,15 @@ export function PatchedSupermarketFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function PatchedSupermarketToJSON(value?: Omit<PatchedSupermarket, 'category_to_supermarket'> | null): any {
+export function PatchedSupermarketToJSON(json: any): PatchedSupermarket {
+    return PatchedSupermarketToJSONTyped(json, false);
+}
+
+export function PatchedSupermarketToJSONTyped(value?: Omit<PatchedSupermarket, 'category_to_supermarket'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -129,15 +135,4 @@ export function PatchedSupermarketToJSON(value?: Omit<PatchedSupermarket, 'categ
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedSupermarketListRequest, PaginatedPatchedSupermarketList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedSupermarketListRequest = {}): Promise<PaginatedPatchedSupermarketList> {
-    const api = new ApiApi()
-    return api.apiPatchedSupermarketList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedSupermarketCategory.ts b/vue3/src/openapi/models/PatchedSupermarketCategory.ts
index f847a278f..77aa0d2e6 100644
--- a/vue3/src/openapi/models/PatchedSupermarketCategory.ts
+++ b/vue3/src/openapi/models/PatchedSupermarketCategory.ts
@@ -96,10 +96,15 @@ export function PatchedSupermarketCategoryFromJSONTyped(json: any, ignoreDiscrim
     };
 }
 
-export function PatchedSupermarketCategoryToJSON(value?: PatchedSupermarketCategory | null): any {
+export function PatchedSupermarketCategoryToJSON(json: any): PatchedSupermarketCategory {
+    return PatchedSupermarketCategoryToJSONTyped(json, false);
+}
+
+export function PatchedSupermarketCategoryToJSONTyped(value?: PatchedSupermarketCategory | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -107,15 +112,4 @@ export function PatchedSupermarketCategoryToJSON(value?: PatchedSupermarketCateg
         'description': value['description'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedSupermarketCategoryListRequest, PaginatedPatchedSupermarketCategoryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedSupermarketCategoryListRequest = {}): Promise<PaginatedPatchedSupermarketCategoryList> {
-    const api = new ApiApi()
-    return api.apiPatchedSupermarketCategoryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedSupermarketCategoryRelation.ts b/vue3/src/openapi/models/PatchedSupermarketCategoryRelation.ts
index 4fc7b3889..1b117a7a9 100644
--- a/vue3/src/openapi/models/PatchedSupermarketCategoryRelation.ts
+++ b/vue3/src/openapi/models/PatchedSupermarketCategoryRelation.ts
@@ -18,6 +18,7 @@ import {
     SupermarketCategoryFromJSON,
     SupermarketCategoryFromJSONTyped,
     SupermarketCategoryToJSON,
+    SupermarketCategoryToJSONTyped,
 } from './SupermarketCategory';
 
 /**
@@ -76,10 +77,15 @@ export function PatchedSupermarketCategoryRelationFromJSONTyped(json: any, ignor
     };
 }
 
-export function PatchedSupermarketCategoryRelationToJSON(value?: PatchedSupermarketCategoryRelation | null): any {
+export function PatchedSupermarketCategoryRelationToJSON(json: any): PatchedSupermarketCategoryRelation {
+    return PatchedSupermarketCategoryRelationToJSONTyped(json, false);
+}
+
+export function PatchedSupermarketCategoryRelationToJSONTyped(value?: PatchedSupermarketCategoryRelation | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -88,15 +94,4 @@ export function PatchedSupermarketCategoryRelationToJSON(value?: PatchedSupermar
         'order': value['order'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedSupermarketCategoryRelationListRequest, PaginatedPatchedSupermarketCategoryRelationList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedSupermarketCategoryRelationListRequest = {}): Promise<PaginatedPatchedSupermarketCategoryRelationList> {
-    const api = new ApiApi()
-    return api.apiPatchedSupermarketCategoryRelationList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedSync.ts b/vue3/src/openapi/models/PatchedSync.ts
index 4ec664571..3dd6840bd 100644
--- a/vue3/src/openapi/models/PatchedSync.ts
+++ b/vue3/src/openapi/models/PatchedSync.ts
@@ -90,10 +90,15 @@ export function PatchedSyncFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function PatchedSyncToJSON(value?: Omit<PatchedSync, 'created_at'|'updated_at'> | null): any {
+export function PatchedSyncToJSON(json: any): PatchedSync {
+    return PatchedSyncToJSONTyped(json, false);
+}
+
+export function PatchedSyncToJSONTyped(value?: Omit<PatchedSync, 'created_at'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -103,15 +108,4 @@ export function PatchedSyncToJSON(value?: Omit<PatchedSync, 'created_at'|'update
         'last_checked': value['lastChecked'] == null ? undefined : ((value['lastChecked'] as any).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedSyncListRequest, PaginatedPatchedSyncList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedSyncListRequest = {}): Promise<PaginatedPatchedSyncList> {
-    const api = new ApiApi()
-    return api.apiPatchedSyncList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedUnit.ts b/vue3/src/openapi/models/PatchedUnit.ts
index 7ca50b287..e50ebc3fa 100644
--- a/vue3/src/openapi/models/PatchedUnit.ts
+++ b/vue3/src/openapi/models/PatchedUnit.ts
@@ -117,10 +117,15 @@ export function PatchedUnitFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function PatchedUnitToJSON(value?: PatchedUnit | null): any {
+export function PatchedUnitToJSON(json: any): PatchedUnit {
+    return PatchedUnitToJSONTyped(json, false);
+}
+
+export function PatchedUnitToJSONTyped(value?: PatchedUnit | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -131,15 +136,4 @@ export function PatchedUnitToJSON(value?: PatchedUnit | null): any {
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedUnitListRequest, PaginatedPatchedUnitList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedUnitListRequest = {}): Promise<PaginatedPatchedUnitList> {
-    const api = new ApiApi()
-    return api.apiPatchedUnitList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedUnitConversion.ts b/vue3/src/openapi/models/PatchedUnitConversion.ts
index 89175e323..9d4f682e1 100644
--- a/vue3/src/openapi/models/PatchedUnitConversion.ts
+++ b/vue3/src/openapi/models/PatchedUnitConversion.ts
@@ -18,12 +18,14 @@ import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Food } from './Food';
 import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -110,10 +112,15 @@ export function PatchedUnitConversionFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function PatchedUnitConversionToJSON(value?: Omit<PatchedUnitConversion, 'name'> | null): any {
+export function PatchedUnitConversionToJSON(json: any): PatchedUnitConversion {
+    return PatchedUnitConversionToJSONTyped(json, false);
+}
+
+export function PatchedUnitConversionToJSONTyped(value?: Omit<PatchedUnitConversion, 'name'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -125,15 +132,4 @@ export function PatchedUnitConversionToJSON(value?: Omit<PatchedUnitConversion,
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedUnitConversionListRequest, PaginatedPatchedUnitConversionList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedUnitConversionListRequest = {}): Promise<PaginatedPatchedUnitConversionList> {
-    const api = new ApiApi()
-    return api.apiPatchedUnitConversionList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedUser.ts b/vue3/src/openapi/models/PatchedUser.ts
index 1f2493ea5..f15c386dd 100644
--- a/vue3/src/openapi/models/PatchedUser.ts
+++ b/vue3/src/openapi/models/PatchedUser.ts
@@ -76,10 +76,15 @@ export function PatchedUserFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function PatchedUserToJSON(value?: Omit<PatchedUser, 'username'|'display_name'> | null): any {
+export function PatchedUserToJSON(json: any): PatchedUser {
+    return PatchedUserToJSONTyped(json, false);
+}
+
+export function PatchedUserToJSONTyped(value?: Omit<PatchedUser, 'username'|'display_name'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -87,15 +92,4 @@ export function PatchedUserToJSON(value?: Omit<PatchedUser, 'username'|'display_
         'last_name': value['lastName'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedUserListRequest, PaginatedPatchedUserList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedUserListRequest = {}): Promise<PaginatedPatchedUserList> {
-    const api = new ApiApi()
-    return api.apiPatchedUserList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedUserPreference.ts b/vue3/src/openapi/models/PatchedUserPreference.ts
index bea43f04b..b06f0a06c 100644
--- a/vue3/src/openapi/models/PatchedUserPreference.ts
+++ b/vue3/src/openapi/models/PatchedUserPreference.ts
@@ -18,36 +18,42 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { UserFileView } from './UserFileView';
 import {
     UserFileViewFromJSON,
     UserFileViewFromJSONTyped,
     UserFileViewToJSON,
+    UserFileViewToJSONTyped,
 } from './UserFileView';
 import type { UserPreferenceNavTextColorEnum } from './UserPreferenceNavTextColorEnum';
 import {
     UserPreferenceNavTextColorEnumFromJSON,
     UserPreferenceNavTextColorEnumFromJSONTyped,
     UserPreferenceNavTextColorEnumToJSON,
+    UserPreferenceNavTextColorEnumToJSONTyped,
 } from './UserPreferenceNavTextColorEnum';
 import type { FoodInheritField } from './FoodInheritField';
 import {
     FoodInheritFieldFromJSON,
     FoodInheritFieldFromJSONTyped,
     FoodInheritFieldToJSON,
+    FoodInheritFieldToJSONTyped,
 } from './FoodInheritField';
 import type { ThemeEnum } from './ThemeEnum';
 import {
     ThemeEnumFromJSON,
     ThemeEnumFromJSONTyped,
     ThemeEnumToJSON,
+    ThemeEnumToJSONTyped,
 } from './ThemeEnum';
 import type { DefaultPageEnum } from './DefaultPageEnum';
 import {
     DefaultPageEnumFromJSON,
     DefaultPageEnumFromJSONTyped,
     DefaultPageEnumToJSON,
+    DefaultPageEnumToJSONTyped,
 } from './DefaultPageEnum';
 
 /**
@@ -283,10 +289,15 @@ export function PatchedUserPreferenceFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function PatchedUserPreferenceToJSON(value?: Omit<PatchedUserPreference, 'food_inherit_default'|'food_children_exist'> | null): any {
+export function PatchedUserPreferenceToJSON(json: any): PatchedUserPreference {
+    return PatchedUserPreferenceToJSONTyped(json, false);
+}
+
+export function PatchedUserPreferenceToJSONTyped(value?: Omit<PatchedUserPreference, 'food_inherit_default'|'food_children_exist'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'user': value['user'],
@@ -318,15 +329,4 @@ export function PatchedUserPreferenceToJSON(value?: Omit<PatchedUserPreference,
         'show_step_ingredients': value['showStepIngredients'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedUserPreferenceListRequest, PaginatedPatchedUserPreferenceList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedUserPreferenceListRequest = {}): Promise<PaginatedPatchedUserPreferenceList> {
-    const api = new ApiApi()
-    return api.apiPatchedUserPreferenceList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedUserSpace.ts b/vue3/src/openapi/models/PatchedUserSpace.ts
index f9e1a191a..641b2ca91 100644
--- a/vue3/src/openapi/models/PatchedUserSpace.ts
+++ b/vue3/src/openapi/models/PatchedUserSpace.ts
@@ -18,12 +18,14 @@ import {
     GroupFromJSON,
     GroupFromJSONTyped,
     GroupToJSON,
+    GroupToJSONTyped,
 } from './Group';
 import type { User } from './User';
 import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -117,10 +119,15 @@ export function PatchedUserSpaceFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function PatchedUserSpaceToJSON(value?: Omit<PatchedUserSpace, 'user'|'space'|'invite_link'|'created_at'|'updated_at'> | null): any {
+export function PatchedUserSpaceToJSON(json: any): PatchedUserSpace {
+    return PatchedUserSpaceToJSONTyped(json, false);
+}
+
+export function PatchedUserSpaceToJSONTyped(value?: Omit<PatchedUserSpace, 'user'|'space'|'invite_link'|'created_at'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -129,15 +136,4 @@ export function PatchedUserSpaceToJSON(value?: Omit<PatchedUserSpace, 'user'|'sp
         'internal_note': value['internalNote'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedUserSpaceListRequest, PaginatedPatchedUserSpaceList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedUserSpaceListRequest = {}): Promise<PaginatedPatchedUserSpaceList> {
-    const api = new ApiApi()
-    return api.apiPatchedUserSpaceList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PatchedViewLog.ts b/vue3/src/openapi/models/PatchedViewLog.ts
index d85dfdb16..f634bd621 100644
--- a/vue3/src/openapi/models/PatchedViewLog.ts
+++ b/vue3/src/openapi/models/PatchedViewLog.ts
@@ -69,25 +69,19 @@ export function PatchedViewLogFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function PatchedViewLogToJSON(value?: Omit<PatchedViewLog, 'created_by'|'created_at'> | null): any {
+export function PatchedViewLogToJSON(json: any): PatchedViewLog {
+    return PatchedViewLogToJSONTyped(json, false);
+}
+
+export function PatchedViewLogToJSONTyped(value?: Omit<PatchedViewLog, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
         'recipe': value['recipe'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPatchedViewLogListRequest, PaginatedPatchedViewLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPatchedViewLogListRequest = {}): Promise<PaginatedPatchedViewLogList> {
-    const api = new ApiApi()
-    return api.apiPatchedViewLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Property.ts b/vue3/src/openapi/models/Property.ts
index 68ae67ac0..23097d8f1 100644
--- a/vue3/src/openapi/models/Property.ts
+++ b/vue3/src/openapi/models/Property.ts
@@ -18,6 +18,7 @@ import {
     PropertyTypeFromJSON,
     PropertyTypeFromJSONTyped,
     PropertyTypeToJSON,
+    PropertyTypeToJSONTyped,
 } from './PropertyType';
 
 /**
@@ -105,10 +106,15 @@ export function PropertyFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function PropertyToJSON(value?: Property | null): any {
+export function PropertyToJSON(json: any): Property {
+    return PropertyToJSONTyped(json, false);
+}
+
+export function PropertyToJSONTyped(value?: Property | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -116,15 +122,4 @@ export function PropertyToJSON(value?: Property | null): any {
         'property_type': PropertyTypeToJSON(value['propertyType']),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPropertyListRequest, PaginatedPropertyList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPropertyListRequest = {}): Promise<PaginatedPropertyList> {
-    const api = new ApiApi()
-    return api.apiPropertyList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/PropertyType.ts b/vue3/src/openapi/models/PropertyType.ts
index 27eb7d53e..aed86b364 100644
--- a/vue3/src/openapi/models/PropertyType.ts
+++ b/vue3/src/openapi/models/PropertyType.ts
@@ -91,10 +91,15 @@ export function PropertyTypeFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function PropertyTypeToJSON(value?: PropertyType | null): any {
+export function PropertyTypeToJSON(json: any): PropertyType {
+    return PropertyTypeToJSONTyped(json, false);
+}
+
+export function PropertyTypeToJSONTyped(value?: PropertyType | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -106,15 +111,4 @@ export function PropertyTypeToJSON(value?: PropertyType | null): any {
         'fdc_id': value['fdcId'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiPropertyTypeListRequest, PaginatedPropertyTypeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiPropertyTypeListRequest = {}): Promise<PaginatedPropertyTypeList> {
-    const api = new ApiApi()
-    return api.apiPropertyTypeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Recipe.ts b/vue3/src/openapi/models/Recipe.ts
index 06c2d5912..78b2deb85 100644
--- a/vue3/src/openapi/models/Recipe.ts
+++ b/vue3/src/openapi/models/Recipe.ts
@@ -18,30 +18,35 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { Keyword } from './Keyword';
 import {
     KeywordFromJSON,
     KeywordFromJSONTyped,
     KeywordToJSON,
+    KeywordToJSONTyped,
 } from './Keyword';
 import type { Step } from './Step';
 import {
     StepFromJSON,
     StepFromJSONTyped,
     StepToJSON,
+    StepToJSONTyped,
 } from './Step';
 import type { Property } from './Property';
 import {
     PropertyFromJSON,
     PropertyFromJSONTyped,
     PropertyToJSON,
+    PropertyToJSONTyped,
 } from './Property';
 import type { NutritionInformation } from './NutritionInformation';
 import {
     NutritionInformationFromJSON,
     NutritionInformationFromJSONTyped,
     NutritionInformationToJSON,
+    NutritionInformationToJSONTyped,
 } from './NutritionInformation';
 
 /**
@@ -249,10 +254,15 @@ export function RecipeFromJSONTyped(json: any, ignoreDiscriminator: boolean): Re
     };
 }
 
-export function RecipeToJSON(value?: Omit<Recipe, 'image'|'created_by'|'created_at'|'updated_at'|'food_properties'|'rating'|'last_cooked'> | null): any {
+export function RecipeToJSON(json: any): Recipe {
+    return RecipeToJSONTyped(json, false);
+}
+
+export function RecipeToJSONTyped(value?: Omit<Recipe, 'image'|'created_by'|'created_at'|'updated_at'|'food_properties'|'rating'|'last_cooked'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -274,15 +284,4 @@ export function RecipeToJSON(value?: Omit<Recipe, 'image'|'created_by'|'created_
         'shared': value['shared'] == null ? undefined : ((value['shared'] as Array<any>).map(UserToJSON)),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeListRequest, PaginatedRecipeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeListRequest = {}): Promise<PaginatedRecipeList> {
-    const api = new ApiApi()
-    return api.apiRecipeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeBook.ts b/vue3/src/openapi/models/RecipeBook.ts
index 723f29ab9..a5323b0bc 100644
--- a/vue3/src/openapi/models/RecipeBook.ts
+++ b/vue3/src/openapi/models/RecipeBook.ts
@@ -18,12 +18,14 @@ import {
     CustomFilterFromJSON,
     CustomFilterFromJSONTyped,
     CustomFilterToJSON,
+    CustomFilterToJSONTyped,
 } from './CustomFilter';
 import type { User } from './User';
 import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -106,10 +108,15 @@ export function RecipeBookFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     };
 }
 
-export function RecipeBookToJSON(value?: Omit<RecipeBook, 'created_by'> | null): any {
+export function RecipeBookToJSON(json: any): RecipeBook {
+    return RecipeBookToJSONTyped(json, false);
+}
+
+export function RecipeBookToJSONTyped(value?: Omit<RecipeBook, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -120,15 +127,4 @@ export function RecipeBookToJSON(value?: Omit<RecipeBook, 'created_by'> | null):
         'order': value['order'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeBookListRequest, PaginatedRecipeBookList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeBookListRequest = {}): Promise<PaginatedRecipeBookList> {
-    const api = new ApiApi()
-    return api.apiRecipeBookList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeBookEntry.ts b/vue3/src/openapi/models/RecipeBookEntry.ts
index bf049c059..8ceb65fc3 100644
--- a/vue3/src/openapi/models/RecipeBookEntry.ts
+++ b/vue3/src/openapi/models/RecipeBookEntry.ts
@@ -18,12 +18,14 @@ import {
     RecipeBookFromJSON,
     RecipeBookFromJSONTyped,
     RecipeBookToJSON,
+    RecipeBookToJSONTyped,
 } from './RecipeBook';
 import type { RecipeOverview } from './RecipeOverview';
 import {
     RecipeOverviewFromJSON,
     RecipeOverviewFromJSONTyped,
     RecipeOverviewToJSON,
+    RecipeOverviewToJSONTyped,
 } from './RecipeOverview';
 
 /**
@@ -93,10 +95,15 @@ export function RecipeBookEntryFromJSONTyped(json: any, ignoreDiscriminator: boo
     };
 }
 
-export function RecipeBookEntryToJSON(value?: Omit<RecipeBookEntry, 'book_content'|'recipe_content'> | null): any {
+export function RecipeBookEntryToJSON(json: any): RecipeBookEntry {
+    return RecipeBookEntryToJSONTyped(json, false);
+}
+
+export function RecipeBookEntryToJSONTyped(value?: Omit<RecipeBookEntry, 'book_content'|'recipe_content'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -104,15 +111,4 @@ export function RecipeBookEntryToJSON(value?: Omit<RecipeBookEntry, 'book_conten
         'recipe': value['recipe'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeBookEntryListRequest, PaginatedRecipeBookEntryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeBookEntryListRequest = {}): Promise<PaginatedRecipeBookEntryList> {
-    const api = new ApiApi()
-    return api.apiRecipeBookEntryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeFlat.ts b/vue3/src/openapi/models/RecipeFlat.ts
index 93f0a41e2..247e2aa4b 100644
--- a/vue3/src/openapi/models/RecipeFlat.ts
+++ b/vue3/src/openapi/models/RecipeFlat.ts
@@ -63,10 +63,15 @@ export function RecipeFlatFromJSONTyped(json: any, ignoreDiscriminator: boolean)
     };
 }
 
-export function RecipeFlatToJSON(value?: RecipeFlat | null): any {
+export function RecipeFlatToJSON(json: any): RecipeFlat {
+    return RecipeFlatToJSONTyped(json, false);
+}
+
+export function RecipeFlatToJSONTyped(value?: RecipeFlat | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -74,15 +79,4 @@ export function RecipeFlatToJSON(value?: RecipeFlat | null): any {
         'image': value['image'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeFlatListRequest, PaginatedRecipeFlatList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeFlatListRequest = {}): Promise<PaginatedRecipeFlatList> {
-    const api = new ApiApi()
-    return api.apiRecipeFlatList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeImage.ts b/vue3/src/openapi/models/RecipeImage.ts
index 5a364ddec..68912115f 100644
--- a/vue3/src/openapi/models/RecipeImage.ts
+++ b/vue3/src/openapi/models/RecipeImage.ts
@@ -55,25 +55,19 @@ export function RecipeImageFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function RecipeImageToJSON(value?: RecipeImage | null): any {
+export function RecipeImageToJSON(json: any): RecipeImage {
+    return RecipeImageToJSONTyped(json, false);
+}
+
+export function RecipeImageToJSONTyped(value?: RecipeImage | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'image': value['image'],
         'image_url': value['imageUrl'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeImageListRequest, PaginatedRecipeImageList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeImageListRequest = {}): Promise<PaginatedRecipeImageList> {
-    const api = new ApiApi()
-    return api.apiRecipeImageList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeOverview.ts b/vue3/src/openapi/models/RecipeOverview.ts
index d409979a4..0db14fff3 100644
--- a/vue3/src/openapi/models/RecipeOverview.ts
+++ b/vue3/src/openapi/models/RecipeOverview.ts
@@ -18,6 +18,7 @@ import {
     KeywordLabelFromJSON,
     KeywordLabelFromJSONTyped,
     KeywordLabelToJSON,
+    KeywordLabelToJSONTyped,
 } from './KeywordLabel';
 
 /**
@@ -182,10 +183,15 @@ export function RecipeOverviewFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function RecipeOverviewToJSON(value?: Omit<RecipeOverview, 'image'|'keywords'|'working_time'|'waiting_time'|'created_by'|'created_at'|'updated_at'|'internal'|'servings'|'servings_text'|'rating'|'last_cooked'|'new'|'recent'> | null): any {
+export function RecipeOverviewToJSON(json: any): RecipeOverview {
+    return RecipeOverviewToJSONTyped(json, false);
+}
+
+export function RecipeOverviewToJSONTyped(value?: Omit<RecipeOverview, 'image'|'keywords'|'working_time'|'waiting_time'|'created_by'|'created_at'|'updated_at'|'internal'|'servings'|'servings_text'|'rating'|'last_cooked'|'new'|'recent'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -193,15 +199,4 @@ export function RecipeOverviewToJSON(value?: Omit<RecipeOverview, 'image'|'keywo
         'description': value['description'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeOverviewListRequest, PaginatedRecipeOverviewList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeOverviewListRequest = {}): Promise<PaginatedRecipeOverviewList> {
-    const api = new ApiApi()
-    return api.apiRecipeOverviewList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeShoppingUpdate.ts b/vue3/src/openapi/models/RecipeShoppingUpdate.ts
index df9af26b3..c9d315bff 100644
--- a/vue3/src/openapi/models/RecipeShoppingUpdate.ts
+++ b/vue3/src/openapi/models/RecipeShoppingUpdate.ts
@@ -69,10 +69,15 @@ export function RecipeShoppingUpdateFromJSONTyped(json: any, ignoreDiscriminator
     };
 }
 
-export function RecipeShoppingUpdateToJSON(value?: RecipeShoppingUpdate | null): any {
+export function RecipeShoppingUpdateToJSON(json: any): RecipeShoppingUpdate {
+    return RecipeShoppingUpdateToJSONTyped(json, false);
+}
+
+export function RecipeShoppingUpdateToJSONTyped(value?: RecipeShoppingUpdate | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -81,15 +86,4 @@ export function RecipeShoppingUpdateToJSON(value?: RecipeShoppingUpdate | null):
         'servings': value['servings'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeShoppingUpdateListRequest, PaginatedRecipeShoppingUpdateList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeShoppingUpdateListRequest = {}): Promise<PaginatedRecipeShoppingUpdateList> {
-    const api = new ApiApi()
-    return api.apiRecipeShoppingUpdateList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/RecipeSimple.ts b/vue3/src/openapi/models/RecipeSimple.ts
index a12c17613..0df794ed1 100644
--- a/vue3/src/openapi/models/RecipeSimple.ts
+++ b/vue3/src/openapi/models/RecipeSimple.ts
@@ -64,25 +64,19 @@ export function RecipeSimpleFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function RecipeSimpleToJSON(value?: Omit<RecipeSimple, 'url'> | null): any {
+export function RecipeSimpleToJSON(json: any): RecipeSimple {
+    return RecipeSimpleToJSONTyped(json, false);
+}
+
+export function RecipeSimpleToJSONTyped(value?: Omit<RecipeSimple, 'url'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
         'name': value['name'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiRecipeSimpleListRequest, PaginatedRecipeSimpleList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiRecipeSimpleListRequest = {}): Promise<PaginatedRecipeSimpleList> {
-    const api = new ApiApi()
-    return api.apiRecipeSimpleList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ServerSettings.ts b/vue3/src/openapi/models/ServerSettings.ts
index 06072b921..dd57bcd5f 100644
--- a/vue3/src/openapi/models/ServerSettings.ts
+++ b/vue3/src/openapi/models/ServerSettings.ts
@@ -61,6 +61,12 @@ export interface ServerSettings {
      * @memberof ServerSettings
      */
     hosted: boolean;
+    /**
+     * 
+     * @type {boolean}
+     * @memberof ServerSettings
+     */
+    debug: boolean;
 }
 
 /**
@@ -74,6 +80,7 @@ export function instanceOfServerSettings(value: object): value is ServerSettings
     if (!('privacyUrl' in value) || value['privacyUrl'] === undefined) return false;
     if (!('imprintUrl' in value) || value['imprintUrl'] === undefined) return false;
     if (!('hosted' in value) || value['hosted'] === undefined) return false;
+    if (!('debug' in value) || value['debug'] === undefined) return false;
     return true;
 }
 
@@ -94,13 +101,19 @@ export function ServerSettingsFromJSONTyped(json: any, ignoreDiscriminator: bool
         'privacyUrl': json['privacy_url'],
         'imprintUrl': json['imprint_url'],
         'hosted': json['hosted'],
+        'debug': json['debug'],
     };
 }
 
-export function ServerSettingsToJSON(value?: ServerSettings | null): any {
+export function ServerSettingsToJSON(json: any): ServerSettings {
+    return ServerSettingsToJSONTyped(json, false);
+}
+
+export function ServerSettingsToJSONTyped(value?: ServerSettings | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'shopping_min_autosync_interval': value['shoppingMinAutosyncInterval'],
@@ -110,17 +123,7 @@ export function ServerSettingsToJSON(value?: ServerSettings | null): any {
         'privacy_url': value['privacyUrl'],
         'imprint_url': value['imprintUrl'],
         'hosted': value['hosted'],
+        'debug': value['debug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiServerSettingsListRequest, PaginatedServerSettingsList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiServerSettingsListRequest = {}): Promise<PaginatedServerSettingsList> {
-    const api = new ApiApi()
-    return api.apiServerSettingsList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ShareLink.ts b/vue3/src/openapi/models/ShareLink.ts
index 7fa6364f6..c9529995f 100644
--- a/vue3/src/openapi/models/ShareLink.ts
+++ b/vue3/src/openapi/models/ShareLink.ts
@@ -65,10 +65,15 @@ export function ShareLinkFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function ShareLinkToJSON(value?: ShareLink | null): any {
+export function ShareLinkToJSON(json: any): ShareLink {
+    return ShareLinkToJSONTyped(json, false);
+}
+
+export function ShareLinkToJSONTyped(value?: ShareLink | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'pk': value['pk'],
@@ -76,15 +81,4 @@ export function ShareLinkToJSON(value?: ShareLink | null): any {
         'link': value['link'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiShareLinkListRequest, PaginatedShareLinkList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiShareLinkListRequest = {}): Promise<PaginatedShareLinkList> {
-    const api = new ApiApi()
-    return api.apiShareLinkList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ShoppingListEntry.ts b/vue3/src/openapi/models/ShoppingListEntry.ts
index 4e46e2ccf..a5bf0cfdf 100644
--- a/vue3/src/openapi/models/ShoppingListEntry.ts
+++ b/vue3/src/openapi/models/ShoppingListEntry.ts
@@ -18,24 +18,28 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { ShoppingListRecipe } from './ShoppingListRecipe';
 import {
     ShoppingListRecipeFromJSON,
     ShoppingListRecipeFromJSONTyped,
     ShoppingListRecipeToJSON,
+    ShoppingListRecipeToJSONTyped,
 } from './ShoppingListRecipe';
 import type { Unit } from './Unit';
 import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Food } from './Food';
 import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -163,10 +167,15 @@ export function ShoppingListEntryFromJSONTyped(json: any, ignoreDiscriminator: b
     };
 }
 
-export function ShoppingListEntryToJSON(value?: Omit<ShoppingListEntry, 'recipe_mealplan'|'created_by'|'created_at'|'updated_at'> | null): any {
+export function ShoppingListEntryToJSON(json: any): ShoppingListEntry {
+    return ShoppingListEntryToJSONTyped(json, false);
+}
+
+export function ShoppingListEntryToJSONTyped(value?: Omit<ShoppingListEntry, 'recipe_mealplan'|'created_by'|'created_at'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -180,15 +189,4 @@ export function ShoppingListEntryToJSON(value?: Omit<ShoppingListEntry, 'recipe_
         'delay_until': value['delayUntil'] == null ? undefined : ((value['delayUntil'] as any).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiShoppingListEntryListRequest, PaginatedShoppingListEntryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiShoppingListEntryListRequest = {}): Promise<PaginatedShoppingListEntryList> {
-    const api = new ApiApi()
-    return api.apiShoppingListEntryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ShoppingListEntryBulk.ts b/vue3/src/openapi/models/ShoppingListEntryBulk.ts
index f4853d884..c22829cad 100644
--- a/vue3/src/openapi/models/ShoppingListEntryBulk.ts
+++ b/vue3/src/openapi/models/ShoppingListEntryBulk.ts
@@ -65,25 +65,19 @@ export function ShoppingListEntryBulkFromJSONTyped(json: any, ignoreDiscriminato
     };
 }
 
-export function ShoppingListEntryBulkToJSON(value?: Omit<ShoppingListEntryBulk, 'timestamp'> | null): any {
+export function ShoppingListEntryBulkToJSON(json: any): ShoppingListEntryBulk {
+    return ShoppingListEntryBulkToJSONTyped(json, false);
+}
+
+export function ShoppingListEntryBulkToJSONTyped(value?: Omit<ShoppingListEntryBulk, 'timestamp'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'ids': value['ids'],
         'checked': value['checked'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiShoppingListEntryBulkListRequest, PaginatedShoppingListEntryBulkList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiShoppingListEntryBulkListRequest = {}): Promise<PaginatedShoppingListEntryBulkList> {
-    const api = new ApiApi()
-    return api.apiShoppingListEntryBulkList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ShoppingListRecipe.ts b/vue3/src/openapi/models/ShoppingListRecipe.ts
index 6389eb546..dae89d8b9 100644
--- a/vue3/src/openapi/models/ShoppingListRecipe.ts
+++ b/vue3/src/openapi/models/ShoppingListRecipe.ts
@@ -110,10 +110,15 @@ export function ShoppingListRecipeFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function ShoppingListRecipeToJSON(value?: Omit<ShoppingListRecipe, 'recipe_name'|'name'|'mealplan_note'|'mealplan_from_date'|'mealplan_type'> | null): any {
+export function ShoppingListRecipeToJSON(json: any): ShoppingListRecipe {
+    return ShoppingListRecipeToJSONTyped(json, false);
+}
+
+export function ShoppingListRecipeToJSONTyped(value?: Omit<ShoppingListRecipe, 'recipe_name'|'name'|'mealplan_note'|'mealplan_from_date'|'mealplan_type'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -122,15 +127,4 @@ export function ShoppingListRecipeToJSON(value?: Omit<ShoppingListRecipe, 'recip
         'servings': value['servings'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiShoppingListRecipeListRequest, PaginatedShoppingListRecipeList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiShoppingListRecipeListRequest = {}): Promise<PaginatedShoppingListRecipeList> {
-    const api = new ApiApi()
-    return api.apiShoppingListRecipeList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Space.ts b/vue3/src/openapi/models/Space.ts
index 59d2b3d7a..f409d2c41 100644
--- a/vue3/src/openapi/models/Space.ts
+++ b/vue3/src/openapi/models/Space.ts
@@ -18,30 +18,35 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { UserFileView } from './UserFileView';
 import {
     UserFileViewFromJSON,
     UserFileViewFromJSONTyped,
     UserFileViewToJSON,
+    UserFileViewToJSONTyped,
 } from './UserFileView';
 import type { SpaceNavTextColorEnum } from './SpaceNavTextColorEnum';
 import {
     SpaceNavTextColorEnumFromJSON,
     SpaceNavTextColorEnumFromJSONTyped,
     SpaceNavTextColorEnumToJSON,
+    SpaceNavTextColorEnumToJSONTyped,
 } from './SpaceNavTextColorEnum';
 import type { FoodInheritField } from './FoodInheritField';
 import {
     FoodInheritFieldFromJSON,
     FoodInheritFieldFromJSONTyped,
     FoodInheritFieldToJSON,
+    FoodInheritFieldToJSONTyped,
 } from './FoodInheritField';
 import type { SpaceThemeEnum } from './SpaceThemeEnum';
 import {
     SpaceThemeEnumFromJSON,
     SpaceThemeEnumFromJSONTyped,
     SpaceThemeEnumToJSON,
+    SpaceThemeEnumToJSONTyped,
 } from './SpaceThemeEnum';
 
 /**
@@ -274,10 +279,15 @@ export function SpaceFromJSONTyped(json: any, ignoreDiscriminator: boolean): Spa
     };
 }
 
-export function SpaceToJSON(value?: Omit<Space, 'created_by'|'created_at'|'max_recipes'|'max_file_storage_mb'|'max_users'|'allow_sharing'|'demo'|'user_count'|'recipe_count'|'file_size_mb'> | null): any {
+export function SpaceToJSON(json: any): Space {
+    return SpaceToJSONTyped(json, false);
+}
+
+export function SpaceToJSONTyped(value?: Omit<Space, 'created_by'|'created_at'|'max_recipes'|'max_file_storage_mb'|'max_users'|'allow_sharing'|'demo'|'user_count'|'recipe_count'|'file_size_mb'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -299,15 +309,4 @@ export function SpaceToJSON(value?: Omit<Space, 'created_by'|'created_at'|'max_r
         'logo_color_svg': UserFileViewToJSON(value['logoColorSvg']),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiSpaceListRequest, PaginatedSpaceList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiSpaceListRequest = {}): Promise<PaginatedSpaceList> {
-    const api = new ApiApi()
-    return api.apiSpaceList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Step.ts b/vue3/src/openapi/models/Step.ts
index 724faeaba..bf8c5069a 100644
--- a/vue3/src/openapi/models/Step.ts
+++ b/vue3/src/openapi/models/Step.ts
@@ -18,12 +18,14 @@ import {
     UserFileViewFromJSON,
     UserFileViewFromJSONTyped,
     UserFileViewToJSON,
+    UserFileViewToJSONTyped,
 } from './UserFileView';
 import type { Ingredient } from './Ingredient';
 import {
     IngredientFromJSON,
     IngredientFromJSONTyped,
     IngredientToJSON,
+    IngredientToJSONTyped,
 } from './Ingredient';
 
 /**
@@ -149,10 +151,15 @@ export function StepFromJSONTyped(json: any, ignoreDiscriminator: boolean): Step
     };
 }
 
-export function StepToJSON(value?: Omit<Step, 'instructions_markdown'|'step_recipe_data'|'numrecipe'> | null): any {
+export function StepToJSON(json: any): Step {
+    return StepToJSONTyped(json, false);
+}
+
+export function StepToJSONTyped(value?: Omit<Step, 'instructions_markdown'|'step_recipe_data'|'numrecipe'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -167,15 +174,4 @@ export function StepToJSON(value?: Omit<Step, 'instructions_markdown'|'step_reci
         'show_ingredients_table': value['showIngredientsTable'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiStepListRequest, PaginatedStepList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiStepListRequest = {}): Promise<PaginatedStepList> {
-    const api = new ApiApi()
-    return api.apiStepList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Storage.ts b/vue3/src/openapi/models/Storage.ts
index c16d8a4b0..e579995a0 100644
--- a/vue3/src/openapi/models/Storage.ts
+++ b/vue3/src/openapi/models/Storage.ts
@@ -18,6 +18,7 @@ import {
     MethodEnumFromJSON,
     MethodEnumFromJSONTyped,
     MethodEnumToJSON,
+    MethodEnumToJSONTyped,
 } from './MethodEnum';
 
 /**
@@ -101,10 +102,15 @@ export function StorageFromJSONTyped(json: any, ignoreDiscriminator: boolean): S
     };
 }
 
-export function StorageToJSON(value?: Omit<Storage, 'created_by'> | null): any {
+export function StorageToJSON(json: any): Storage {
+    return StorageToJSONTyped(json, false);
+}
+
+export function StorageToJSONTyped(value?: Omit<Storage, 'created_by'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -115,15 +121,4 @@ export function StorageToJSON(value?: Omit<Storage, 'created_by'> | null): any {
         'token': value['token'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiStorageListRequest, PaginatedStorageList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiStorageListRequest = {}): Promise<PaginatedStorageList> {
-    const api = new ApiApi()
-    return api.apiStorageList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Supermarket.ts b/vue3/src/openapi/models/Supermarket.ts
index 217dddb28..57ad4eac8 100644
--- a/vue3/src/openapi/models/Supermarket.ts
+++ b/vue3/src/openapi/models/Supermarket.ts
@@ -18,6 +18,7 @@ import {
     SupermarketCategoryRelationFromJSON,
     SupermarketCategoryRelationFromJSONTyped,
     SupermarketCategoryRelationToJSON,
+    SupermarketCategoryRelationToJSONTyped,
 } from './SupermarketCategoryRelation';
 
 /**
@@ -119,10 +120,15 @@ export function SupermarketFromJSONTyped(json: any, ignoreDiscriminator: boolean
     };
 }
 
-export function SupermarketToJSON(value?: Omit<Supermarket, 'category_to_supermarket'> | null): any {
+export function SupermarketToJSON(json: any): Supermarket {
+    return SupermarketToJSONTyped(json, false);
+}
+
+export function SupermarketToJSONTyped(value?: Omit<Supermarket, 'category_to_supermarket'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -131,15 +137,4 @@ export function SupermarketToJSON(value?: Omit<Supermarket, 'category_to_superma
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiSupermarketListRequest, PaginatedSupermarketList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiSupermarketListRequest = {}): Promise<PaginatedSupermarketList> {
-    const api = new ApiApi()
-    return api.apiSupermarketList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/SupermarketCategory.ts b/vue3/src/openapi/models/SupermarketCategory.ts
index 951227f9e..44a5d0981 100644
--- a/vue3/src/openapi/models/SupermarketCategory.ts
+++ b/vue3/src/openapi/models/SupermarketCategory.ts
@@ -97,10 +97,15 @@ export function SupermarketCategoryFromJSONTyped(json: any, ignoreDiscriminator:
     };
 }
 
-export function SupermarketCategoryToJSON(value?: SupermarketCategory | null): any {
+export function SupermarketCategoryToJSON(json: any): SupermarketCategory {
+    return SupermarketCategoryToJSONTyped(json, false);
+}
+
+export function SupermarketCategoryToJSONTyped(value?: SupermarketCategory | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -108,15 +113,4 @@ export function SupermarketCategoryToJSON(value?: SupermarketCategory | null): a
         'description': value['description'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiSupermarketCategoryListRequest, PaginatedSupermarketCategoryList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiSupermarketCategoryListRequest = {}): Promise<PaginatedSupermarketCategoryList> {
-    const api = new ApiApi()
-    return api.apiSupermarketCategoryList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/SupermarketCategoryRelation.ts b/vue3/src/openapi/models/SupermarketCategoryRelation.ts
index de76291d3..050876a99 100644
--- a/vue3/src/openapi/models/SupermarketCategoryRelation.ts
+++ b/vue3/src/openapi/models/SupermarketCategoryRelation.ts
@@ -18,6 +18,7 @@ import {
     SupermarketCategoryFromJSON,
     SupermarketCategoryFromJSONTyped,
     SupermarketCategoryToJSON,
+    SupermarketCategoryToJSONTyped,
 } from './SupermarketCategory';
 
 /**
@@ -78,10 +79,15 @@ export function SupermarketCategoryRelationFromJSONTyped(json: any, ignoreDiscri
     };
 }
 
-export function SupermarketCategoryRelationToJSON(value?: SupermarketCategoryRelation | null): any {
+export function SupermarketCategoryRelationToJSON(json: any): SupermarketCategoryRelation {
+    return SupermarketCategoryRelationToJSONTyped(json, false);
+}
+
+export function SupermarketCategoryRelationToJSONTyped(value?: SupermarketCategoryRelation | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -90,15 +96,4 @@ export function SupermarketCategoryRelationToJSON(value?: SupermarketCategoryRel
         'order': value['order'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiSupermarketCategoryRelationListRequest, PaginatedSupermarketCategoryRelationList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiSupermarketCategoryRelationListRequest = {}): Promise<PaginatedSupermarketCategoryRelationList> {
-    const api = new ApiApi()
-    return api.apiSupermarketCategoryRelationList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Sync.ts b/vue3/src/openapi/models/Sync.ts
index f00369ac8..217d1fed6 100644
--- a/vue3/src/openapi/models/Sync.ts
+++ b/vue3/src/openapi/models/Sync.ts
@@ -93,10 +93,15 @@ export function SyncFromJSONTyped(json: any, ignoreDiscriminator: boolean): Sync
     };
 }
 
-export function SyncToJSON(value?: Omit<Sync, 'created_at'|'updated_at'> | null): any {
+export function SyncToJSON(json: any): Sync {
+    return SyncToJSONTyped(json, false);
+}
+
+export function SyncToJSONTyped(value?: Omit<Sync, 'created_at'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -106,15 +111,4 @@ export function SyncToJSON(value?: Omit<Sync, 'created_at'|'updated_at'> | null)
         'last_checked': value['lastChecked'] == null ? undefined : ((value['lastChecked'] as any).toISOString()),
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiSyncListRequest, PaginatedSyncList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiSyncListRequest = {}): Promise<PaginatedSyncList> {
-    const api = new ApiApi()
-    return api.apiSyncList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/SyncLog.ts b/vue3/src/openapi/models/SyncLog.ts
index d41c06003..6c040a3bc 100644
--- a/vue3/src/openapi/models/SyncLog.ts
+++ b/vue3/src/openapi/models/SyncLog.ts
@@ -79,10 +79,15 @@ export function SyncLogFromJSONTyped(json: any, ignoreDiscriminator: boolean): S
     };
 }
 
-export function SyncLogToJSON(value?: Omit<SyncLog, 'created_at'> | null): any {
+export function SyncLogToJSON(json: any): SyncLog {
+    return SyncLogToJSONTyped(json, false);
+}
+
+export function SyncLogToJSONTyped(value?: Omit<SyncLog, 'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -91,15 +96,4 @@ export function SyncLogToJSON(value?: Omit<SyncLog, 'created_at'> | null): any {
         'msg': value['msg'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiSyncLogListRequest, PaginatedSyncLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiSyncLogListRequest = {}): Promise<PaginatedSyncLogList> {
-    const api = new ApiApi()
-    return api.apiSyncLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/Unit.ts b/vue3/src/openapi/models/Unit.ts
index 6cfd1d104..d6bed34c2 100644
--- a/vue3/src/openapi/models/Unit.ts
+++ b/vue3/src/openapi/models/Unit.ts
@@ -118,10 +118,15 @@ export function UnitFromJSONTyped(json: any, ignoreDiscriminator: boolean): Unit
     };
 }
 
-export function UnitToJSON(value?: Unit | null): any {
+export function UnitToJSON(json: any): Unit {
+    return UnitToJSONTyped(json, false);
+}
+
+export function UnitToJSONTyped(value?: Unit | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -132,15 +137,4 @@ export function UnitToJSON(value?: Unit | null): any {
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUnitListRequest, PaginatedUnitList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUnitListRequest = {}): Promise<PaginatedUnitList> {
-    const api = new ApiApi()
-    return api.apiUnitList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/UnitConversion.ts b/vue3/src/openapi/models/UnitConversion.ts
index 77375b652..1bfe40673 100644
--- a/vue3/src/openapi/models/UnitConversion.ts
+++ b/vue3/src/openapi/models/UnitConversion.ts
@@ -18,12 +18,14 @@ import {
     UnitFromJSON,
     UnitFromJSONTyped,
     UnitToJSON,
+    UnitToJSONTyped,
 } from './Unit';
 import type { Food } from './Food';
 import {
     FoodFromJSON,
     FoodFromJSONTyped,
     FoodToJSON,
+    FoodToJSONTyped,
 } from './Food';
 
 /**
@@ -115,10 +117,15 @@ export function UnitConversionFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function UnitConversionToJSON(value?: Omit<UnitConversion, 'name'> | null): any {
+export function UnitConversionToJSON(json: any): UnitConversion {
+    return UnitConversionToJSONTyped(json, false);
+}
+
+export function UnitConversionToJSONTyped(value?: Omit<UnitConversion, 'name'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -130,15 +137,4 @@ export function UnitConversionToJSON(value?: Omit<UnitConversion, 'name'> | null
         'open_data_slug': value['openDataSlug'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUnitConversionListRequest, PaginatedUnitConversionList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUnitConversionListRequest = {}): Promise<PaginatedUnitConversionList> {
-    const api = new ApiApi()
-    return api.apiUnitConversionList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/User.ts b/vue3/src/openapi/models/User.ts
index 2b9fb76a8..d123c8a0a 100644
--- a/vue3/src/openapi/models/User.ts
+++ b/vue3/src/openapi/models/User.ts
@@ -78,10 +78,15 @@ export function UserFromJSONTyped(json: any, ignoreDiscriminator: boolean): User
     };
 }
 
-export function UserToJSON(value?: Omit<User, 'username'|'display_name'> | null): any {
+export function UserToJSON(json: any): User {
+    return UserToJSONTyped(json, false);
+}
+
+export function UserToJSONTyped(value?: Omit<User, 'username'|'display_name'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -89,15 +94,4 @@ export function UserToJSON(value?: Omit<User, 'username'|'display_name'> | null)
         'last_name': value['lastName'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUserListRequest, PaginatedUserList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUserListRequest = {}): Promise<PaginatedUserList> {
-    const api = new ApiApi()
-    return api.apiUserList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/UserFile.ts b/vue3/src/openapi/models/UserFile.ts
index f52a83d1d..34985c465 100644
--- a/vue3/src/openapi/models/UserFile.ts
+++ b/vue3/src/openapi/models/UserFile.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -111,10 +112,15 @@ export function UserFileFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function UserFileToJSON(value?: Omit<UserFile, 'file_download'|'preview'|'file_size_kb'|'created_by'|'created_at'> | null): any {
+export function UserFileToJSON(json: any): UserFile {
+    return UserFileToJSONTyped(json, false);
+}
+
+export function UserFileToJSONTyped(value?: Omit<UserFile, 'file_download'|'preview'|'file_size_kb'|'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -122,15 +128,4 @@ export function UserFileToJSON(value?: Omit<UserFile, 'file_download'|'preview'|
         'file': value['file'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUserFileListRequest, PaginatedUserFileList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUserFileListRequest = {}): Promise<PaginatedUserFileList> {
-    const api = new ApiApi()
-    return api.apiUserFileList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/UserFileView.ts b/vue3/src/openapi/models/UserFileView.ts
index c6ca1e354..35be1405b 100644
--- a/vue3/src/openapi/models/UserFileView.ts
+++ b/vue3/src/openapi/models/UserFileView.ts
@@ -18,6 +18,7 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -103,25 +104,19 @@ export function UserFileViewFromJSONTyped(json: any, ignoreDiscriminator: boolea
     };
 }
 
-export function UserFileViewToJSON(value?: Omit<UserFileView, 'file_download'|'preview'|'file_size_kb'|'created_by'|'created_at'> | null): any {
+export function UserFileViewToJSON(json: any): UserFileView {
+    return UserFileViewToJSONTyped(json, false);
+}
+
+export function UserFileViewToJSONTyped(value?: Omit<UserFileView, 'file_download'|'preview'|'file_size_kb'|'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
         'name': value['name'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUserFileViewListRequest, PaginatedUserFileViewList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUserFileViewListRequest = {}): Promise<PaginatedUserFileViewList> {
-    const api = new ApiApi()
-    return api.apiUserFileViewList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/UserPreference.ts b/vue3/src/openapi/models/UserPreference.ts
index 2b8d95033..8e505c05a 100644
--- a/vue3/src/openapi/models/UserPreference.ts
+++ b/vue3/src/openapi/models/UserPreference.ts
@@ -18,36 +18,42 @@ import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 import type { UserFileView } from './UserFileView';
 import {
     UserFileViewFromJSON,
     UserFileViewFromJSONTyped,
     UserFileViewToJSON,
+    UserFileViewToJSONTyped,
 } from './UserFileView';
 import type { UserPreferenceNavTextColorEnum } from './UserPreferenceNavTextColorEnum';
 import {
     UserPreferenceNavTextColorEnumFromJSON,
     UserPreferenceNavTextColorEnumFromJSONTyped,
     UserPreferenceNavTextColorEnumToJSON,
+    UserPreferenceNavTextColorEnumToJSONTyped,
 } from './UserPreferenceNavTextColorEnum';
 import type { FoodInheritField } from './FoodInheritField';
 import {
     FoodInheritFieldFromJSON,
     FoodInheritFieldFromJSONTyped,
     FoodInheritFieldToJSON,
+    FoodInheritFieldToJSONTyped,
 } from './FoodInheritField';
 import type { ThemeEnum } from './ThemeEnum';
 import {
     ThemeEnumFromJSON,
     ThemeEnumFromJSONTyped,
     ThemeEnumToJSON,
+    ThemeEnumToJSONTyped,
 } from './ThemeEnum';
 import type { DefaultPageEnum } from './DefaultPageEnum';
 import {
     DefaultPageEnumFromJSON,
     DefaultPageEnumFromJSONTyped,
     DefaultPageEnumToJSON,
+    DefaultPageEnumToJSONTyped,
 } from './DefaultPageEnum';
 
 /**
@@ -286,10 +292,15 @@ export function UserPreferenceFromJSONTyped(json: any, ignoreDiscriminator: bool
     };
 }
 
-export function UserPreferenceToJSON(value?: Omit<UserPreference, 'food_inherit_default'|'food_children_exist'> | null): any {
+export function UserPreferenceToJSON(json: any): UserPreference {
+    return UserPreferenceToJSONTyped(json, false);
+}
+
+export function UserPreferenceToJSONTyped(value?: Omit<UserPreference, 'food_inherit_default'|'food_children_exist'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'user': value['user'],
@@ -321,15 +332,4 @@ export function UserPreferenceToJSON(value?: Omit<UserPreference, 'food_inherit_
         'show_step_ingredients': value['showStepIngredients'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUserPreferenceListRequest, PaginatedUserPreferenceList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUserPreferenceListRequest = {}): Promise<PaginatedUserPreferenceList> {
-    const api = new ApiApi()
-    return api.apiUserPreferenceList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/UserSpace.ts b/vue3/src/openapi/models/UserSpace.ts
index 5aa51ba83..0300cd927 100644
--- a/vue3/src/openapi/models/UserSpace.ts
+++ b/vue3/src/openapi/models/UserSpace.ts
@@ -18,12 +18,14 @@ import {
     GroupFromJSON,
     GroupFromJSONTyped,
     GroupToJSON,
+    GroupToJSONTyped,
 } from './Group';
 import type { User } from './User';
 import {
     UserFromJSON,
     UserFromJSONTyped,
     UserToJSON,
+    UserToJSONTyped,
 } from './User';
 
 /**
@@ -123,10 +125,15 @@ export function UserSpaceFromJSONTyped(json: any, ignoreDiscriminator: boolean):
     };
 }
 
-export function UserSpaceToJSON(value?: Omit<UserSpace, 'user'|'space'|'invite_link'|'created_at'|'updated_at'> | null): any {
+export function UserSpaceToJSON(json: any): UserSpace {
+    return UserSpaceToJSONTyped(json, false);
+}
+
+export function UserSpaceToJSONTyped(value?: Omit<UserSpace, 'user'|'space'|'invite_link'|'created_at'|'updated_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
@@ -135,15 +142,4 @@ export function UserSpaceToJSON(value?: Omit<UserSpace, 'user'|'space'|'invite_l
         'internal_note': value['internalNote'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiUserSpaceListRequest, PaginatedUserSpaceList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiUserSpaceListRequest = {}): Promise<PaginatedUserSpaceList> {
-    const api = new ApiApi()
-    return api.apiUserSpaceList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/ViewLog.ts b/vue3/src/openapi/models/ViewLog.ts
index 1264c7f75..3cf739133 100644
--- a/vue3/src/openapi/models/ViewLog.ts
+++ b/vue3/src/openapi/models/ViewLog.ts
@@ -72,25 +72,19 @@ export function ViewLogFromJSONTyped(json: any, ignoreDiscriminator: boolean): V
     };
 }
 
-export function ViewLogToJSON(value?: Omit<ViewLog, 'created_by'|'created_at'> | null): any {
+export function ViewLogToJSON(json: any): ViewLog {
+    return ViewLogToJSONTyped(json, false);
+}
+
+export function ViewLogToJSONTyped(value?: Omit<ViewLog, 'created_by'|'created_at'> | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
+
     return {
         
         'id': value['id'],
         'recipe': value['recipe'],
     };
 }
-// ----------------------------------------------------------------------
-// Custom model functions added by custom openapi-generator template
-// ----------------------------------------------------------------------
-import {ApiApi, ApiViewLogListRequest, PaginatedViewLogList} from "@/openapi";
 
-/**
- * query list endpoint using the provided request parameters
- */
-export function list(requestParameters: ApiViewLogListRequest = {}): Promise<PaginatedViewLogList> {
-    const api = new ApiApi()
-    return api.apiViewLogList(requestParameters)
-}
diff --git a/vue3/src/openapi/models/index.ts b/vue3/src/openapi/models/index.ts
index a6d85aadf..715c40c7f 100644
--- a/vue3/src/openapi/models/index.ts
+++ b/vue3/src/openapi/models/index.ts
@@ -4,6 +4,8 @@ export * from './AccessToken';
 export * from './AuthToken';
 export * from './AutoMealPlan';
 export * from './Automation';
+export * from './AutomationTypeEnum';
+export * from './BaseUnitEnum';
 export * from './BookmarkletImport';
 export * from './BookmarkletImportList';
 export * from './ConnectorConfigConfig';
@@ -29,6 +31,16 @@ export * from './MealPlan';
 export * from './MealType';
 export * from './MethodEnum';
 export * from './NutritionInformation';
+export * from './OpenDataCategory';
+export * from './OpenDataConversion';
+export * from './OpenDataFood';
+export * from './OpenDataFoodProperty';
+export * from './OpenDataProperty';
+export * from './OpenDataStore';
+export * from './OpenDataStoreCategory';
+export * from './OpenDataUnit';
+export * from './OpenDataUnitTypeEnum';
+export * from './OpenDataVersion';
 export * from './PaginatedAutomationList';
 export * from './PaginatedBookmarkletImportListList';
 export * from './PaginatedCookLogList';
@@ -75,6 +87,13 @@ export * from './PatchedInviteLink';
 export * from './PatchedKeyword';
 export * from './PatchedMealPlan';
 export * from './PatchedMealType';
+export * from './PatchedOpenDataCategory';
+export * from './PatchedOpenDataConversion';
+export * from './PatchedOpenDataFood';
+export * from './PatchedOpenDataProperty';
+export * from './PatchedOpenDataStore';
+export * from './PatchedOpenDataUnit';
+export * from './PatchedOpenDataVersion';
 export * from './PatchedProperty';
 export * from './PatchedPropertyType';
 export * from './PatchedRecipe';
@@ -121,7 +140,6 @@ export * from './SupermarketCategoryRelation';
 export * from './Sync';
 export * from './SyncLog';
 export * from './ThemeEnum';
-export * from './TypeEnum';
 export * from './Unit';
 export * from './UnitConversion';
 export * from './User';
diff --git a/vue3/src/stores/ShoppingListStore.js b/vue3/src/stores/ShoppingListStore.js
deleted file mode 100644
index 7592e3839..000000000
--- a/vue3/src/stores/ShoppingListStore.js
+++ /dev/null
@@ -1,487 +0,0 @@
-import {defineStore} from "pinia"
-import Vue from "vue"
-import _ from 'lodash';
-import {useUserPreferenceStore} from "@/stores/UserPreferenceStore";
-import {ApiApi} from "@/openapi/index.js";
-import {DateTime} from "luxon";
-
-
-const _STORE_ID = "shopping_list_store"
-
-export const useShoppingListStore = defineStore(_STORE_ID, {
-    state: () => ({
-        // shopping data
-        entries: {},
-        supermarket_categories: [],
-        supermarkets: [],
-
-        total_unchecked: 0,
-        total_checked: 0,
-        total_unchecked_food: 0,
-        total_checked_food: 0,
-
-        // internal
-        currently_updating: false,
-        last_autosync: null,
-        autosync_has_focus: true,
-        autosync_timeout_id: null,
-        undo_stack: [],
-
-        queue_timeout_id: undefined,
-        item_check_sync_queue: {},
-
-        // constants
-        GROUP_CATEGORY: 'food.supermarket_category.name',
-        GROUP_CREATED_BY: 'created_by.display_name',
-        GROUP_RECIPE: 'recipe_mealplan.recipe_name',
-
-        UNDEFINED_CATEGORY: 'shopping_undefined_category'
-    }),
-    getters: {
-        /**
-         * build a multi-level data structure ready for display from shopping list entries
-         * group by selected grouping key
-         * @return {{}}
-         */
-        get_entries_by_group: function () {
-            let structure = {}
-            let ordered_structure = []
-
-            // build structure
-            for (let i in this.entries) {
-                structure = this.updateEntryInStructure(structure, this.entries[i], useUserPreferenceStore().device_settings.shopping_selected_grouping)
-            }
-
-            // statistics for UI conditions and display
-            let total_unchecked = 0
-            let total_checked = 0
-            let total_unchecked_food = 0
-            let total_checked_food = 0
-            for (let i in structure) {
-                let count_unchecked = 0
-                let count_checked = 0
-                let count_unchecked_food = 0
-                let count_checked_food = 0
-
-                for (let fi in structure[i]['foods']) {
-                    let food_checked = true
-                    for (let ei in structure[i]['foods'][fi]['entries']) {
-                        if (structure[i]['foods'][fi]['entries'][ei].checked) {
-                            count_checked++
-                        } else {
-                            food_checked = false
-                            count_unchecked++
-                        }
-                    }
-                    if (food_checked) {
-                        count_checked_food++
-                    } else {
-                        count_unchecked_food++
-                    }
-                }
-
-                Vue.set(structure[i], 'count_unchecked', count_unchecked)
-                Vue.set(structure[i], 'count_checked', count_checked)
-                Vue.set(structure[i], 'count_unchecked_food', count_unchecked_food)
-                Vue.set(structure[i], 'count_checked_food', count_checked_food)
-
-                total_unchecked += count_unchecked
-                total_checked += count_checked
-                total_unchecked_food += count_unchecked_food
-                total_checked_food += count_checked_food
-            }
-
-            this.total_unchecked = total_unchecked
-            this.total_checked = total_checked
-            this.total_unchecked_food = total_unchecked_food
-            this.total_checked_food = total_checked_food
-
-            // ordering
-            if (this.UNDEFINED_CATEGORY in structure) {
-                ordered_structure.push(structure[this.UNDEFINED_CATEGORY])
-                Vue.delete(structure, this.UNDEFINED_CATEGORY)
-            }
-
-            if (useUserPreferenceStore().device_settings.shopping_selected_grouping === this.GROUP_CATEGORY && useUserPreferenceStore().device_settings.shopping_selected_supermarket !== null) {
-                for (let c of useUserPreferenceStore().device_settings.shopping_selected_supermarket.category_to_supermarket) {
-                    if (c.category.name in structure) {
-                        ordered_structure.push(structure[c.category.name])
-                        Vue.delete(structure, c.category.name)
-                    }
-                }
-                if (!useUserPreferenceStore().device_settings.shopping_show_selected_supermarket_only) {
-                    for (let i in structure) {
-                        ordered_structure.push(structure[i])
-                    }
-                }
-            } else {
-                for (let i in structure) {
-                    ordered_structure.push(structure[i])
-                }
-            }
-
-            return ordered_structure
-        },
-        /**
-         * flattened list of entries used for exporters
-         * kinda uncool but works for now
-         * @return {*[]}
-         */
-        get_flat_entries: function () {
-            let items = []
-            for (let i in this.get_entries_by_group) {
-                for (let f in this.get_entries_by_group[i]['foods']) {
-                    for (let e in this.get_entries_by_group[i]['foods'][f]['entries']) {
-                        items.push({
-                            amount: this.get_entries_by_group[i]['foods'][f]['entries'][e].amount,
-                            unit: this.get_entries_by_group[i]['foods'][f]['entries'][e].unit?.name ?? '',
-                            food: this.get_entries_by_group[i]['foods'][f]['entries'][e].food?.name ?? '',
-                        })
-                    }
-                }
-            }
-            return items
-        },
-        /**
-         * list of options available for grouping entry display
-         * @return {[{id: *, translatable_label: string},{id: *, translatable_label: string},{id: *, translatable_label: string}]}
-         */
-        grouping_options: function () {
-            return [
-                {'id': this.GROUP_CATEGORY, 'translatable_label': 'Category'},
-                {'id': this.GROUP_CREATED_BY, 'translatable_label': 'created_by'},
-                {'id': this.GROUP_RECIPE, 'translatable_label': 'Recipe'}
-            ]
-        },
-        /**
-         * checks if failed items are contained in the sync queue
-         */
-        has_failed_items: function () {
-            for (let i in this.item_check_sync_queue) {
-                if (this.item_check_sync_queue[i]['status'] === 'syncing_failed_before' || this.item_check_sync_queue[i]['status'] === 'waiting_failed_before') {
-                    return true
-                }
-            }
-            return false
-        }
-    },
-    actions: {
-        /**
-         * Retrieves all shopping related data (shopping list entries, supermarkets, supermarket categories and shopping list recipes) from API
-         */
-        refreshFromAPI() {
-            if (!this.currently_updating) {
-                this.currently_updating = true
-                this.last_autosync = new Date().getTime();
-
-                let api = new ApiApi()
-                api.listShoppingListEntrys().then((r) => {
-                    this.entries = {}
-
-                    r.forEach((e) => {
-                        this.entries[e.id] = e
-                    })
-                    this.currently_updating = false
-                }).catch((err) => {
-                    this.currently_updating = false
-                    //StandardToasts.makeStandardToast(this, StandardToasts.FAIL_FETCH, err)
-                })
-
-                api.listSupermarketCategorys().then(r => {
-                    this.supermarket_categories = r
-                }).catch((err) => {
-                    // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_FETCH, err)
-                })
-
-                api.listSupermarkets().then(r => {
-                    this.supermarkets = r
-                }).catch((err) => {
-                    // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_FETCH, err)
-                })
-            }
-        },
-        /**
-         * perform auto sync request to special endpoint returning only entries changed since last auto sync
-         * only updates local entries that are older than the server version
-         */
-        autosync() {
-            if (!this.currently_updating && this.autosync_has_focus) {
-                console.log('running autosync')
-
-                this.currently_updating = true
-
-                let previous_autosync = this.last_autosync
-                this.last_autosync = new Date().getTime();
-
-                const api = new ApiApi()
-                // TODO query parameters
-                api.listShoppingListEntrys({last_autosync: previous_autosync}).then((r) => {
-                    r.forEach((e) => {
-                        // dont update stale client data
-                        if (!(Object.keys(this.entries).includes(e.id.toString())) || Date.parse(this.entries[e.id].updated_at) < Date.parse(e.updated_at)) {
-                            console.log('auto sync updating entry ', e)
-                            this.entries[e.id] = e
-                        }
-                    })
-                    this.currently_updating = false
-                }).catch((err) => {
-                    console.warn('auto sync failed')
-                    this.currently_updating = false
-                })
-            }
-        },
-        /**
-         * Create a new shopping list entry
-         * adds new entry to store
-         * @param object entry object to create
-         * @return {Promise<T | void>} promise of creation call to subscribe to
-         */
-        createObject(object) {
-            const api = new ApiApi()
-            return api.createShoppingListEntry(object).then((r) => {
-                this.entries[r.id] = r
-            }).catch((err) => {
-                // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_UPDATE, err)
-            })
-        },
-        /**
-         * update existing entry object and updated_at timestamp
-         * updates data in store
-         * IMPORTANT: always use this method to update objects to keep client state consistent
-         * @param object entry object to update
-         * @return {Promise<T | void>} promise of updating call to subscribe to
-         */
-        updateObject(object) {
-            const api = new ApiApi()
-            // sets the update_at timestamp on the client to prevent auto sync from overriding with older changes
-            // moment().format() yields locale aware datetime without ms 2024-01-04T13:39:08.607238+01:00
-            //Vue.set(object, 'updated_at', moment().format())
-            object['update_at'] = DateTime.toLocaleString() // TODO check formats
-
-            return api.updateShoppingListEntry(object.id, object).then((r) => {
-                this.entries[r.id] = r
-            }).catch((err) => {
-                // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_UPDATE, err)
-            })
-        },
-        /**
-         * delete shopping list entry object from DB and store
-         * @param object entry object to delete
-         * @return {Promise<T | void>} promise of delete call to subscribe to
-         */
-        deleteObject(object) {
-            const api = new ApiApi()
-            return api.destroyShoppingListEntry({id: object.id}).then((r) => {
-                delete this.entries[object.id]
-            }).catch((err) => {
-                // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_DELETE, err)
-            })
-        },
-        /**
-         * returns a distinct list of recipes associated with unchecked shopping list entries
-         */
-        getAssociatedRecipes: function () {
-            let recipes = {} // TODO this needs a type
-
-            for (let i in this.entries) {
-                let e = this.entries[i]
-                if (e.recipe_mealplan !== null) {
-                    recipes[e.recipe_mealplan.recipe] = {
-                        'shopping_list_recipe_id': e.list_recipe,
-                        'recipe_id': e.recipe_mealplan.recipe,
-                        'recipe_name': e.recipe_mealplan.recipe_name,
-                        'servings': e.recipe_mealplan.servings,
-                        'mealplan_from_date': e.recipe_mealplan.mealplan_from_date,
-                        'mealplan_type': e.recipe_mealplan.mealplan_type,
-                    }
-                }
-            }
-
-            return recipes
-        },
-        // convenience methods
-        /**
-         * function to set entry to its proper place in the data structure to perform grouping
-         * @param {{}} structure datastructure
-         * @param {*} entry entry to place
-         * @param {*} group group to place entry into (must be of ShoppingListStore.GROUP_XXX/dot notation of entry property)
-         * @returns {{}} datastructure including entry
-         */
-        updateEntryInStructure(structure, entry, group) {
-            let grouping_key = _.get(entry, group, this.UNDEFINED_CATEGORY)
-
-            if (grouping_key === undefined || grouping_key === null) {
-                grouping_key = this.UNDEFINED_CATEGORY
-            }
-
-            if (!(grouping_key in structure)) {
-                structure[grouping_key] = {'name': grouping_key, 'foods': {}}
-            }
-            if (!(entry.food.id in structure[grouping_key]['foods'])) {
-                structure[grouping_key]['foods'][entry.food.id] = {
-                    'id': entry.food.id,
-                    'name': entry.food.name,
-                    'entries': {}
-                }
-            }
-            structure[grouping_key]['foods'][entry.food.id]['entries'][entry.id] = entry
-            return structure
-        },
-        /**
-         * function to handle user checking or unchecking a set of entries
-         * @param {{}} entries set of entries
-         * @param checked boolean to set checked state of entry to
-         * @param undo if the user should be able to undo the change or not
-         */
-        setEntriesCheckedState(entries, checked, undo) {
-            if (undo) {
-                this.registerChange((checked ? 'CHECKED' : 'UNCHECKED'), entries)
-            }
-
-            let entry_id_list = []
-            for (let i in entries) {
-                this.entries[i]['checked'] = checked
-                this.entries[i]['updated_at'] = DateTime.now().toISOTime() // TODO was moment.format() (see above)
-                entry_id_list.push(i)
-            }
-
-            this.item_check_sync_queue[Math.random()] =  {
-                'ids': entry_id_list,
-                'checked': checked,
-                'status': 'waiting'
-            }
-            this.runSyncQueue(5)
-        },
-        /**
-         * go through the list of queued requests and try to run them
-         * add request back to queue if it fails due to offline or timeout
-         * Do NOT call this method directly, always call using runSyncQueue method to prevent simultaneous runs
-         * @private
-         */
-        _replaySyncQueue() {
-            if (navigator.onLine || document.location.href.includes('localhost')) {
-                let api = new ApiApi()
-                let promises = []
-
-                for (let i in this.item_check_sync_queue) {
-                    let entry = this.item_check_sync_queue[i]
-                    entry['status'] = ((entry['status'] === 'waiting') ? 'syncing' : 'syncing_failed_before')
-                    this.item_check_sync_queue[i] = entry
-
-                    // TODO request params
-                    let p = api.bulkShoppingListEntry(entry, {timeout: 15000}).then((r) => {
-                        delete this.item_check_sync_queue[i]
-                    }).catch((err) => {
-                        if (err.code === "ERR_NETWORK" || err.code === "ECONNABORTED") {
-                            entry['status'] = 'waiting_failed_before'
-                            this.item_check_sync_queue[i] = entry
-                        } else {
-                             delete this.item_check_sync_queue[i]
-                            console.error('Failed API call for entry ', entry)
-                            // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_UPDATE, err)
-                        }
-                    })
-                    promises.push(p)
-                }
-
-                Promise.allSettled(promises).finally(r => {
-                    this.runSyncQueue(500)
-                })
-            } else {
-                this.runSyncQueue(5000)
-            }
-        },
-        /**
-         * manages running the replaySyncQueue function after the given timeout
-         * calling this function might cancel a previously created timeout
-         * @param timeout time in ms after which to run the replaySyncQueue function
-         */
-        runSyncQueue(timeout) {
-            clearTimeout(this.queue_timeout_id)
-
-            this.queue_timeout_id = setTimeout(() => {
-                this._replaySyncQueue()
-            }, timeout)
-        },
-        /**
-         * function to handle user "delaying" and "undelaying" shopping entries
-         * @param {{}} entries set of entries
-         * @param delay if entries should be delayed or if delay should be removed
-         * @param undo if the user should be able to undo the change or not
-         */
-        delayEntries(entries, delay, undo) {
-            let delay_hours = useUserPreferenceStore().user_settings.default_delay
-            let delay_date = new Date(Date.now() + delay_hours * (60 * 60 * 1000))
-
-            if (undo) {
-                this.registerChange((delay ? 'DELAY' : 'UNDELAY'), entries)
-            }
-
-            for (let i in entries) {
-                this.entries[i].delay_until = (delay ? delay_date : null)
-                this.updateObject(this.entries[i])
-            }
-        },
-        /**
-         * delete list of entries
-         * @param {{}} entries set of entries
-         */
-        deleteEntries(entries) {
-            for (let i in entries) {
-                this.deleteObject(this.entries[i])
-            }
-        },
-        deleteShoppingListRecipe(shopping_list_recipe_id) {
-            const api = new ApiApi()
-
-            for (let i in this.entries) {
-                if (this.entries[i].list_recipe === shopping_list_recipe_id) {
-                    delete this.entries[i]
-                }
-            }
-
-            api.destroyShoppingListRecipe(shopping_list_recipe_id).then((x) => {
-                // no need to update anything, entries were already removed
-            }).catch((err) => {
-                // StandardToasts.makeStandardToast(this, StandardToasts.FAIL_DELETE, err)
-            })
-        },
-        /**
-         * register the change to a set of entries to allow undoing it
-         * throws an Error if the operation type is not known
-         * @param type the type of change to register. This determines what undoing the change does. (CREATE->delete object,
-         *              CHECKED->uncheck entry, UNCHECKED->check entry, DELAY->remove delay)
-         * @param {{}} entries set of entries
-         */
-        registerChange(type, entries) {
-            if (!['CREATED', 'CHECKED', 'UNCHECKED', 'DELAY', 'UNDELAY'].includes(type)) {
-                throw Error('Tried to register unknown change type')
-            }
-            this.undo_stack.push({'type': type, 'entries': entries})
-        },
-        /**
-         * takes the last item from the undo stack and reverts it
-         */
-        undoChange() {
-            let last_item = this.undo_stack.pop()
-            if (last_item !== undefined) {
-                let type = last_item['type']
-                let entries = last_item['entries']
-
-                if (type === 'CHECKED' || type === 'UNCHECKED') {
-                    this.setEntriesCheckedState(entries, (type === 'UNCHECKED'), false)
-                } else if (type === 'DELAY' || type === 'UNDELAY') {
-                    this.delayEntries(entries, (type === 'UNDELAY'), false)
-                } else if (type === 'CREATED') {
-                    for (let i in entries) {
-                        let e = entries[i]
-                        this.deleteObject(e)
-                    }
-                }
-            } else {
-                // can use localization in store
-                //StandardToasts.makeStandardToast(this, this.$t('NoMoreUndo'))
-            }
-        }
-    },
-})
diff --git a/vue3/src/stores/ShoppingStore.ts b/vue3/src/stores/ShoppingStore.ts
index c56fd0327..bfb639e34 100644
--- a/vue3/src/stores/ShoppingStore.ts
+++ b/vue3/src/stores/ShoppingStore.ts
@@ -43,15 +43,11 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
     let queueTimeoutId = ref(-1)
     let itemCheckSyncQueue = ref([] as IShoppingSyncQueueEntry[])
 
-
     /**
      * build a multi-level data structure ready for display from shopping list entries
      * group by selected grouping key
      */
     const getEntriesByGroup = computed(() => {
-        //TODO why is this called many times on each auto sync
-        console.log('running getEntriesByGroup')
-
         stats.value = {
             countChecked: 0,
             countUnchecked: 0,
@@ -73,7 +69,7 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
 
         // build structure
         entries.value.forEach(shoppingListEntry => {
-            structure = updateEntryInStructure(structure, shoppingListEntry, useUserPreferenceStore().deviceSettings.shopping_selected_grouping)
+            structure = updateEntryInStructure(structure, shoppingListEntry)
         })
 
         // statistics for UI conditions and display
@@ -115,8 +111,9 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
         })
 
         // ordering
-        if (structure.categories.has(UNDEFINED_CATEGORY)) {
-            orderedStructure.push(structure.categories.get(UNDEFINED_CATEGORY))
+        let undefinedCategoryGroup = structure.categories.get(UNDEFINED_CATEGORY)
+        if (undefinedCategoryGroup != null) {
+            orderedStructure.push(undefinedCategoryGroup)
             structure.categories.delete(UNDEFINED_CATEGORY)
         }
 
@@ -207,9 +204,7 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
             const api = new ApiApi()
             api.apiShoppingListEntryList({updatedAfter: autoSyncLastTimestamp.value}).then((r) => {
                 autoSyncLastTimestamp.value = r.timestamp!
-
                 r.results.forEach((e) => {
-                    console.log('updating entry by auto sync ', e)
                     entries.value.set(e.id!, e)
                 })
                 currentlyUpdating.value = false
@@ -220,15 +215,17 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
     }
 
     /**
-     * Create a new shopping list entry
-     * adds new entry to store
-     * @param object entry object to create
-     * @return {Promise<ShoppingListEntry>} promise of creation call to subscribe to
+     * creates new ShoppingListEntry in database and updates it in store
+     * @param object entry to create
+     * @param undo if the user should be able to undo the change or not
      */
-    function createObject(object: ShoppingListEntry) {
+    function createObject(object: ShoppingListEntry, undo: boolean) {
         const api = new ApiApi()
         return api.apiShoppingListEntryCreate({shoppingListEntry: object}).then((r) => {
             entries.value.set(r.id!, r)
+            if (undo) {
+                registerChange("CREATE", [r])
+            }
         }).catch((err) => {
             useMessageStore().addError(ErrorMessageType.CREATE_ERROR, err)
         })
@@ -259,12 +256,15 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
     /**
      * delete shopping list entry object from DB and store
      * @param object entry object to delete
-     * @return {Promise<ShoppingListEntry>} promise of delete call to subscribe to
+     * @param undo if the user should be able to undo the change or not
      */
-    function deleteObject(object: ShoppingListEntry) {
+    function deleteObject(object: ShoppingListEntry, undo: boolean) {
         const api = new ApiApi()
         return api.apiShoppingListEntryDestroy({id: object.id!}).then((r) => {
             entries.value.delete(object.id!)
+            if (undo) {
+                registerChange("DESTROY", [object])
+            }
         }).catch((err) => {
             useMessageStore().addError(ErrorMessageType.DELETE_ERROR, err)
         })
@@ -368,7 +368,7 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
                     })
                     itemCheckSyncQueue.value.splice(index, 1)
                 }).catch((err) => {
-                    if (err.code === "ERR_NETWORK" || err.code === "ECONNABORTED") {
+                    if (err.name === "FetchError") {
                         entry['status'] = 'waiting_failed_before'
                     } else {
                         itemCheckSyncQueue.value.splice(index, 1)
@@ -377,11 +377,14 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
                 })
                 promises.push(p)
             })
-            // TODO verify this all settled works
+
             Promise.allSettled(promises).finally(() => {
-                runSyncQueue(500)
+                if (itemCheckSyncQueue.value.length > 0) {
+                    runSyncQueue(500)
+                }
             })
         } else {
+            // try again if internet after a few seconds
             runSyncQueue(5000)
         }
     }
@@ -454,7 +457,7 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
      */
     function deleteEntries(entries: ShoppingListEntry[]) {
         entries.forEach((entry) => {
-            deleteObject(entry)
+            deleteObject(entry, false)
         })
     }
 
@@ -499,10 +502,15 @@ export const useShoppingStore = defineStore(_STORE_ID, () => {
                 setEntriesCheckedState(entries, (type === 'UNCHECKED'), false)
             } else if (type === 'DELAY' || type === 'UNDELAY') {
                 setEntriesDelayedState(entries, (type === 'UNDELAY'), false)
-            } else if (type === 'CREATED') {
+            } else if (type === 'CREATE') {
                 for (let i in entries) {
                     let e = entries[i]
-                    deleteObject(e)
+                    deleteObject(e, false)
+                }
+            } else if (type === 'DESTROY') {
+                for (let i in entries) {
+                    let e = entries[i]
+                    createObject(e, false)
                 }
             } else if (type === 'IGNORE' || type === 'UNIGNORE') {
                 setFoodIgnoredState(entries, (type === 'UNIGNORE'), false)
diff --git a/vue3/src/stores/UserPreferenceStore.ts b/vue3/src/stores/UserPreferenceStore.ts
index 7672a998a..096b35e16 100644
--- a/vue3/src/stores/UserPreferenceStore.ts
+++ b/vue3/src/stores/UserPreferenceStore.ts
@@ -1,7 +1,7 @@
 import {acceptHMRUpdate, defineStore} from 'pinia'
 import {useStorage} from "@vueuse/core";
 import {ErrorMessageType, PreparedMessage, useMessageStore} from "@/stores/MessageStore";
-import {ApiApi, ServerSettings, Space, UserPreference} from "@/openapi";
+import {ApiApi, ServerSettings, Space, Supermarket, UserPreference} from "@/openapi";
 import {ShoppingGroupingOptions} from "@/types/Shopping";
 
 const DEVICE_SETTINGS_KEY = 'TANDOOR_DEVICE_SETTINGS'
@@ -14,10 +14,11 @@ class DeviceSettings {
     shopping_show_delayed_entries = false
     shopping_show_selected_supermarket_only = false
     shopping_selected_grouping = ShoppingGroupingOptions.CATEGORY
-    shopping_selected_supermarket = null
+    shopping_selected_supermarket: Supermarket = {} as Supermarket
     shopping_item_info_created_by = false
     shopping_item_info_mealplan = false
     shopping_item_info_recipe = true
+    shopping_show_debug = false
 
     mealplan_displayPeriod = 'week'
     mealplan_displayPeriodCount = 3
diff --git a/vue3/src/types/Shopping.ts b/vue3/src/types/Shopping.ts
index bce43a17d..837cc98a0 100644
--- a/vue3/src/types/Shopping.ts
+++ b/vue3/src/types/Shopping.ts
@@ -79,7 +79,7 @@ export type ShoppingListStats = {
  * DELAY: ShoppingListEntry was postponed/delayed
  * UNDELAY: ShoppingListEntry delay was removed
  */
-export type ShoppingOperationHistoryType = 'CREATED' | 'CHECKED' | 'UNCHECKED' | 'DELAY' | 'UNDELAY' | 'IGNORE' | 'UNIGNORE'
+export type ShoppingOperationHistoryType = 'CHECKED' | 'UNCHECKED' | 'DELAY' | 'UNDELAY' | 'IGNORE' | 'UNIGNORE' | 'CREATE' | 'DESTROY'
 
 /**
  * history event consisting of a type and affected entries
diff --git a/vue3/src/utils/logic_utils.ts b/vue3/src/utils/logic_utils.ts
index d1323d752..12b7f7bbb 100644
--- a/vue3/src/utils/logic_utils.ts
+++ b/vue3/src/utils/logic_utils.ts
@@ -8,7 +8,7 @@ import {IShoppingListFood} from "@/types/Shopping";
 export function isDelayed(entry: ShoppingListEntry){
     // this function is needed because the openapi typescript fetch client always replaces null with undefined, so delayUntil cant be
     // set back to null once it has been delayed once. This will hopefully be fixed at some point, until then un-delaying will set the date to 1997-1-1 00:00
-    return entry.delayUntil !== null && entry.delayUntil > Date.now()
+    return entry.delayUntil != null && entry.delayUntil > new Date()
 }
 
 /**