playing with plugins

vue3/src/openapi/.openapi-generator/FILES

@@ -64,6 +64,13 @@ models/PaginatedInviteLinkList.ts
 models/PaginatedKeywordList.ts
 models/PaginatedMealPlanList.ts
 models/PaginatedMealTypeList.ts
+models/PaginatedOpenDataCategoryList.ts
+models/PaginatedOpenDataConversionList.ts
+models/PaginatedOpenDataFoodList.ts
+models/PaginatedOpenDataPropertyList.ts
+models/PaginatedOpenDataStoreList.ts
+models/PaginatedOpenDataUnitList.ts
+models/PaginatedOpenDataVersionList.ts
 models/PaginatedPropertyList.ts
 models/PaginatedPropertyTypeList.ts
 models/PaginatedRecipeBookEntryList.ts

vue3/src/openapi/apis/ApiApi.ts

@@ -60,6 +60,13 @@ import type {
   PaginatedKeywordList,
   PaginatedMealPlanList,
   PaginatedMealTypeList,
+  PaginatedOpenDataCategoryList,
+  PaginatedOpenDataConversionList,
+  PaginatedOpenDataFoodList,
+  PaginatedOpenDataPropertyList,
+  PaginatedOpenDataStoreList,
+  PaginatedOpenDataUnitList,
+  PaginatedOpenDataVersionList,
   PaginatedPropertyList,
   PaginatedPropertyTypeList,
   PaginatedRecipeBookEntryList,
@@ -252,6 +259,20 @@ import {
     PaginatedMealPlanListToJSON,
     PaginatedMealTypeListFromJSON,
     PaginatedMealTypeListToJSON,
+    PaginatedOpenDataCategoryListFromJSON,
+    PaginatedOpenDataCategoryListToJSON,
+    PaginatedOpenDataConversionListFromJSON,
+    PaginatedOpenDataConversionListToJSON,
+    PaginatedOpenDataFoodListFromJSON,
+    PaginatedOpenDataFoodListToJSON,
+    PaginatedOpenDataPropertyListFromJSON,
+    PaginatedOpenDataPropertyListToJSON,
+    PaginatedOpenDataStoreListFromJSON,
+    PaginatedOpenDataStoreListToJSON,
+    PaginatedOpenDataUnitListFromJSON,
+    PaginatedOpenDataUnitListToJSON,
+    PaginatedOpenDataVersionListFromJSON,
+    PaginatedOpenDataVersionListToJSON,
     PaginatedPropertyListFromJSON,
     PaginatedPropertyListToJSON,
     PaginatedPropertyTypeListFromJSON,
@@ -955,6 +976,11 @@ export interface ApiOpenDataCategoryDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataCategoryListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataCategoryPartialUpdateRequest {
     id: number;
     patchedOpenDataCategory?: Omit<PatchedOpenDataCategory, 'createdBy'>;
@@ -977,6 +1003,11 @@ export interface ApiOpenDataConversionDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataConversionListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataConversionPartialUpdateRequest {
     id: number;
     patchedOpenDataConversion?: Omit<PatchedOpenDataConversion, 'createdBy'>;
@@ -1003,6 +1034,16 @@ export interface ApiOpenDataFoodDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataFoodFdcCreateRequest {
+    id: number;
+    openDataFood: Omit<OpenDataFood, 'createdBy'>;
+}
+
+export interface ApiOpenDataFoodListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataFoodPartialUpdateRequest {
     id: number;
     patchedOpenDataFood?: Omit<PatchedOpenDataFood, 'createdBy'>;
@@ -1025,6 +1066,11 @@ export interface ApiOpenDataPropertyDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataPropertyListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataPropertyPartialUpdateRequest {
     id: number;
     patchedOpenDataProperty?: Omit<PatchedOpenDataProperty, 'createdBy'>;
@@ -1047,6 +1093,11 @@ export interface ApiOpenDataStoreDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataStoreListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataStorePartialUpdateRequest {
     id: number;
     patchedOpenDataStore?: Omit<PatchedOpenDataStore, 'createdBy'>;
@@ -1069,6 +1120,11 @@ export interface ApiOpenDataUnitDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataUnitListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataUnitPartialUpdateRequest {
     id: number;
     patchedOpenDataUnit?: Omit<PatchedOpenDataUnit, 'createdBy'>;
@@ -1091,6 +1147,11 @@ export interface ApiOpenDataVersionDestroyRequest {
     id: number;
 }
 
+export interface ApiOpenDataVersionListRequest {
+    page?: number;
+    pageSize?: number;
+}
+
 export interface ApiOpenDataVersionPartialUpdateRequest {
     id: number;
     patchedOpenDataVersion?: PatchedOpenDataVersion;
@@ -6324,9 +6385,17 @@ export class ApiApi extends runtime.BaseAPI {
 
     /**
      */
-    async apiOpenDataCategoryListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataCategory>>> {
+    async apiOpenDataCategoryListRaw(requestParameters: ApiOpenDataCategoryListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataCategoryList>> {
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.apiKey) {
@@ -6340,13 +6409,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataCategoryFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataCategoryListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataCategoryList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataCategory>> {
-        const response = await this.apiOpenDataCategoryListRaw(initOverrides);
+    async apiOpenDataCategoryList(requestParameters: ApiOpenDataCategoryListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataCategoryList> {
+        const response = await this.apiOpenDataCategoryListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -6542,9 +6611,17 @@ export class ApiApi extends runtime.BaseAPI {
 
     /**
      */
-    async apiOpenDataConversionListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataConversion>>> {
+    async apiOpenDataConversionListRaw(requestParameters: ApiOpenDataConversionListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataConversionList>> {
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.apiKey) {
@@ -6558,13 +6635,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataConversionFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataConversionListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataConversionList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataConversion>> {
-        const response = await this.apiOpenDataConversionListRaw(initOverrides);
+    async apiOpenDataConversionList(requestParameters: ApiOpenDataConversionListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataConversionList> {
+        const response = await this.apiOpenDataConversionListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -6793,12 +6870,67 @@ export class ApiApi extends runtime.BaseAPI {
     }
 
     /**
+     * updates the food with all possible data from the FDC Api if properties with a fdc_id already exist they will be overridden, if existing properties don\'t have a fdc_id they won\'t be changed
      */
-    async apiOpenDataFoodListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataFood>>> {
+    async apiOpenDataFoodFdcCreateRaw(requestParameters: ApiOpenDataFoodFdcCreateRequest, 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 apiOpenDataFoodFdcCreate().'
+            );
+        }
+
+        if (requestParameters['openDataFood'] == null) {
+            throw new runtime.RequiredError(
+                'openDataFood',
+                'Required parameter "openDataFood" was null or undefined when calling apiOpenDataFoodFdcCreate().'
+            );
+        }
+
         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}/fdc/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: OpenDataFoodToJSON(requestParameters['openDataFood']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataFoodFromJSON(jsonValue));
+    }
+
+    /**
+     * updates the food with all possible data from the FDC Api if properties with a fdc_id already exist they will be overridden, if existing properties don\'t have a fdc_id they won\'t be changed
+     */
+    async apiOpenDataFoodFdcCreate(requestParameters: ApiOpenDataFoodFdcCreateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
+        const response = await this.apiOpenDataFoodFdcCreateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     */
+    async apiOpenDataFoodListRaw(requestParameters: ApiOpenDataFoodListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataFoodList>> {
+        const queryParameters: any = {};
+
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["Authorization"] = await this.configuration.apiKey("Authorization"); // ApiKeyAuth authentication
         }
@@ -6810,13 +6942,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataFoodFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataFoodListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataFoodList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataFood>> {
-        const response = await this.apiOpenDataFoodListRaw(initOverrides);
+    async apiOpenDataFoodList(requestParameters: ApiOpenDataFoodListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataFoodList> {
+        const response = await this.apiOpenDataFoodListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -7012,9 +7144,17 @@ export class ApiApi extends runtime.BaseAPI {
 
     /**
      */
-    async apiOpenDataPropertyListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataProperty>>> {
+    async apiOpenDataPropertyListRaw(requestParameters: ApiOpenDataPropertyListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataPropertyList>> {
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.apiKey) {
@@ -7028,13 +7168,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataPropertyFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataPropertyListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataPropertyList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataProperty>> {
-        const response = await this.apiOpenDataPropertyListRaw(initOverrides);
+    async apiOpenDataPropertyList(requestParameters: ApiOpenDataPropertyListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataPropertyList> {
+        const response = await this.apiOpenDataPropertyListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -7257,9 +7397,17 @@ export class ApiApi extends runtime.BaseAPI {
 
     /**
      */
-    async apiOpenDataStoreListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataStore>>> {
+    async apiOpenDataStoreListRaw(requestParameters: ApiOpenDataStoreListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataStoreList>> {
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.apiKey) {
@@ -7273,13 +7421,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataStoreFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataStoreListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataStoreList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataStore>> {
-        const response = await this.apiOpenDataStoreListRaw(initOverrides);
+    async apiOpenDataStoreList(requestParameters: ApiOpenDataStoreListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataStoreList> {
+        const response = await this.apiOpenDataStoreListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -7475,9 +7623,17 @@ export class ApiApi extends runtime.BaseAPI {
 
     /**
      */
-    async apiOpenDataUnitListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataUnit>>> {
+    async apiOpenDataUnitListRaw(requestParameters: ApiOpenDataUnitListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataUnitList>> {
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.apiKey) {
@@ -7491,13 +7647,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataUnitFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataUnitListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataUnitList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataUnit>> {
-        const response = await this.apiOpenDataUnitListRaw(initOverrides);
+    async apiOpenDataUnitList(requestParameters: ApiOpenDataUnitListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataUnitList> {
+        const response = await this.apiOpenDataUnitListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
@@ -7693,9 +7849,17 @@ export class ApiApi extends runtime.BaseAPI {
 
     /**
      */
-    async apiOpenDataVersionListRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataVersion>>> {
+    async apiOpenDataVersionListRaw(requestParameters: ApiOpenDataVersionListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PaginatedOpenDataVersionList>> {
         const queryParameters: any = {};
 
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+
+        if (requestParameters['pageSize'] != null) {
+            queryParameters['page_size'] = requestParameters['pageSize'];
+        }
+
         const headerParameters: runtime.HTTPHeaders = {};
 
         if (this.configuration && this.configuration.apiKey) {
@@ -7709,13 +7873,13 @@ export class ApiApi extends runtime.BaseAPI {
             query: queryParameters,
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(OpenDataVersionFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => PaginatedOpenDataVersionListFromJSON(jsonValue));
     }
 
     /**
      */
-    async apiOpenDataVersionList(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataVersion>> {
-        const response = await this.apiOpenDataVersionListRaw(initOverrides);
+    async apiOpenDataVersionList(requestParameters: ApiOpenDataVersionListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PaginatedOpenDataVersionList> {
+        const response = await this.apiOpenDataVersionListRaw(requestParameters, initOverrides);
         return await response.value();
     }
 

vue3/src/openapi/models/BaseUnitEnum.ts

@@ -14,43 +14,47 @@
 
 
 /**
- * * `G` - g
- * * `KG` - kg
- * * `ML` - ml
- * * `L` - l
- * * `OUNCE` - ounce
- * * `POUND` - pound
- * * `FLUID_OUNCE` - fluid_ounce
- * * `TSP` - tsp
- * * `TBSP` - tbsp
- * * `CUP` - cup
- * * `PINT` - pint
- * * `QUART` - quart
- * * `GALLON` - gallon
- * * `IMPERIAL_FLUID_OUNCE` - imperial fluid ounce
- * * `IMPERIAL_PINT` - imperial pint
- * * `IMPERIAL_QUART` - imperial quart
- * * `IMPERIAL_GALLON` - imperial gallon
+ * * `g` - g
+ * * `kg` - kg
+ * * `ounce` - ounce
+ * * `pound` - pound
+ * * `ml` - ml
+ * * `l` - l
+ * * `fluid_ounce` - fluid_ounce
+ * * `pint` - pint
+ * * `quart` - quart
+ * * `gallon` - gallon
+ * * `tbsp` - tbsp
+ * * `tsp` - tsp
+ * * `us_cup` - US Cup
+ * * `imperial_fluid_ounce` - imperial fluid ounce
+ * * `imperial_pint` - imperial pint
+ * * `imperial_quart` - imperial quart
+ * * `imperial_gallon` - imperial gallon
+ * * `imperial_tbsp` - imperial tbsp
+ * * `imperial_tsp` - imperial tsp
  * @export
  */
 export const BaseUnitEnum = {
-    G: 'G',
-    Kg: 'KG',
-    Ml: 'ML',
-    L: 'L',
-    Ounce: 'OUNCE',
-    Pound: 'POUND',
-    FluidOunce: 'FLUID_OUNCE',
-    Tsp: 'TSP',
-    Tbsp: 'TBSP',
-    Cup: 'CUP',
-    Pint: 'PINT',
-    Quart: 'QUART',
-    Gallon: 'GALLON',
-    ImperialFluidOunce: 'IMPERIAL_FLUID_OUNCE',
-    ImperialPint: 'IMPERIAL_PINT',
-    ImperialQuart: 'IMPERIAL_QUART',
-    ImperialGallon: 'IMPERIAL_GALLON'
+    G: 'g',
+    Kg: 'kg',
+    Ounce: 'ounce',
+    Pound: 'pound',
+    Ml: 'ml',
+    L: 'l',
+    FluidOunce: 'fluid_ounce',
+    Pint: 'pint',
+    Quart: 'quart',
+    Gallon: 'gallon',
+    Tbsp: 'tbsp',
+    Tsp: 'tsp',
+    UsCup: 'us_cup',
+    ImperialFluidOunce: 'imperial_fluid_ounce',
+    ImperialPint: 'imperial_pint',
+    ImperialQuart: 'imperial_quart',
+    ImperialGallon: 'imperial_gallon',
+    ImperialTbsp: 'imperial_tbsp',
+    ImperialTsp: 'imperial_tsp'
 } as const;
 export type BaseUnitEnum = typeof BaseUnitEnum[keyof typeof BaseUnitEnum];
 

vue3/src/openapi/models/OpenDataFood.ts

@@ -164,10 +164,10 @@ export interface OpenDataFood {
     propertiesSource?: string;
     /**
      * 
-     * @type {string}
+     * @type {number}
      * @memberof OpenDataFood
      */
-    fdcId: string;
+    fdcId?: number;
     /**
      * 
      * @type {string}
@@ -193,7 +193,6 @@ export function instanceOfOpenDataFood(value: object): value is OpenDataFood {
     if (!('storeCategory' in value) || value['storeCategory'] === undefined) return false;
     if (!('properties' in value) || value['properties'] === undefined) return false;
     if (!('propertiesFoodUnit' in value) || value['propertiesFoodUnit'] === undefined) return false;
-    if (!('fdcId' in value) || value['fdcId'] === undefined) return false;
     if (!('createdBy' in value) || value['createdBy'] === undefined) return false;
     return true;
 }
@@ -222,7 +221,7 @@ export function OpenDataFoodFromJSONTyped(json: any, ignoreDiscriminator: boolea
         'propertiesFoodAmount': json['properties_food_amount'] == null ? undefined : json['properties_food_amount'],
         'propertiesFoodUnit': OpenDataUnitFromJSON(json['properties_food_unit']),
         'propertiesSource': json['properties_source'] == null ? undefined : json['properties_source'],
-        'fdcId': json['fdc_id'],
+        'fdcId': json['fdc_id'] == null ? undefined : json['fdc_id'],
         'comment': json['comment'] == null ? undefined : json['comment'],
         'createdBy': json['created_by'],
     };

vue3/src/openapi/models/PaginatedOpenDataCategoryList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataCategory } from './OpenDataCategory';
+import {
+    OpenDataCategoryFromJSON,
+    OpenDataCategoryFromJSONTyped,
+    OpenDataCategoryToJSON,
+} from './OpenDataCategory';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataCategoryList
+ */
+export interface PaginatedOpenDataCategoryList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataCategoryList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataCategoryList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataCategoryList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataCategory>}
+     * @memberof PaginatedOpenDataCategoryList
+     */
+    results: Array<OpenDataCategory>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataCategoryList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataCategoryList interface.
+ */
+export function instanceOfPaginatedOpenDataCategoryList(value: object): value is PaginatedOpenDataCategoryList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataCategoryListFromJSON(json: any): PaginatedOpenDataCategoryList {
+    return PaginatedOpenDataCategoryListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataCategoryListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataCategoryList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataCategoryFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataCategoryListToJSON(value?: PaginatedOpenDataCategoryList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataCategoryToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PaginatedOpenDataConversionList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataConversion } from './OpenDataConversion';
+import {
+    OpenDataConversionFromJSON,
+    OpenDataConversionFromJSONTyped,
+    OpenDataConversionToJSON,
+} from './OpenDataConversion';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataConversionList
+ */
+export interface PaginatedOpenDataConversionList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataConversionList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataConversionList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataConversionList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataConversion>}
+     * @memberof PaginatedOpenDataConversionList
+     */
+    results: Array<OpenDataConversion>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataConversionList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataConversionList interface.
+ */
+export function instanceOfPaginatedOpenDataConversionList(value: object): value is PaginatedOpenDataConversionList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataConversionListFromJSON(json: any): PaginatedOpenDataConversionList {
+    return PaginatedOpenDataConversionListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataConversionListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataConversionList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataConversionFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataConversionListToJSON(value?: PaginatedOpenDataConversionList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataConversionToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PaginatedOpenDataFoodList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataFood } from './OpenDataFood';
+import {
+    OpenDataFoodFromJSON,
+    OpenDataFoodFromJSONTyped,
+    OpenDataFoodToJSON,
+} from './OpenDataFood';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataFoodList
+ */
+export interface PaginatedOpenDataFoodList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataFoodList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataFoodList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataFoodList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataFood>}
+     * @memberof PaginatedOpenDataFoodList
+     */
+    results: Array<OpenDataFood>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataFoodList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataFoodList interface.
+ */
+export function instanceOfPaginatedOpenDataFoodList(value: object): value is PaginatedOpenDataFoodList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataFoodListFromJSON(json: any): PaginatedOpenDataFoodList {
+    return PaginatedOpenDataFoodListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataFoodListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataFoodList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataFoodFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataFoodListToJSON(value?: PaginatedOpenDataFoodList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataFoodToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PaginatedOpenDataPropertyList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataProperty } from './OpenDataProperty';
+import {
+    OpenDataPropertyFromJSON,
+    OpenDataPropertyFromJSONTyped,
+    OpenDataPropertyToJSON,
+} from './OpenDataProperty';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataPropertyList
+ */
+export interface PaginatedOpenDataPropertyList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataPropertyList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataPropertyList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataPropertyList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataProperty>}
+     * @memberof PaginatedOpenDataPropertyList
+     */
+    results: Array<OpenDataProperty>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataPropertyList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataPropertyList interface.
+ */
+export function instanceOfPaginatedOpenDataPropertyList(value: object): value is PaginatedOpenDataPropertyList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataPropertyListFromJSON(json: any): PaginatedOpenDataPropertyList {
+    return PaginatedOpenDataPropertyListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataPropertyListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataPropertyList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataPropertyFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataPropertyListToJSON(value?: PaginatedOpenDataPropertyList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataPropertyToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PaginatedOpenDataStoreList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataStore } from './OpenDataStore';
+import {
+    OpenDataStoreFromJSON,
+    OpenDataStoreFromJSONTyped,
+    OpenDataStoreToJSON,
+} from './OpenDataStore';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataStoreList
+ */
+export interface PaginatedOpenDataStoreList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataStoreList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataStoreList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataStoreList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataStore>}
+     * @memberof PaginatedOpenDataStoreList
+     */
+    results: Array<OpenDataStore>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataStoreList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataStoreList interface.
+ */
+export function instanceOfPaginatedOpenDataStoreList(value: object): value is PaginatedOpenDataStoreList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataStoreListFromJSON(json: any): PaginatedOpenDataStoreList {
+    return PaginatedOpenDataStoreListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataStoreListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataStoreList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataStoreFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataStoreListToJSON(value?: PaginatedOpenDataStoreList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataStoreToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PaginatedOpenDataUnitList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataUnit } from './OpenDataUnit';
+import {
+    OpenDataUnitFromJSON,
+    OpenDataUnitFromJSONTyped,
+    OpenDataUnitToJSON,
+} from './OpenDataUnit';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataUnitList
+ */
+export interface PaginatedOpenDataUnitList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataUnitList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataUnitList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataUnitList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataUnit>}
+     * @memberof PaginatedOpenDataUnitList
+     */
+    results: Array<OpenDataUnit>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataUnitList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataUnitList interface.
+ */
+export function instanceOfPaginatedOpenDataUnitList(value: object): value is PaginatedOpenDataUnitList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataUnitListFromJSON(json: any): PaginatedOpenDataUnitList {
+    return PaginatedOpenDataUnitListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataUnitListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataUnitList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataUnitFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataUnitListToJSON(value?: PaginatedOpenDataUnitList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataUnitToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PaginatedOpenDataVersionList.ts

@@ -0,0 +1,101 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Tandoor
+ * Tandoor API Docs
+ *
+ * The version of the OpenAPI document: 0.0.0
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime';
+import type { OpenDataVersion } from './OpenDataVersion';
+import {
+    OpenDataVersionFromJSON,
+    OpenDataVersionFromJSONTyped,
+    OpenDataVersionToJSON,
+} from './OpenDataVersion';
+
+/**
+ * 
+ * @export
+ * @interface PaginatedOpenDataVersionList
+ */
+export interface PaginatedOpenDataVersionList {
+    /**
+     * 
+     * @type {number}
+     * @memberof PaginatedOpenDataVersionList
+     */
+    count: number;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataVersionList
+     */
+    next?: string;
+    /**
+     * 
+     * @type {string}
+     * @memberof PaginatedOpenDataVersionList
+     */
+    previous?: string;
+    /**
+     * 
+     * @type {Array<OpenDataVersion>}
+     * @memberof PaginatedOpenDataVersionList
+     */
+    results: Array<OpenDataVersion>;
+    /**
+     * 
+     * @type {Date}
+     * @memberof PaginatedOpenDataVersionList
+     */
+    timestamp?: Date;
+}
+
+/**
+ * Check if a given object implements the PaginatedOpenDataVersionList interface.
+ */
+export function instanceOfPaginatedOpenDataVersionList(value: object): value is PaginatedOpenDataVersionList {
+    if (!('count' in value) || value['count'] === undefined) return false;
+    if (!('results' in value) || value['results'] === undefined) return false;
+    return true;
+}
+
+export function PaginatedOpenDataVersionListFromJSON(json: any): PaginatedOpenDataVersionList {
+    return PaginatedOpenDataVersionListFromJSONTyped(json, false);
+}
+
+export function PaginatedOpenDataVersionListFromJSONTyped(json: any, ignoreDiscriminator: boolean): PaginatedOpenDataVersionList {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'count': json['count'],
+        'next': json['next'] == null ? undefined : json['next'],
+        'previous': json['previous'] == null ? undefined : json['previous'],
+        'results': ((json['results'] as Array<any>).map(OpenDataVersionFromJSON)),
+        'timestamp': json['timestamp'] == null ? undefined : (new Date(json['timestamp'])),
+    };
+}
+
+export function PaginatedOpenDataVersionListToJSON(value?: PaginatedOpenDataVersionList | null): any {
+    if (value == null) {
+        return value;
+    }
+    return {
+        
+        'count': value['count'],
+        'next': value['next'],
+        'previous': value['previous'],
+        'results': ((value['results'] as Array<any>).map(OpenDataVersionToJSON)),
+        'timestamp': value['timestamp'] == null ? undefined : ((value['timestamp']).toISOString()),
+    };
+}
+

vue3/src/openapi/models/PatchedOpenDataFood.ts

@@ -164,10 +164,10 @@ export interface PatchedOpenDataFood {
     propertiesSource?: string;
     /**
      * 
-     * @type {string}
+     * @type {number}
      * @memberof PatchedOpenDataFood
      */
-    fdcId?: string;
+    fdcId?: number;
     /**
      * 
      * @type {string}

vue3/src/openapi/models/index.ts

@@ -62,6 +62,13 @@ export * from './PaginatedInviteLinkList';
 export * from './PaginatedKeywordList';
 export * from './PaginatedMealPlanList';
 export * from './PaginatedMealTypeList';
+export * from './PaginatedOpenDataCategoryList';
+export * from './PaginatedOpenDataConversionList';
+export * from './PaginatedOpenDataFoodList';
+export * from './PaginatedOpenDataPropertyList';
+export * from './PaginatedOpenDataStoreList';
+export * from './PaginatedOpenDataUnitList';
+export * from './PaginatedOpenDataVersionList';
 export * from './PaginatedPropertyList';
 export * from './PaginatedPropertyTypeList';
 export * from './PaginatedRecipeBookEntryList';