recipes/vue3/apis/ApiApi.ts

/* tslint:disable */
/* eslint-disable */
/**
 * Django Recipes
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 
 * 
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */


import * as runtime from '../runtime';
import type {
  AccessToken,
  Automation,
  BookmarkletImport,
  BookmarkletImportList,
  CookLog,
  CustomFilter,
  ExportLog,
  Food,
  FoodInheritField,
  FoodShoppingUpdate,
  Group,
  ImportLog,
  Ingredient,
  InviteLink,
  Keyword,
  ListCookLogs200Response,
  ListExportLogs200Response,
  ListFoods200Response,
  ListImportLogs200Response,
  ListIngredients200Response,
  ListKeywords200Response,
  ListRecipes200Response,
  ListSteps200Response,
  ListSupermarketCategoryRelations200Response,
  ListSyncLogs200Response,
  ListUnits200Response,
  ListUserSpaces200Response,
  ListViewLogs200Response,
  MealPlan,
  MealType,
  OpenDataCategory,
  OpenDataConversion,
  OpenDataFood,
  OpenDataProperty,
  OpenDataStore,
  OpenDataUnit,
  OpenDataVersion,
  Property,
  PropertyType,
  Recipe,
  RecipeBook,
  RecipeBookEntry,
  RecipeImage,
  RecipeShoppingUpdate,
  RecipeSimple,
  ShoppingList,
  ShoppingListEntry,
  ShoppingListEntryBulk,
  ShoppingListRecipe,
  Space,
  Step,
  Storage,
  Supermarket,
  SupermarketCategory,
  SupermarketCategoryRelation,
  Sync,
  SyncLog,
  Unit,
  UnitConversion,
  User,
  UserFile,
  UserPreference,
  UserSpace,
  ViewLog,
} from '../models/index';
import {
    AccessTokenFromJSON,
    AccessTokenToJSON,
    AutomationFromJSON,
    AutomationToJSON,
    BookmarkletImportFromJSON,
    BookmarkletImportToJSON,
    BookmarkletImportListFromJSON,
    BookmarkletImportListToJSON,
    CookLogFromJSON,
    CookLogToJSON,
    CustomFilterFromJSON,
    CustomFilterToJSON,
    ExportLogFromJSON,
    ExportLogToJSON,
    FoodFromJSON,
    FoodToJSON,
    FoodInheritFieldFromJSON,
    FoodInheritFieldToJSON,
    FoodShoppingUpdateFromJSON,
    FoodShoppingUpdateToJSON,
    GroupFromJSON,
    GroupToJSON,
    ImportLogFromJSON,
    ImportLogToJSON,
    IngredientFromJSON,
    IngredientToJSON,
    InviteLinkFromJSON,
    InviteLinkToJSON,
    KeywordFromJSON,
    KeywordToJSON,
    ListCookLogs200ResponseFromJSON,
    ListCookLogs200ResponseToJSON,
    ListExportLogs200ResponseFromJSON,
    ListExportLogs200ResponseToJSON,
    ListFoods200ResponseFromJSON,
    ListFoods200ResponseToJSON,
    ListImportLogs200ResponseFromJSON,
    ListImportLogs200ResponseToJSON,
    ListIngredients200ResponseFromJSON,
    ListIngredients200ResponseToJSON,
    ListKeywords200ResponseFromJSON,
    ListKeywords200ResponseToJSON,
    ListRecipes200ResponseFromJSON,
    ListRecipes200ResponseToJSON,
    ListSteps200ResponseFromJSON,
    ListSteps200ResponseToJSON,
    ListSupermarketCategoryRelations200ResponseFromJSON,
    ListSupermarketCategoryRelations200ResponseToJSON,
    ListSyncLogs200ResponseFromJSON,
    ListSyncLogs200ResponseToJSON,
    ListUnits200ResponseFromJSON,
    ListUnits200ResponseToJSON,
    ListUserSpaces200ResponseFromJSON,
    ListUserSpaces200ResponseToJSON,
    ListViewLogs200ResponseFromJSON,
    ListViewLogs200ResponseToJSON,
    MealPlanFromJSON,
    MealPlanToJSON,
    MealTypeFromJSON,
    MealTypeToJSON,
    OpenDataCategoryFromJSON,
    OpenDataCategoryToJSON,
    OpenDataConversionFromJSON,
    OpenDataConversionToJSON,
    OpenDataFoodFromJSON,
    OpenDataFoodToJSON,
    OpenDataPropertyFromJSON,
    OpenDataPropertyToJSON,
    OpenDataStoreFromJSON,
    OpenDataStoreToJSON,
    OpenDataUnitFromJSON,
    OpenDataUnitToJSON,
    OpenDataVersionFromJSON,
    OpenDataVersionToJSON,
    PropertyFromJSON,
    PropertyToJSON,
    PropertyTypeFromJSON,
    PropertyTypeToJSON,
    RecipeFromJSON,
    RecipeToJSON,
    RecipeBookFromJSON,
    RecipeBookToJSON,
    RecipeBookEntryFromJSON,
    RecipeBookEntryToJSON,
    RecipeImageFromJSON,
    RecipeImageToJSON,
    RecipeShoppingUpdateFromJSON,
    RecipeShoppingUpdateToJSON,
    RecipeSimpleFromJSON,
    RecipeSimpleToJSON,
    ShoppingListFromJSON,
    ShoppingListToJSON,
    ShoppingListEntryFromJSON,
    ShoppingListEntryToJSON,
    ShoppingListEntryBulkFromJSON,
    ShoppingListEntryBulkToJSON,
    ShoppingListRecipeFromJSON,
    ShoppingListRecipeToJSON,
    SpaceFromJSON,
    SpaceToJSON,
    StepFromJSON,
    StepToJSON,
    StorageFromJSON,
    StorageToJSON,
    SupermarketFromJSON,
    SupermarketToJSON,
    SupermarketCategoryFromJSON,
    SupermarketCategoryToJSON,
    SupermarketCategoryRelationFromJSON,
    SupermarketCategoryRelationToJSON,
    SyncFromJSON,
    SyncToJSON,
    SyncLogFromJSON,
    SyncLogToJSON,
    UnitFromJSON,
    UnitToJSON,
    UnitConversionFromJSON,
    UnitConversionToJSON,
    UserFromJSON,
    UserToJSON,
    UserFileFromJSON,
    UserFileToJSON,
    UserPreferenceFromJSON,
    UserPreferenceToJSON,
    UserSpaceFromJSON,
    UserSpaceToJSON,
    ViewLogFromJSON,
    ViewLogToJSON,
} from '../models/index';

export interface BulkShoppingListEntryRequest {
    shoppingListEntryBulk?: ShoppingListEntryBulk;
}

export interface CreateAccessTokenRequest {
    accessToken?: AccessToken;
}

export interface CreateAutoPlanViewSetRequest {
    body?: any | null;
}

export interface CreateAutomationRequest {
    automation?: Automation;
}

export interface CreateBookmarkletImportRequest {
    bookmarkletImport?: BookmarkletImport;
}

export interface CreateCookLogRequest {
    cookLog?: CookLog;
}

export interface CreateCustomFilterRequest {
    customFilter?: CustomFilter;
}

export interface CreateExportLogRequest {
    exportLog?: ExportLog;
}

export interface CreateFoodRequest {
    food?: Food;
}

export interface CreateImportLogRequest {
    importLog?: ImportLog;
}

export interface CreateIngredientRequest {
    ingredient?: Ingredient;
}

export interface CreateInviteLinkRequest {
    inviteLink?: InviteLink;
}

export interface CreateKeywordRequest {
    keyword?: Keyword;
}

export interface CreateMealPlanRequest {
    mealPlan?: MealPlan;
}

export interface CreateMealTypeRequest {
    mealType?: MealType;
}

export interface CreateOpenDataCategoryRequest {
    openDataCategory?: OpenDataCategory;
}

export interface CreateOpenDataConversionRequest {
    openDataConversion?: OpenDataConversion;
}

export interface CreateOpenDataFoodRequest {
    openDataFood?: OpenDataFood;
}

export interface CreateOpenDataPropertyRequest {
    openDataProperty?: OpenDataProperty;
}

export interface CreateOpenDataStoreRequest {
    openDataStore?: OpenDataStore;
}

export interface CreateOpenDataUnitRequest {
    openDataUnit?: OpenDataUnit;
}

export interface CreateOpenDataVersionRequest {
    openDataVersion?: OpenDataVersion;
}

export interface CreatePropertyRequest {
    property?: Property;
}

export interface CreatePropertyTypeRequest {
    propertyType?: PropertyType;
}

export interface CreateRecipeRequest {
    recipe?: Recipe;
}

export interface CreateRecipeBookRequest {
    recipeBook?: RecipeBook;
}

export interface CreateRecipeBookEntryRequest {
    recipeBookEntry?: RecipeBookEntry;
}

export interface CreateRecipeUrlImportRequest {
    body?: any | null;
}

export interface CreateShoppingListRequest {
    shoppingList?: ShoppingList;
}

export interface CreateShoppingListEntryRequest {
    shoppingListEntry?: ShoppingListEntry;
}

export interface CreateShoppingListRecipeRequest {
    shoppingListRecipe?: ShoppingListRecipe;
}

export interface CreateStepRequest {
    step?: Step;
}

export interface CreateStorageRequest {
    storage?: Storage;
}

export interface CreateSupermarketRequest {
    supermarket?: Supermarket;
}

export interface CreateSupermarketCategoryRequest {
    supermarketCategory?: SupermarketCategory;
}

export interface CreateSupermarketCategoryRelationRequest {
    supermarketCategoryRelation?: SupermarketCategoryRelation;
}

export interface CreateSyncRequest {
    sync?: Sync;
}

export interface CreateUnitRequest {
    unit?: Unit;
}

export interface CreateUnitConversionRequest {
    unitConversion?: UnitConversion;
}

export interface CreateUserFileRequest {
    name: string;
    file: Blob;
    id?: number;
    fileDownload?: string;
    preview?: string;
    fileSizeKb?: number;
}

export interface CreateViewLogRequest {
    viewLog?: ViewLog;
}

export interface CreateimportFilesRequest {
    body?: any | null;
}

export interface DestroyAccessTokenRequest {
    id: string;
}

export interface DestroyAutomationRequest {
    id: string;
}

export interface DestroyBookmarkletImportRequest {
    id: string;
}

export interface DestroyCookLogRequest {
    id: string;
}

export interface DestroyCustomFilterRequest {
    id: string;
}

export interface DestroyExportLogRequest {
    id: string;
}

export interface DestroyFoodRequest {
    id: string;
}

export interface DestroyImportLogRequest {
    id: string;
}

export interface DestroyIngredientRequest {
    id: string;
}

export interface DestroyInviteLinkRequest {
    id: string;
}

export interface DestroyKeywordRequest {
    id: string;
}

export interface DestroyMealPlanRequest {
    id: string;
}

export interface DestroyMealTypeRequest {
    id: string;
}

export interface DestroyOpenDataCategoryRequest {
    id: string;
}

export interface DestroyOpenDataConversionRequest {
    id: string;
}

export interface DestroyOpenDataFoodRequest {
    id: string;
}

export interface DestroyOpenDataPropertyRequest {
    id: string;
}

export interface DestroyOpenDataStoreRequest {
    id: string;
}

export interface DestroyOpenDataUnitRequest {
    id: string;
}

export interface DestroyOpenDataVersionRequest {
    id: string;
}

export interface DestroyPropertyRequest {
    id: string;
}

export interface DestroyPropertyTypeRequest {
    id: string;
}

export interface DestroyRecipeRequest {
    id: string;
}

export interface DestroyRecipeBookRequest {
    id: string;
}

export interface DestroyRecipeBookEntryRequest {
    id: string;
}

export interface DestroyShoppingListRequest {
    id: string;
}

export interface DestroyShoppingListEntryRequest {
    id: string;
}

export interface DestroyShoppingListRecipeRequest {
    id: string;
}

export interface DestroyStepRequest {
    id: string;
}

export interface DestroyStorageRequest {
    id: string;
}

export interface DestroySupermarketRequest {
    id: string;
}

export interface DestroySupermarketCategoryRequest {
    id: string;
}

export interface DestroySupermarketCategoryRelationRequest {
    id: string;
}

export interface DestroySyncRequest {
    id: string;
}

export interface DestroyUnitRequest {
    id: string;
}

export interface DestroyUnitConversionRequest {
    id: string;
}

export interface DestroyUserFileRequest {
    id: string;
}

export interface DestroyUserSpaceRequest {
    id: string;
}

export interface DestroyViewLogRequest {
    id: string;
}

export interface FdcFoodRequest {
    id: string;
    food?: Food;
}

export interface ImageRecipeRequest {
    id: string;
    image?: Blob | null;
    imageUrl?: string | null;
}

export interface ListCookLogsRequest {
    page?: number;
    pageSize?: number;
}

export interface ListExportLogsRequest {
    page?: number;
    pageSize?: number;
}

export interface ListFoodsRequest {
    query?: string;
    root?: number;
    tree?: number;
    page?: number;
    pageSize?: number;
}

export interface ListImportLogsRequest {
    page?: number;
    pageSize?: number;
}

export interface ListIngredientsRequest {
    page?: number;
    pageSize?: number;
}

export interface ListKeywordsRequest {
    query?: string;
    root?: number;
    tree?: number;
    page?: number;
    pageSize?: number;
}

export interface ListMealPlansRequest {
    fromDate?: string;
    toDate?: string;
    mealType?: number;
}

export interface ListRecipesRequest {
    query?: string;
    keywords?: number;
    keywordsOr?: number;
    keywordsAnd?: number;
    keywordsOrNot?: number;
    keywordsAndNot?: number;
    foods?: number;
    foodsOr?: number;
    foodsAnd?: number;
    foodsOrNot?: number;
    foodsAndNot?: number;
    units?: number;
    rating?: number;
    books?: string;
    booksOr?: number;
    booksAnd?: number;
    booksOrNot?: number;
    booksAndNot?: number;
    internal?: string;
    random?: string;
    _new?: string;
    timescooked?: number;
    cookedon?: string;
    createdon?: string;
    updatedon?: string;
    viewedon?: string;
    makenow?: string;
    page?: number;
    pageSize?: number;
}

export interface ListShoppingListEntrysRequest {
    id?: number;
    checked?: string;
    supermarket?: number;
}

export interface ListStepsRequest {
    recipe?: number;
    query?: string;
    page?: number;
    pageSize?: number;
}

export interface ListSupermarketCategoryRelationsRequest {
    page?: number;
    pageSize?: number;
}

export interface ListSupermarketCategorysRequest {
    query?: string;
}

export interface ListSupermarketsRequest {
    query?: string;
}

export interface ListSyncLogsRequest {
    page?: number;
    pageSize?: number;
}

export interface ListUnitConversionsRequest {
    foodId?: number;
}

export interface ListUnitsRequest {
    query?: string;
    page?: number;
    pageSize?: number;
}

export interface ListUserFilesRequest {
    query?: string;
}

export interface ListUserSpacesRequest {
    page?: number;
    pageSize?: number;
}

export interface ListViewLogsRequest {
    page?: number;
    pageSize?: number;
}

export interface MergeFoodRequest {
    id: string;
    target: string;
    food?: Food;
}

export interface MergeKeywordRequest {
    id: string;
    target: string;
    keyword?: Keyword;
}

export interface MergeSupermarketCategoryRequest {
    id: string;
    target: string;
    supermarketCategory?: SupermarketCategory;
}

export interface MergeUnitRequest {
    id: string;
    target: string;
    unit?: Unit;
}

export interface MoveFoodRequest {
    id: string;
    parent: string;
    food?: Food;
}

export interface MoveKeywordRequest {
    id: string;
    parent: string;
    keyword?: Keyword;
}

export interface PartialUpdateAccessTokenRequest {
    id: string;
    accessToken?: AccessToken;
}

export interface PartialUpdateAutomationRequest {
    id: string;
    automation?: Automation;
}

export interface PartialUpdateBookmarkletImportRequest {
    id: string;
    bookmarkletImport?: BookmarkletImport;
}

export interface PartialUpdateCookLogRequest {
    id: string;
    cookLog?: CookLog;
}

export interface PartialUpdateCustomFilterRequest {
    id: string;
    customFilter?: CustomFilter;
}

export interface PartialUpdateExportLogRequest {
    id: string;
    exportLog?: ExportLog;
}

export interface PartialUpdateFoodRequest {
    id: string;
    food?: Food;
}

export interface PartialUpdateImportLogRequest {
    id: string;
    importLog?: ImportLog;
}

export interface PartialUpdateIngredientRequest {
    id: string;
    ingredient?: Ingredient;
}

export interface PartialUpdateInviteLinkRequest {
    id: string;
    inviteLink?: InviteLink;
}

export interface PartialUpdateKeywordRequest {
    id: string;
    keyword?: Keyword;
}

export interface PartialUpdateMealPlanRequest {
    id: string;
    mealPlan?: MealPlan;
}

export interface PartialUpdateMealTypeRequest {
    id: string;
    mealType?: MealType;
}

export interface PartialUpdateOpenDataCategoryRequest {
    id: string;
    openDataCategory?: OpenDataCategory;
}

export interface PartialUpdateOpenDataConversionRequest {
    id: string;
    openDataConversion?: OpenDataConversion;
}

export interface PartialUpdateOpenDataFoodRequest {
    id: string;
    openDataFood?: OpenDataFood;
}

export interface PartialUpdateOpenDataPropertyRequest {
    id: string;
    openDataProperty?: OpenDataProperty;
}

export interface PartialUpdateOpenDataStoreRequest {
    id: string;
    openDataStore?: OpenDataStore;
}

export interface PartialUpdateOpenDataUnitRequest {
    id: string;
    openDataUnit?: OpenDataUnit;
}

export interface PartialUpdateOpenDataVersionRequest {
    id: string;
    openDataVersion?: OpenDataVersion;
}

export interface PartialUpdatePropertyRequest {
    id: string;
    property?: Property;
}

export interface PartialUpdatePropertyTypeRequest {
    id: string;
    propertyType?: PropertyType;
}

export interface PartialUpdateRecipeRequest {
    id: string;
    recipe?: Recipe;
}

export interface PartialUpdateRecipeBookRequest {
    id: string;
    recipeBook?: RecipeBook;
}

export interface PartialUpdateRecipeBookEntryRequest {
    id: string;
    recipeBookEntry?: RecipeBookEntry;
}

export interface PartialUpdateShoppingListRequest {
    id: string;
    shoppingList?: ShoppingList;
}

export interface PartialUpdateShoppingListEntryRequest {
    id: string;
    shoppingListEntry?: ShoppingListEntry;
}

export interface PartialUpdateShoppingListRecipeRequest {
    id: string;
    shoppingListRecipe?: ShoppingListRecipe;
}

export interface PartialUpdateSpaceRequest {
    id: string;
    space?: Space;
}

export interface PartialUpdateStepRequest {
    id: string;
    step?: Step;
}

export interface PartialUpdateStorageRequest {
    id: string;
    storage?: Storage;
}

export interface PartialUpdateSupermarketRequest {
    id: string;
    supermarket?: Supermarket;
}

export interface PartialUpdateSupermarketCategoryRequest {
    id: string;
    supermarketCategory?: SupermarketCategory;
}

export interface PartialUpdateSupermarketCategoryRelationRequest {
    id: string;
    supermarketCategoryRelation?: SupermarketCategoryRelation;
}

export interface PartialUpdateSyncRequest {
    id: string;
    sync?: Sync;
}

export interface PartialUpdateUnitRequest {
    id: string;
    unit?: Unit;
}

export interface PartialUpdateUnitConversionRequest {
    id: string;
    unitConversion?: UnitConversion;
}

export interface PartialUpdateUserRequest {
    id: string;
    user?: User;
}

export interface PartialUpdateUserFileRequest {
    id: string;
    name: string;
    file: Blob;
    id2?: number;
    fileDownload?: string;
    preview?: string;
    fileSizeKb?: number;
}

export interface PartialUpdateUserPreferenceRequest {
    user: string;
    userPreference?: UserPreference;
}

export interface PartialUpdateUserSpaceRequest {
    id: string;
    userSpace?: UserSpace;
}

export interface PartialUpdateViewLogRequest {
    id: string;
    viewLog?: ViewLog;
}

export interface RelatedRecipeRequest {
    id: string;
}

export interface RetrieveAccessTokenRequest {
    id: string;
}

export interface RetrieveAutomationRequest {
    id: string;
}

export interface RetrieveBookmarkletImportRequest {
    id: string;
}

export interface RetrieveCookLogRequest {
    id: string;
}

export interface RetrieveCustomFilterRequest {
    id: string;
}

export interface RetrieveExportLogRequest {
    id: string;
}

export interface RetrieveFDCViewSetRequest {
    id: string;
}

export interface RetrieveFoodRequest {
    id: string;
}

export interface RetrieveFoodInheritFieldRequest {
    id: string;
}

export interface RetrieveGroupRequest {
    id: string;
}

export interface RetrieveImportLogRequest {
    id: string;
}

export interface RetrieveIngredientRequest {
    id: string;
}

export interface RetrieveInviteLinkRequest {
    id: string;
}

export interface RetrieveKeywordRequest {
    id: string;
}

export interface RetrieveMealPlanRequest {
    id: string;
}

export interface RetrieveMealTypeRequest {
    id: string;
}

export interface RetrieveOpenDataCategoryRequest {
    id: string;
}

export interface RetrieveOpenDataConversionRequest {
    id: string;
}

export interface RetrieveOpenDataFoodRequest {
    id: string;
}

export interface RetrieveOpenDataPropertyRequest {
    id: string;
}

export interface RetrieveOpenDataStoreRequest {
    id: string;
}

export interface RetrieveOpenDataUnitRequest {
    id: string;
}

export interface RetrieveOpenDataVersionRequest {
    id: string;
}

export interface RetrievePropertyRequest {
    id: string;
}

export interface RetrievePropertyTypeRequest {
    id: string;
}

export interface RetrieveRecipeRequest {
    id: string;
}

export interface RetrieveRecipeBookRequest {
    id: string;
}

export interface RetrieveRecipeBookEntryRequest {
    id: string;
}

export interface RetrieveShoppingListRequest {
    id: string;
}

export interface RetrieveShoppingListEntryRequest {
    id: string;
}

export interface RetrieveShoppingListRecipeRequest {
    id: string;
}

export interface RetrieveSpaceRequest {
    id: string;
}

export interface RetrieveStepRequest {
    id: string;
}

export interface RetrieveStorageRequest {
    id: string;
}

export interface RetrieveSupermarketRequest {
    id: string;
}

export interface RetrieveSupermarketCategoryRequest {
    id: string;
}

export interface RetrieveSupermarketCategoryRelationRequest {
    id: string;
}

export interface RetrieveSyncRequest {
    id: string;
}

export interface RetrieveSyncLogRequest {
    id: string;
}

export interface RetrieveUnitRequest {
    id: string;
}

export interface RetrieveUnitConversionRequest {
    id: string;
}

export interface RetrieveUserRequest {
    id: string;
}

export interface RetrieveUserFileRequest {
    id: string;
}

export interface RetrieveUserPreferenceRequest {
    user: string;
}

export interface RetrieveUserSpaceRequest {
    id: string;
}

export interface RetrieveViewLogRequest {
    id: string;
}

export interface RetrievedownloadFileRequest {
    fileId: string;
}

export interface RetrieveshareLinkRequest {
    id: string;
}

export interface RetrieveswitchActiveSpaceRequest {
    spaceId: string;
}

export interface ShoppingFoodRequest {
    id: string;
    foodShoppingUpdate?: FoodShoppingUpdate;
}

export interface ShoppingRecipeRequest {
    id: string;
    recipeShoppingUpdate?: RecipeShoppingUpdate;
}

export interface UpdateAccessTokenRequest {
    id: string;
    accessToken?: AccessToken;
}

export interface UpdateAutomationRequest {
    id: string;
    automation?: Automation;
}

export interface UpdateBookmarkletImportRequest {
    id: string;
    bookmarkletImport?: BookmarkletImport;
}

export interface UpdateCookLogRequest {
    id: string;
    cookLog?: CookLog;
}

export interface UpdateCustomFilterRequest {
    id: string;
    customFilter?: CustomFilter;
}

export interface UpdateExportLogRequest {
    id: string;
    exportLog?: ExportLog;
}

export interface UpdateFoodRequest {
    id: string;
    food?: Food;
}

export interface UpdateImportLogRequest {
    id: string;
    importLog?: ImportLog;
}

export interface UpdateIngredientRequest {
    id: string;
    ingredient?: Ingredient;
}

export interface UpdateInviteLinkRequest {
    id: string;
    inviteLink?: InviteLink;
}

export interface UpdateKeywordRequest {
    id: string;
    keyword?: Keyword;
}

export interface UpdateMealPlanRequest {
    id: string;
    mealPlan?: MealPlan;
}

export interface UpdateMealTypeRequest {
    id: string;
    mealType?: MealType;
}

export interface UpdateOpenDataCategoryRequest {
    id: string;
    openDataCategory?: OpenDataCategory;
}

export interface UpdateOpenDataConversionRequest {
    id: string;
    openDataConversion?: OpenDataConversion;
}

export interface UpdateOpenDataFoodRequest {
    id: string;
    openDataFood?: OpenDataFood;
}

export interface UpdateOpenDataPropertyRequest {
    id: string;
    openDataProperty?: OpenDataProperty;
}

export interface UpdateOpenDataStoreRequest {
    id: string;
    openDataStore?: OpenDataStore;
}

export interface UpdateOpenDataUnitRequest {
    id: string;
    openDataUnit?: OpenDataUnit;
}

export interface UpdateOpenDataVersionRequest {
    id: string;
    openDataVersion?: OpenDataVersion;
}

export interface UpdatePropertyRequest {
    id: string;
    property?: Property;
}

export interface UpdatePropertyTypeRequest {
    id: string;
    propertyType?: PropertyType;
}

export interface UpdateRecipeRequest {
    id: string;
    recipe?: Recipe;
}

export interface UpdateRecipeBookRequest {
    id: string;
    recipeBook?: RecipeBook;
}

export interface UpdateRecipeBookEntryRequest {
    id: string;
    recipeBookEntry?: RecipeBookEntry;
}

export interface UpdateShoppingListRequest {
    id: string;
    shoppingList?: ShoppingList;
}

export interface UpdateShoppingListEntryRequest {
    id: string;
    shoppingListEntry?: ShoppingListEntry;
}

export interface UpdateShoppingListRecipeRequest {
    id: string;
    shoppingListRecipe?: ShoppingListRecipe;
}

export interface UpdateStepRequest {
    id: string;
    step?: Step;
}

export interface UpdateStorageRequest {
    id: string;
    storage?: Storage;
}

export interface UpdateSupermarketRequest {
    id: string;
    supermarket?: Supermarket;
}

export interface UpdateSupermarketCategoryRequest {
    id: string;
    supermarketCategory?: SupermarketCategory;
}

export interface UpdateSupermarketCategoryRelationRequest {
    id: string;
    supermarketCategoryRelation?: SupermarketCategoryRelation;
}

export interface UpdateSyncRequest {
    id: string;
    sync?: Sync;
}

export interface UpdateUnitRequest {
    id: string;
    unit?: Unit;
}

export interface UpdateUnitConversionRequest {
    id: string;
    unitConversion?: UnitConversion;
}

export interface UpdateUserFileRequest {
    id: string;
    name: string;
    file: Blob;
    id2?: number;
    fileDownload?: string;
    preview?: string;
    fileSizeKb?: number;
}

export interface UpdateViewLogRequest {
    id: string;
    viewLog?: ViewLog;
}

/**
 * 
 */
export class ApiApi extends runtime.BaseAPI {

    /**
     * 
     */
    async bulkShoppingListEntryRaw(requestParameters: BulkShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListEntryBulk>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-entry/bulk/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListEntryBulkToJSON(requestParameters.shoppingListEntryBulk),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListEntryBulkFromJSON(jsonValue));
    }

    /**
     * 
     */
    async bulkShoppingListEntry(requestParameters: BulkShoppingListEntryRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListEntryBulk> {
        const response = await this.bulkShoppingListEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createAccessTokenRaw(requestParameters: CreateAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccessToken>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/access-token/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AccessTokenToJSON(requestParameters.accessToken),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AccessTokenFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createAccessToken(requestParameters: CreateAccessTokenRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccessToken> {
        const response = await this.createAccessTokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createAutoPlanViewSetRaw(requestParameters: CreateAutoPlanViewSetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/auto-plan/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.body as any,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * 
     */
    async createAutoPlanViewSet(requestParameters: CreateAutoPlanViewSetRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.createAutoPlanViewSetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createAutomationRaw(requestParameters: CreateAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Automation>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/automation/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: AutomationToJSON(requestParameters.automation),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AutomationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createAutomation(requestParameters: CreateAutomationRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Automation> {
        const response = await this.createAutomationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createBookmarkletImportRaw(requestParameters: CreateBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BookmarkletImport>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/bookmarklet-import/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: BookmarkletImportToJSON(requestParameters.bookmarkletImport),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => BookmarkletImportFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createBookmarkletImport(requestParameters: CreateBookmarkletImportRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BookmarkletImport> {
        const response = await this.createBookmarkletImportRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createCookLogRaw(requestParameters: CreateCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CookLog>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/cook-log/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CookLogToJSON(requestParameters.cookLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CookLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createCookLog(requestParameters: CreateCookLogRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CookLog> {
        const response = await this.createCookLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createCustomFilterRaw(requestParameters: CreateCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CustomFilter>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/custom-filter/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: CustomFilterToJSON(requestParameters.customFilter),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFilterFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createCustomFilter(requestParameters: CreateCustomFilterRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CustomFilter> {
        const response = await this.createCustomFilterRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createExportLogRaw(requestParameters: CreateExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ExportLog>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/export-log/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ExportLogToJSON(requestParameters.exportLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createExportLog(requestParameters: CreateExportLogRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ExportLog> {
        const response = await this.createExportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createFoodRaw(requestParameters: CreateFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FoodToJSON(requestParameters.food),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createFood(requestParameters: CreateFoodRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.createFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createImportLogRaw(requestParameters: CreateImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ImportLog>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/import-log/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ImportLogToJSON(requestParameters.importLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ImportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createImportLog(requestParameters: CreateImportLogRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ImportLog> {
        const response = await this.createImportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createIngredientRaw(requestParameters: CreateIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Ingredient>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/ingredient/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: IngredientToJSON(requestParameters.ingredient),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => IngredientFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createIngredient(requestParameters: CreateIngredientRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Ingredient> {
        const response = await this.createIngredientRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createInviteLinkRaw(requestParameters: CreateInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteLink>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/invite-link/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: InviteLinkToJSON(requestParameters.inviteLink),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => InviteLinkFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createInviteLink(requestParameters: CreateInviteLinkRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteLink> {
        const response = await this.createInviteLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createKeywordRaw(requestParameters: CreateKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Keyword>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/keyword/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: KeywordToJSON(requestParameters.keyword),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => KeywordFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createKeyword(requestParameters: CreateKeywordRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Keyword> {
        const response = await this.createKeywordRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createMealPlanRaw(requestParameters: CreateMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealPlan>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/meal-plan/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MealPlanToJSON(requestParameters.mealPlan),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealPlanFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createMealPlan(requestParameters: CreateMealPlanRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealPlan> {
        const response = await this.createMealPlanRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async createMealTypeRaw(requestParameters: CreateMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealType>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/meal-type/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: MealTypeToJSON(requestParameters.mealType),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealTypeFromJSON(jsonValue));
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async createMealType(requestParameters: CreateMealTypeRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealType> {
        const response = await this.createMealTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataCategoryRaw(requestParameters: CreateOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataCategory(requestParameters: CreateOpenDataCategoryRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
        const response = await this.createOpenDataCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataConversionRaw(requestParameters: CreateOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataConversion(requestParameters: CreateOpenDataConversionRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
        const response = await this.createOpenDataConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataFoodRaw(requestParameters: CreateOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataFood(requestParameters: CreateOpenDataFoodRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
        const response = await this.createOpenDataFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataPropertyRaw(requestParameters: CreateOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataProperty(requestParameters: CreateOpenDataPropertyRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
        const response = await this.createOpenDataPropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataStoreRaw(requestParameters: CreateOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataStore(requestParameters: CreateOpenDataStoreRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
        const response = await this.createOpenDataStoreRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataUnitRaw(requestParameters: CreateOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataUnit(requestParameters: CreateOpenDataUnitRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
        const response = await this.createOpenDataUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createOpenDataVersionRaw(requestParameters: CreateOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 createOpenDataVersion(requestParameters: CreateOpenDataVersionRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
        const response = await this.createOpenDataVersionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createPropertyRaw(requestParameters: CreatePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Property>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food-property/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PropertyToJSON(requestParameters.property),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createProperty(requestParameters: CreatePropertyRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Property> {
        const response = await this.createPropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createPropertyTypeRaw(requestParameters: CreatePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PropertyType>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food-property-type/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: PropertyTypeToJSON(requestParameters.propertyType),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyTypeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createPropertyType(requestParameters: CreatePropertyTypeRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PropertyType> {
        const response = await this.createPropertyTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createRecipeRaw(requestParameters: CreateRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recipe>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeToJSON(requestParameters.recipe),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createRecipe(requestParameters: CreateRecipeRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recipe> {
        const response = await this.createRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createRecipeBookRaw(requestParameters: CreateRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBook>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-book/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeBookToJSON(requestParameters.recipeBook),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createRecipeBook(requestParameters: CreateRecipeBookRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBook> {
        const response = await this.createRecipeBookRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createRecipeBookEntryRaw(requestParameters: CreateRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBookEntry>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-book-entry/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeBookEntryToJSON(requestParameters.recipeBookEntry),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createRecipeBookEntry(requestParameters: CreateRecipeBookEntryRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBookEntry> {
        const response = await this.createRecipeBookEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * function to retrieve a recipe from a given url or source string :param request: standard request with additional post parameters         - url: url to use for importing recipe         - data: if no url is given recipe is imported from provided source data         - (optional) bookmarklet: id of bookmarklet import to use, overrides URL and data attributes :return: JsonResponse containing the parsed json and images
     */
    async createRecipeUrlImportRaw(requestParameters: CreateRecipeUrlImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-from-source/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.body as any,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * function to retrieve a recipe from a given url or source string :param request: standard request with additional post parameters         - url: url to use for importing recipe         - data: if no url is given recipe is imported from provided source data         - (optional) bookmarklet: id of bookmarklet import to use, overrides URL and data attributes :return: JsonResponse containing the parsed json and images
     */
    async createRecipeUrlImport(requestParameters: CreateRecipeUrlImportRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.createRecipeUrlImportRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createShoppingListRaw(requestParameters: CreateShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingList>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListToJSON(requestParameters.shoppingList),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createShoppingList(requestParameters: CreateShoppingListRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingList> {
        const response = await this.createShoppingListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createShoppingListEntryRaw(requestParameters: CreateShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListEntry>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-entry/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListEntryToJSON(requestParameters.shoppingListEntry),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createShoppingListEntry(requestParameters: CreateShoppingListEntryRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListEntry> {
        const response = await this.createShoppingListEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createShoppingListRecipeRaw(requestParameters: CreateShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListRecipe>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-recipe/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListRecipeToJSON(requestParameters.shoppingListRecipe),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListRecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createShoppingListRecipe(requestParameters: CreateShoppingListRecipeRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListRecipe> {
        const response = await this.createShoppingListRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createStepRaw(requestParameters: CreateStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Step>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/step/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: StepToJSON(requestParameters.step),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StepFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createStep(requestParameters: CreateStepRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Step> {
        const response = await this.createStepRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createStorageRaw(requestParameters: CreateStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Storage>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/storage/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: StorageToJSON(requestParameters.storage),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StorageFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createStorage(requestParameters: CreateStorageRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Storage> {
        const response = await this.createStorageRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createSupermarketRaw(requestParameters: CreateSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Supermarket>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketToJSON(requestParameters.supermarket),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createSupermarket(requestParameters: CreateSupermarketRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Supermarket> {
        const response = await this.createSupermarketRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createSupermarketCategoryRaw(requestParameters: CreateSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategory>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryToJSON(requestParameters.supermarketCategory),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createSupermarketCategory(requestParameters: CreateSupermarketCategoryRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategory> {
        const response = await this.createSupermarketCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createSupermarketCategoryRelationRaw(requestParameters: CreateSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategoryRelation>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category-relation/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryRelationToJSON(requestParameters.supermarketCategoryRelation),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryRelationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createSupermarketCategoryRelation(requestParameters: CreateSupermarketCategoryRelationRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategoryRelation> {
        const response = await this.createSupermarketCategoryRelationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createSyncRaw(requestParameters: CreateSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Sync>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/sync/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: SyncToJSON(requestParameters.sync),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SyncFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createSync(requestParameters: CreateSyncRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Sync> {
        const response = await this.createSyncRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createUnitRaw(requestParameters: CreateUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unit>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UnitToJSON(requestParameters.unit),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createUnit(requestParameters: CreateUnitRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unit> {
        const response = await this.createUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createUnitConversionRaw(requestParameters: CreateUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UnitConversion>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit-conversion/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: UnitConversionToJSON(requestParameters.unitConversion),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitConversionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createUnitConversion(requestParameters: CreateUnitConversionRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UnitConversion> {
        const response = await this.createUnitConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createUserFileRaw(requestParameters: CreateUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserFile>> {
        if (requestParameters.name === null || requestParameters.name === undefined) {
            throw new runtime.RequiredError('name','Required parameter requestParameters.name was null or undefined when calling createUserFile.');
        }

        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling createUserFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.id !== undefined) {
            formParams.append('id', requestParameters.id as any);
        }

        if (requestParameters.name !== undefined) {
            formParams.append('name', requestParameters.name as any);
        }

        if (requestParameters.file !== undefined) {
            formParams.append('file', requestParameters.file as any);
        }

        if (requestParameters.fileDownload !== undefined) {
            formParams.append('file_download', requestParameters.fileDownload as any);
        }

        if (requestParameters.preview !== undefined) {
            formParams.append('preview', requestParameters.preview as any);
        }

        if (requestParameters.fileSizeKb !== undefined) {
            formParams.append('file_size_kb', requestParameters.fileSizeKb as any);
        }

        const response = await this.request({
            path: `/api/user-file/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserFileFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createUserFile(requestParameters: CreateUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserFile> {
        const response = await this.createUserFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async createViewLogRaw(requestParameters: CreateViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ViewLog>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/view-log/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: ViewLogToJSON(requestParameters.viewLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ViewLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async createViewLog(requestParameters: CreateViewLogRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ViewLog> {
        const response = await this.createViewLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * function to handle files passed by application importer
     */
    async createimportFilesRaw(requestParameters: CreateimportFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/import/`,
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: requestParameters.body as any,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * function to handle files passed by application importer
     */
    async createimportFiles(requestParameters: CreateimportFilesRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.createimportFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async destroyAccessTokenRaw(requestParameters: DestroyAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyAccessToken.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/access-token/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyAccessToken(requestParameters: DestroyAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyAccessTokenRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyAutomationRaw(requestParameters: DestroyAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyAutomation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/automation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyAutomation(requestParameters: DestroyAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyAutomationRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyBookmarkletImportRaw(requestParameters: DestroyBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyBookmarkletImport.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/bookmarklet-import/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyBookmarkletImport(requestParameters: DestroyBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyBookmarkletImportRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyCookLogRaw(requestParameters: DestroyCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyCookLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/cook-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyCookLog(requestParameters: DestroyCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyCookLogRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyCustomFilterRaw(requestParameters: DestroyCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyCustomFilter.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/custom-filter/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyCustomFilter(requestParameters: DestroyCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyCustomFilterRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyExportLogRaw(requestParameters: DestroyExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyExportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/export-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyExportLog(requestParameters: DestroyExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyExportLogRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyFoodRaw(requestParameters: DestroyFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyFood(requestParameters: DestroyFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyFoodRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyImportLogRaw(requestParameters: DestroyImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyImportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/import-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyImportLog(requestParameters: DestroyImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyImportLogRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyIngredientRaw(requestParameters: DestroyIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyIngredient.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/ingredient/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyIngredient(requestParameters: DestroyIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyIngredientRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyInviteLinkRaw(requestParameters: DestroyInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyInviteLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/invite-link/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyInviteLink(requestParameters: DestroyInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyInviteLinkRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyKeywordRaw(requestParameters: DestroyKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyKeyword.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/keyword/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyKeyword(requestParameters: DestroyKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyKeywordRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyMealPlanRaw(requestParameters: DestroyMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyMealPlan.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/meal-plan/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyMealPlan(requestParameters: DestroyMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyMealPlanRaw(requestParameters, initOverrides);
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async destroyMealTypeRaw(requestParameters: DestroyMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyMealType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/meal-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async destroyMealType(requestParameters: DestroyMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyMealTypeRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataCategoryRaw(requestParameters: DestroyOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataCategory(requestParameters: DestroyOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataCategoryRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataConversionRaw(requestParameters: DestroyOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataConversion(requestParameters: DestroyOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataConversionRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataFoodRaw(requestParameters: DestroyOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataFood(requestParameters: DestroyOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataFoodRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataPropertyRaw(requestParameters: DestroyOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataProperty(requestParameters: DestroyOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataPropertyRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataStoreRaw(requestParameters: DestroyOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataStore.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataStore(requestParameters: DestroyOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataStoreRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataUnitRaw(requestParameters: DestroyOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataUnit(requestParameters: DestroyOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataUnitRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyOpenDataVersionRaw(requestParameters: DestroyOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyOpenDataVersion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 destroyOpenDataVersion(requestParameters: DestroyOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyOpenDataVersionRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyPropertyRaw(requestParameters: DestroyPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyProperty(requestParameters: DestroyPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyPropertyRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyPropertyTypeRaw(requestParameters: DestroyPropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyPropertyType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-property-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyPropertyType(requestParameters: DestroyPropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyPropertyTypeRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyRecipeRaw(requestParameters: DestroyRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyRecipe(requestParameters: DestroyRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyRecipeRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyRecipeBookRaw(requestParameters: DestroyRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyRecipeBook.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe-book/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyRecipeBook(requestParameters: DestroyRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyRecipeBookRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyRecipeBookEntryRaw(requestParameters: DestroyRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyRecipeBookEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe-book-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyRecipeBookEntry(requestParameters: DestroyRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyRecipeBookEntryRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyShoppingListRaw(requestParameters: DestroyShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyShoppingList.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyShoppingList(requestParameters: DestroyShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyShoppingListRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyShoppingListEntryRaw(requestParameters: DestroyShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyShoppingListEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyShoppingListEntry(requestParameters: DestroyShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyShoppingListEntryRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyShoppingListRecipeRaw(requestParameters: DestroyShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyShoppingListRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list-recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyShoppingListRecipe(requestParameters: DestroyShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyShoppingListRecipeRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyStepRaw(requestParameters: DestroyStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyStep.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/step/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyStep(requestParameters: DestroyStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyStepRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyStorageRaw(requestParameters: DestroyStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyStorage.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/storage/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyStorage(requestParameters: DestroyStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyStorageRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroySupermarketRaw(requestParameters: DestroySupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroySupermarket.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroySupermarket(requestParameters: DestroySupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroySupermarketRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroySupermarketCategoryRaw(requestParameters: DestroySupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroySupermarketCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroySupermarketCategory(requestParameters: DestroySupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroySupermarketCategoryRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroySupermarketCategoryRelationRaw(requestParameters: DestroySupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroySupermarketCategoryRelation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket-category-relation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroySupermarketCategoryRelation(requestParameters: DestroySupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroySupermarketCategoryRelationRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroySyncRaw(requestParameters: DestroySyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroySync.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/sync/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroySync(requestParameters: DestroySyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroySyncRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyUnitRaw(requestParameters: DestroyUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyUnit(requestParameters: DestroyUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyUnitRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyUnitConversionRaw(requestParameters: DestroyUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyUnitConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/unit-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyUnitConversion(requestParameters: DestroyUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyUnitConversionRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyUserFileRaw(requestParameters: DestroyUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyUserFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-file/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyUserFile(requestParameters: DestroyUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyUserFileRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyUserSpaceRaw(requestParameters: DestroyUserSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyUserSpace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-space/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyUserSpace(requestParameters: DestroyUserSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyUserSpaceRaw(requestParameters, initOverrides);
    }

    /**
     * 
     */
    async destroyViewLogRaw(requestParameters: DestroyViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling destroyViewLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/view-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'DELETE',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.VoidApiResponse(response);
    }

    /**
     * 
     */
    async destroyViewLog(requestParameters: DestroyViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
        await this.destroyViewLogRaw(requestParameters, initOverrides);
    }

    /**
     * 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 fdcFoodRaw(requestParameters: FdcFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling fdcFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/{id}/fdc/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'POST',
            headers: headerParameters,
            query: queryParameters,
            body: FoodToJSON(requestParameters.food),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(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 fdcFood(requestParameters: FdcFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.fdcFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async imageRecipeRaw(requestParameters: ImageRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeImage>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling imageRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.image !== undefined) {
            formParams.append('image', requestParameters.image as any);
        }

        if (requestParameters.imageUrl !== undefined) {
            formParams.append('image_url', requestParameters.imageUrl as any);
        }

        const response = await this.request({
            path: `/api/recipe/{id}/image/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeImageFromJSON(jsonValue));
    }

    /**
     * 
     */
    async imageRecipe(requestParameters: ImageRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeImage> {
        const response = await this.imageRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listAccessTokensRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<AccessToken>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/access-token/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AccessTokenFromJSON));
    }

    /**
     * 
     */
    async listAccessTokens(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<AccessToken>> {
        const response = await this.listAccessTokensRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listAutomationsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Automation>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/automation/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(AutomationFromJSON));
    }

    /**
     * 
     */
    async listAutomations(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Automation>> {
        const response = await this.listAutomationsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listBookmarkletImportsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<BookmarkletImportList>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/bookmarklet-import/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(BookmarkletImportListFromJSON));
    }

    /**
     * 
     */
    async listBookmarkletImports(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<BookmarkletImportList>> {
        const response = await this.listBookmarkletImportsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listCookLogsRaw(requestParameters: ListCookLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListCookLogs200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/cook-log/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListCookLogs200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listCookLogs(requestParameters: ListCookLogsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListCookLogs200Response> {
        const response = await this.listCookLogsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listCustomFiltersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<CustomFilter>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/custom-filter/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CustomFilterFromJSON));
    }

    /**
     * 
     */
    async listCustomFilters(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<CustomFilter>> {
        const response = await this.listCustomFiltersRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listExportLogsRaw(requestParameters: ListExportLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListExportLogs200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/export-log/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListExportLogs200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listExportLogs(requestParameters: ListExportLogsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListExportLogs200Response> {
        const response = await this.listExportLogsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listFoodInheritFieldsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<FoodInheritField>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-inherit-field/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(FoodInheritFieldFromJSON));
    }

    /**
     * 
     */
    async listFoodInheritFields(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<FoodInheritField>> {
        const response = await this.listFoodInheritFieldsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listFoodsRaw(requestParameters: ListFoodsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListFoods200Response>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.tree !== undefined) {
            queryParameters['tree'] = requestParameters.tree;
        }

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListFoods200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listFoods(requestParameters: ListFoodsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListFoods200Response> {
        const response = await this.listFoodsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listGroupsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Group>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/group/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(GroupFromJSON));
    }

    /**
     * 
     */
    async listGroups(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Group>> {
        const response = await this.listGroupsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listImportLogsRaw(requestParameters: ListImportLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListImportLogs200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/import-log/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListImportLogs200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listImportLogs(requestParameters: ListImportLogsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListImportLogs200Response> {
        const response = await this.listImportLogsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listIngredientsRaw(requestParameters: ListIngredientsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListIngredients200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/ingredient/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListIngredients200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listIngredients(requestParameters: ListIngredientsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListIngredients200Response> {
        const response = await this.listIngredientsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listInviteLinksRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<InviteLink>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/invite-link/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(InviteLinkFromJSON));
    }

    /**
     * 
     */
    async listInviteLinks(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<InviteLink>> {
        const response = await this.listInviteLinksRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listKeywordsRaw(requestParameters: ListKeywordsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListKeywords200Response>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        if (requestParameters.root !== undefined) {
            queryParameters['root'] = requestParameters.root;
        }

        if (requestParameters.tree !== undefined) {
            queryParameters['tree'] = requestParameters.tree;
        }

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/keyword/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListKeywords200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listKeywords(requestParameters: ListKeywordsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListKeywords200Response> {
        const response = await this.listKeywordsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * optional parameters  - **from_date**: filter from (inclusive) a certain date onward - **to_date**: filter upward to (inclusive) certain date - **meal_type**: filter meal plans based on meal_type ID
     */
    async listMealPlansRaw(requestParameters: ListMealPlansRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<MealPlan>>> {
        const queryParameters: any = {};

        if (requestParameters.fromDate !== undefined) {
            queryParameters['from_date'] = requestParameters.fromDate;
        }

        if (requestParameters.toDate !== undefined) {
            queryParameters['to_date'] = requestParameters.toDate;
        }

        if (requestParameters.mealType !== undefined) {
            queryParameters['meal_type'] = requestParameters.mealType;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/meal-plan/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MealPlanFromJSON));
    }

    /**
     * optional parameters  - **from_date**: filter from (inclusive) a certain date onward - **to_date**: filter upward to (inclusive) certain date - **meal_type**: filter meal plans based on meal_type ID
     */
    async listMealPlans(requestParameters: ListMealPlansRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<MealPlan>> {
        const response = await this.listMealPlansRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async listMealTypesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<MealType>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/meal-type/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(MealTypeFromJSON));
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async listMealTypes(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<MealType>> {
        const response = await this.listMealTypesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataCategorysRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataCategory>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataCategorys(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataCategory>> {
        const response = await this.listOpenDataCategorysRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataConversionsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataConversion>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataConversions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataConversion>> {
        const response = await this.listOpenDataConversionsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataFoodsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataFood>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataFoods(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataFood>> {
        const response = await this.listOpenDataFoodsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataPropertysRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataProperty>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataPropertys(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataProperty>> {
        const response = await this.listOpenDataPropertysRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataStatisticsViewSetsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<any>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/open-data-stats/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * 
     */
    async listOpenDataStatisticsViewSets(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<any>> {
        const response = await this.listOpenDataStatisticsViewSetsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataStoresRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataStore>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataStores(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataStore>> {
        const response = await this.listOpenDataStoresRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataUnitsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataUnit>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataUnits(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataUnit>> {
        const response = await this.listOpenDataUnitsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listOpenDataVersionsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<OpenDataVersion>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 listOpenDataVersions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<OpenDataVersion>> {
        const response = await this.listOpenDataVersionsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listPropertyTypesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<PropertyType>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-property-type/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PropertyTypeFromJSON));
    }

    /**
     * 
     */
    async listPropertyTypes(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<PropertyType>> {
        const response = await this.listPropertyTypesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listPropertysRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Property>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-property/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(PropertyFromJSON));
    }

    /**
     * 
     */
    async listPropertys(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Property>> {
        const response = await this.listPropertysRaw(initOverrides);
        return await response.value();
    }

    /**
     * optional parameters  - **recipe**: id of recipe - only return books for that recipe - **book**: id of book - only return recipes in that book
     */
    async listRecipeBookEntrysRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<RecipeBookEntry>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe-book-entry/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(RecipeBookEntryFromJSON));
    }

    /**
     * optional parameters  - **recipe**: id of recipe - only return books for that recipe - **book**: id of book - only return recipes in that book
     */
    async listRecipeBookEntrys(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<RecipeBookEntry>> {
        const response = await this.listRecipeBookEntrysRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listRecipeBooksRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<RecipeBook>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe-book/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(RecipeBookFromJSON));
    }

    /**
     * 
     */
    async listRecipeBooks(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<RecipeBook>> {
        const response = await this.listRecipeBooksRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listRecipesRaw(requestParameters: ListRecipesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListRecipes200Response>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        if (requestParameters.keywords !== undefined) {
            queryParameters['keywords'] = requestParameters.keywords;
        }

        if (requestParameters.keywordsOr !== undefined) {
            queryParameters['keywords_or'] = requestParameters.keywordsOr;
        }

        if (requestParameters.keywordsAnd !== undefined) {
            queryParameters['keywords_and'] = requestParameters.keywordsAnd;
        }

        if (requestParameters.keywordsOrNot !== undefined) {
            queryParameters['keywords_or_not'] = requestParameters.keywordsOrNot;
        }

        if (requestParameters.keywordsAndNot !== undefined) {
            queryParameters['keywords_and_not'] = requestParameters.keywordsAndNot;
        }

        if (requestParameters.foods !== undefined) {
            queryParameters['foods'] = requestParameters.foods;
        }

        if (requestParameters.foodsOr !== undefined) {
            queryParameters['foods_or'] = requestParameters.foodsOr;
        }

        if (requestParameters.foodsAnd !== undefined) {
            queryParameters['foods_and'] = requestParameters.foodsAnd;
        }

        if (requestParameters.foodsOrNot !== undefined) {
            queryParameters['foods_or_not'] = requestParameters.foodsOrNot;
        }

        if (requestParameters.foodsAndNot !== undefined) {
            queryParameters['foods_and_not'] = requestParameters.foodsAndNot;
        }

        if (requestParameters.units !== undefined) {
            queryParameters['units'] = requestParameters.units;
        }

        if (requestParameters.rating !== undefined) {
            queryParameters['rating'] = requestParameters.rating;
        }

        if (requestParameters.books !== undefined) {
            queryParameters['books'] = requestParameters.books;
        }

        if (requestParameters.booksOr !== undefined) {
            queryParameters['books_or'] = requestParameters.booksOr;
        }

        if (requestParameters.booksAnd !== undefined) {
            queryParameters['books_and'] = requestParameters.booksAnd;
        }

        if (requestParameters.booksOrNot !== undefined) {
            queryParameters['books_or_not'] = requestParameters.booksOrNot;
        }

        if (requestParameters.booksAndNot !== undefined) {
            queryParameters['books_and_not'] = requestParameters.booksAndNot;
        }

        if (requestParameters.internal !== undefined) {
            queryParameters['internal'] = requestParameters.internal;
        }

        if (requestParameters.random !== undefined) {
            queryParameters['random'] = requestParameters.random;
        }

        if (requestParameters._new !== undefined) {
            queryParameters['new'] = requestParameters._new;
        }

        if (requestParameters.timescooked !== undefined) {
            queryParameters['timescooked'] = requestParameters.timescooked;
        }

        if (requestParameters.cookedon !== undefined) {
            queryParameters['cookedon'] = requestParameters.cookedon;
        }

        if (requestParameters.createdon !== undefined) {
            queryParameters['createdon'] = requestParameters.createdon;
        }

        if (requestParameters.updatedon !== undefined) {
            queryParameters['updatedon'] = requestParameters.updatedon;
        }

        if (requestParameters.viewedon !== undefined) {
            queryParameters['viewedon'] = requestParameters.viewedon;
        }

        if (requestParameters.makenow !== undefined) {
            queryParameters['makenow'] = requestParameters.makenow;
        }

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListRecipes200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listRecipes(requestParameters: ListRecipesRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListRecipes200Response> {
        const response = await this.listRecipesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listShoppingListEntrysRaw(requestParameters: ListShoppingListEntrysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ShoppingListEntry>>> {
        const queryParameters: any = {};

        if (requestParameters.id !== undefined) {
            queryParameters['id'] = requestParameters.id;
        }

        if (requestParameters.checked !== undefined) {
            queryParameters['checked'] = requestParameters.checked;
        }

        if (requestParameters.supermarket !== undefined) {
            queryParameters['supermarket'] = requestParameters.supermarket;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list-entry/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ShoppingListEntryFromJSON));
    }

    /**
     * 
     */
    async listShoppingListEntrys(requestParameters: ListShoppingListEntrysRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ShoppingListEntry>> {
        const response = await this.listShoppingListEntrysRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listShoppingListRecipesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ShoppingListRecipe>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list-recipe/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ShoppingListRecipeFromJSON));
    }

    /**
     * 
     */
    async listShoppingListRecipes(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ShoppingListRecipe>> {
        const response = await this.listShoppingListRecipesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listShoppingListsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<ShoppingList>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(ShoppingListFromJSON));
    }

    /**
     * 
     */
    async listShoppingLists(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<ShoppingList>> {
        const response = await this.listShoppingListsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listSpacesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Space>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/space/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SpaceFromJSON));
    }

    /**
     * 
     */
    async listSpaces(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Space>> {
        const response = await this.listSpacesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listStepsRaw(requestParameters: ListStepsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListSteps200Response>> {
        const queryParameters: any = {};

        if (requestParameters.recipe !== undefined) {
            queryParameters['recipe'] = requestParameters.recipe;
        }

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/step/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListSteps200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listSteps(requestParameters: ListStepsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListSteps200Response> {
        const response = await this.listStepsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listStoragesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Storage>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/storage/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(StorageFromJSON));
    }

    /**
     * 
     */
    async listStorages(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Storage>> {
        const response = await this.listStoragesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listSupermarketCategoryRelationsRaw(requestParameters: ListSupermarketCategoryRelationsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListSupermarketCategoryRelations200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket-category-relation/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListSupermarketCategoryRelations200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listSupermarketCategoryRelations(requestParameters: ListSupermarketCategoryRelationsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListSupermarketCategoryRelations200Response> {
        const response = await this.listSupermarketCategoryRelationsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listSupermarketCategorysRaw(requestParameters: ListSupermarketCategorysRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<SupermarketCategory>>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket-category/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SupermarketCategoryFromJSON));
    }

    /**
     * 
     */
    async listSupermarketCategorys(requestParameters: ListSupermarketCategorysRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<SupermarketCategory>> {
        const response = await this.listSupermarketCategorysRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listSupermarketsRaw(requestParameters: ListSupermarketsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Supermarket>>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SupermarketFromJSON));
    }

    /**
     * 
     */
    async listSupermarkets(requestParameters: ListSupermarketsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Supermarket>> {
        const response = await this.listSupermarketsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listSyncLogsRaw(requestParameters: ListSyncLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListSyncLogs200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/sync-log/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListSyncLogs200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listSyncLogs(requestParameters: ListSyncLogsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListSyncLogs200Response> {
        const response = await this.listSyncLogsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listSyncsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<Sync>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/sync/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(SyncFromJSON));
    }

    /**
     * 
     */
    async listSyncs(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<Sync>> {
        const response = await this.listSyncsRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listUnitConversionsRaw(requestParameters: ListUnitConversionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UnitConversion>>> {
        const queryParameters: any = {};

        if (requestParameters.foodId !== undefined) {
            queryParameters['food_id'] = requestParameters.foodId;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/unit-conversion/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UnitConversionFromJSON));
    }

    /**
     * 
     */
    async listUnitConversions(requestParameters: ListUnitConversionsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UnitConversion>> {
        const response = await this.listUnitConversionsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listUnitsRaw(requestParameters: ListUnitsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListUnits200Response>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/unit/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListUnits200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listUnits(requestParameters: ListUnitsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListUnits200Response> {
        const response = await this.listUnitsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listUserFilesRaw(requestParameters: ListUserFilesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserFile>>> {
        const queryParameters: any = {};

        if (requestParameters.query !== undefined) {
            queryParameters['query'] = requestParameters.query;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-file/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserFileFromJSON));
    }

    /**
     * 
     */
    async listUserFiles(requestParameters: ListUserFilesRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserFile>> {
        const response = await this.listUserFilesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listUserPreferencesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<UserPreference>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-preference/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserPreferenceFromJSON));
    }

    /**
     * 
     */
    async listUserPreferences(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<UserPreference>> {
        const response = await this.listUserPreferencesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listUserSpacesRaw(requestParameters: ListUserSpacesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListUserSpaces200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-space/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListUserSpaces200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listUserSpaces(requestParameters: ListUserSpacesRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListUserSpaces200Response> {
        const response = await this.listUserSpacesRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * optional parameters  - **filter_list**: array of user id\'s to get names for
     */
    async listUsersRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<User>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(UserFromJSON));
    }

    /**
     * optional parameters  - **filter_list**: array of user id\'s to get names for
     */
    async listUsers(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<User>> {
        const response = await this.listUsersRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async listViewLogsRaw(requestParameters: ListViewLogsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListViewLogs200Response>> {
        const queryParameters: any = {};

        if (requestParameters.page !== undefined) {
            queryParameters['page'] = requestParameters.page;
        }

        if (requestParameters.pageSize !== undefined) {
            queryParameters['page_size'] = requestParameters.pageSize;
        }

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/view-log/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ListViewLogs200ResponseFromJSON(jsonValue));
    }

    /**
     * 
     */
    async listViewLogs(requestParameters: ListViewLogsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListViewLogs200Response> {
        const response = await this.listViewLogsRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * function to reset inheritance from api, see food method for docs
     */
    async listresetFoodInheritancesRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Array<any>>> {
        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/reset-food-inheritance/`,
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse<any>(response);
    }

    /**
     * function to reset inheritance from api, see food method for docs
     */
    async listresetFoodInheritances(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Array<any>> {
        const response = await this.listresetFoodInheritancesRaw(initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async mergeFoodRaw(requestParameters: MergeFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling mergeFood.');
        }

        if (requestParameters.target === null || requestParameters.target === undefined) {
            throw new runtime.RequiredError('target','Required parameter requestParameters.target was null or undefined when calling mergeFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/{id}/merge/{target}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"target"}}`, encodeURIComponent(String(requestParameters.target))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: FoodToJSON(requestParameters.food),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async mergeFood(requestParameters: MergeFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.mergeFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async mergeKeywordRaw(requestParameters: MergeKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Keyword>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling mergeKeyword.');
        }

        if (requestParameters.target === null || requestParameters.target === undefined) {
            throw new runtime.RequiredError('target','Required parameter requestParameters.target was null or undefined when calling mergeKeyword.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/keyword/{id}/merge/{target}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"target"}}`, encodeURIComponent(String(requestParameters.target))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: KeywordToJSON(requestParameters.keyword),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => KeywordFromJSON(jsonValue));
    }

    /**
     * 
     */
    async mergeKeyword(requestParameters: MergeKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Keyword> {
        const response = await this.mergeKeywordRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async mergeSupermarketCategoryRaw(requestParameters: MergeSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling mergeSupermarketCategory.');
        }

        if (requestParameters.target === null || requestParameters.target === undefined) {
            throw new runtime.RequiredError('target','Required parameter requestParameters.target was null or undefined when calling mergeSupermarketCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category/{id}/merge/{target}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"target"}}`, encodeURIComponent(String(requestParameters.target))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryToJSON(requestParameters.supermarketCategory),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async mergeSupermarketCategory(requestParameters: MergeSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategory> {
        const response = await this.mergeSupermarketCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async mergeUnitRaw(requestParameters: MergeUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling mergeUnit.');
        }

        if (requestParameters.target === null || requestParameters.target === undefined) {
            throw new runtime.RequiredError('target','Required parameter requestParameters.target was null or undefined when calling mergeUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit/{id}/merge/{target}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"target"}}`, encodeURIComponent(String(requestParameters.target))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UnitToJSON(requestParameters.unit),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitFromJSON(jsonValue));
    }

    /**
     * 
     */
    async mergeUnit(requestParameters: MergeUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unit> {
        const response = await this.mergeUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async moveFoodRaw(requestParameters: MoveFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling moveFood.');
        }

        if (requestParameters.parent === null || requestParameters.parent === undefined) {
            throw new runtime.RequiredError('parent','Required parameter requestParameters.parent was null or undefined when calling moveFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/{id}/move/{parent}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"parent"}}`, encodeURIComponent(String(requestParameters.parent))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: FoodToJSON(requestParameters.food),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async moveFood(requestParameters: MoveFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.moveFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async moveKeywordRaw(requestParameters: MoveKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Keyword>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling moveKeyword.');
        }

        if (requestParameters.parent === null || requestParameters.parent === undefined) {
            throw new runtime.RequiredError('parent','Required parameter requestParameters.parent was null or undefined when calling moveKeyword.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/keyword/{id}/move/{parent}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))).replace(`{${"parent"}}`, encodeURIComponent(String(requestParameters.parent))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: KeywordToJSON(requestParameters.keyword),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => KeywordFromJSON(jsonValue));
    }

    /**
     * 
     */
    async moveKeyword(requestParameters: MoveKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Keyword> {
        const response = await this.moveKeywordRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateAccessTokenRaw(requestParameters: PartialUpdateAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccessToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateAccessToken.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/access-token/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: AccessTokenToJSON(requestParameters.accessToken),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AccessTokenFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateAccessToken(requestParameters: PartialUpdateAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccessToken> {
        const response = await this.partialUpdateAccessTokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateAutomationRaw(requestParameters: PartialUpdateAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Automation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateAutomation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/automation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: AutomationToJSON(requestParameters.automation),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AutomationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateAutomation(requestParameters: PartialUpdateAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Automation> {
        const response = await this.partialUpdateAutomationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateBookmarkletImportRaw(requestParameters: PartialUpdateBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BookmarkletImport>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateBookmarkletImport.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/bookmarklet-import/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: BookmarkletImportToJSON(requestParameters.bookmarkletImport),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => BookmarkletImportFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateBookmarkletImport(requestParameters: PartialUpdateBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BookmarkletImport> {
        const response = await this.partialUpdateBookmarkletImportRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateCookLogRaw(requestParameters: PartialUpdateCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CookLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateCookLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/cook-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: CookLogToJSON(requestParameters.cookLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CookLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateCookLog(requestParameters: PartialUpdateCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CookLog> {
        const response = await this.partialUpdateCookLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateCustomFilterRaw(requestParameters: PartialUpdateCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CustomFilter>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateCustomFilter.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/custom-filter/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: CustomFilterToJSON(requestParameters.customFilter),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFilterFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateCustomFilter(requestParameters: PartialUpdateCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CustomFilter> {
        const response = await this.partialUpdateCustomFilterRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateExportLogRaw(requestParameters: PartialUpdateExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ExportLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateExportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/export-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ExportLogToJSON(requestParameters.exportLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateExportLog(requestParameters: PartialUpdateExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ExportLog> {
        const response = await this.partialUpdateExportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateFoodRaw(requestParameters: PartialUpdateFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: FoodToJSON(requestParameters.food),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateFood(requestParameters: PartialUpdateFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.partialUpdateFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateImportLogRaw(requestParameters: PartialUpdateImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ImportLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateImportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/import-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ImportLogToJSON(requestParameters.importLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ImportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateImportLog(requestParameters: PartialUpdateImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ImportLog> {
        const response = await this.partialUpdateImportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateIngredientRaw(requestParameters: PartialUpdateIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Ingredient>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateIngredient.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/ingredient/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: IngredientToJSON(requestParameters.ingredient),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => IngredientFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateIngredient(requestParameters: PartialUpdateIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Ingredient> {
        const response = await this.partialUpdateIngredientRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateInviteLinkRaw(requestParameters: PartialUpdateInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteLink>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateInviteLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/invite-link/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: InviteLinkToJSON(requestParameters.inviteLink),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => InviteLinkFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateInviteLink(requestParameters: PartialUpdateInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteLink> {
        const response = await this.partialUpdateInviteLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateKeywordRaw(requestParameters: PartialUpdateKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Keyword>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateKeyword.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/keyword/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: KeywordToJSON(requestParameters.keyword),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => KeywordFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateKeyword(requestParameters: PartialUpdateKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Keyword> {
        const response = await this.partialUpdateKeywordRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateMealPlanRaw(requestParameters: PartialUpdateMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealPlan>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateMealPlan.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/meal-plan/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MealPlanToJSON(requestParameters.mealPlan),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealPlanFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateMealPlan(requestParameters: PartialUpdateMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealPlan> {
        const response = await this.partialUpdateMealPlanRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async partialUpdateMealTypeRaw(requestParameters: PartialUpdateMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealType>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateMealType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/meal-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: MealTypeToJSON(requestParameters.mealType),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealTypeFromJSON(jsonValue));
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async partialUpdateMealType(requestParameters: PartialUpdateMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealType> {
        const response = await this.partialUpdateMealTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataCategoryRaw(requestParameters: PartialUpdateOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataCategoryToJSON(requestParameters.openDataCategory),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataCategoryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataCategory(requestParameters: PartialUpdateOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
        const response = await this.partialUpdateOpenDataCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataConversionRaw(requestParameters: PartialUpdateOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataConversionToJSON(requestParameters.openDataConversion),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataConversionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataConversion(requestParameters: PartialUpdateOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
        const response = await this.partialUpdateOpenDataConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataFoodRaw(requestParameters: PartialUpdateOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataFoodToJSON(requestParameters.openDataFood),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataFoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataFood(requestParameters: PartialUpdateOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
        const response = await this.partialUpdateOpenDataFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataPropertyRaw(requestParameters: PartialUpdateOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataPropertyToJSON(requestParameters.openDataProperty),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataPropertyFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataProperty(requestParameters: PartialUpdateOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
        const response = await this.partialUpdateOpenDataPropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataStoreRaw(requestParameters: PartialUpdateOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataStore.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-store/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataStoreToJSON(requestParameters.openDataStore),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataStoreFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataStore(requestParameters: PartialUpdateOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
        const response = await this.partialUpdateOpenDataStoreRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataUnitRaw(requestParameters: PartialUpdateOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataUnitToJSON(requestParameters.openDataUnit),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataUnitFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataUnit(requestParameters: PartialUpdateOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
        const response = await this.partialUpdateOpenDataUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateOpenDataVersionRaw(requestParameters: PartialUpdateOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateOpenDataVersion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/open-data-version/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: OpenDataVersionToJSON(requestParameters.openDataVersion),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => OpenDataVersionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateOpenDataVersion(requestParameters: PartialUpdateOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
        const response = await this.partialUpdateOpenDataVersionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdatePropertyRaw(requestParameters: PartialUpdatePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Property>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PropertyToJSON(requestParameters.property),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateProperty(requestParameters: PartialUpdatePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Property> {
        const response = await this.partialUpdatePropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdatePropertyTypeRaw(requestParameters: PartialUpdatePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PropertyType>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdatePropertyType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food-property-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: PropertyTypeToJSON(requestParameters.propertyType),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyTypeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdatePropertyType(requestParameters: PartialUpdatePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PropertyType> {
        const response = await this.partialUpdatePropertyTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateRecipeRaw(requestParameters: PartialUpdateRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recipe>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeToJSON(requestParameters.recipe),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateRecipe(requestParameters: PartialUpdateRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recipe> {
        const response = await this.partialUpdateRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateRecipeBookRaw(requestParameters: PartialUpdateRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBook>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateRecipeBook.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-book/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeBookToJSON(requestParameters.recipeBook),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateRecipeBook(requestParameters: PartialUpdateRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBook> {
        const response = await this.partialUpdateRecipeBookRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateRecipeBookEntryRaw(requestParameters: PartialUpdateRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBookEntry>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateRecipeBookEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-book-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeBookEntryToJSON(requestParameters.recipeBookEntry),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateRecipeBookEntry(requestParameters: PartialUpdateRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBookEntry> {
        const response = await this.partialUpdateRecipeBookEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateShoppingListRaw(requestParameters: PartialUpdateShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingList>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateShoppingList.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListToJSON(requestParameters.shoppingList),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateShoppingList(requestParameters: PartialUpdateShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingList> {
        const response = await this.partialUpdateShoppingListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateShoppingListEntryRaw(requestParameters: PartialUpdateShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListEntry>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateShoppingListEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListEntryToJSON(requestParameters.shoppingListEntry),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateShoppingListEntry(requestParameters: PartialUpdateShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListEntry> {
        const response = await this.partialUpdateShoppingListEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateShoppingListRecipeRaw(requestParameters: PartialUpdateShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListRecipe>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateShoppingListRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListRecipeToJSON(requestParameters.shoppingListRecipe),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListRecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateShoppingListRecipe(requestParameters: PartialUpdateShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListRecipe> {
        const response = await this.partialUpdateShoppingListRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateSpaceRaw(requestParameters: PartialUpdateSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Space>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateSpace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/space/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SpaceToJSON(requestParameters.space),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SpaceFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateSpace(requestParameters: PartialUpdateSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Space> {
        const response = await this.partialUpdateSpaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateStepRaw(requestParameters: PartialUpdateStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Step>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateStep.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/step/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: StepToJSON(requestParameters.step),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StepFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateStep(requestParameters: PartialUpdateStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Step> {
        const response = await this.partialUpdateStepRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateStorageRaw(requestParameters: PartialUpdateStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Storage>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateStorage.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/storage/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: StorageToJSON(requestParameters.storage),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StorageFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateStorage(requestParameters: PartialUpdateStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Storage> {
        const response = await this.partialUpdateStorageRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateSupermarketRaw(requestParameters: PartialUpdateSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Supermarket>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateSupermarket.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketToJSON(requestParameters.supermarket),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateSupermarket(requestParameters: PartialUpdateSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Supermarket> {
        const response = await this.partialUpdateSupermarketRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateSupermarketCategoryRaw(requestParameters: PartialUpdateSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateSupermarketCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryToJSON(requestParameters.supermarketCategory),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateSupermarketCategory(requestParameters: PartialUpdateSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategory> {
        const response = await this.partialUpdateSupermarketCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateSupermarketCategoryRelationRaw(requestParameters: PartialUpdateSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategoryRelation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateSupermarketCategoryRelation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category-relation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryRelationToJSON(requestParameters.supermarketCategoryRelation),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryRelationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateSupermarketCategoryRelation(requestParameters: PartialUpdateSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategoryRelation> {
        const response = await this.partialUpdateSupermarketCategoryRelationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateSyncRaw(requestParameters: PartialUpdateSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Sync>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateSync.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/sync/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: SyncToJSON(requestParameters.sync),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SyncFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateSync(requestParameters: PartialUpdateSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Sync> {
        const response = await this.partialUpdateSyncRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateUnitRaw(requestParameters: PartialUpdateUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UnitToJSON(requestParameters.unit),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateUnit(requestParameters: PartialUpdateUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unit> {
        const response = await this.partialUpdateUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateUnitConversionRaw(requestParameters: PartialUpdateUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UnitConversion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateUnitConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UnitConversionToJSON(requestParameters.unitConversion),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitConversionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateUnitConversion(requestParameters: PartialUpdateUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UnitConversion> {
        const response = await this.partialUpdateUnitConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateUserRaw(requestParameters: PartialUpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/user/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UserToJSON(requestParameters.user),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateUser(requestParameters: PartialUpdateUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
        const response = await this.partialUpdateUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateUserFileRaw(requestParameters: PartialUpdateUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateUserFile.');
        }

        if (requestParameters.name === null || requestParameters.name === undefined) {
            throw new runtime.RequiredError('name','Required parameter requestParameters.name was null or undefined when calling partialUpdateUserFile.');
        }

        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling partialUpdateUserFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.id2 !== undefined) {
            formParams.append('id', requestParameters.id2 as any);
        }

        if (requestParameters.name !== undefined) {
            formParams.append('name', requestParameters.name as any);
        }

        if (requestParameters.file !== undefined) {
            formParams.append('file', requestParameters.file as any);
        }

        if (requestParameters.fileDownload !== undefined) {
            formParams.append('file_download', requestParameters.fileDownload as any);
        }

        if (requestParameters.preview !== undefined) {
            formParams.append('preview', requestParameters.preview as any);
        }

        if (requestParameters.fileSizeKb !== undefined) {
            formParams.append('file_size_kb', requestParameters.fileSizeKb as any);
        }

        const response = await this.request({
            path: `/api/user-file/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserFileFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateUserFile(requestParameters: PartialUpdateUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserFile> {
        const response = await this.partialUpdateUserFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateUserPreferenceRaw(requestParameters: PartialUpdateUserPreferenceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserPreference>> {
        if (requestParameters.user === null || requestParameters.user === undefined) {
            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling partialUpdateUserPreference.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/user-preference/{user}/`.replace(`{${"user"}}`, encodeURIComponent(String(requestParameters.user))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UserPreferenceToJSON(requestParameters.userPreference),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserPreferenceFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateUserPreference(requestParameters: PartialUpdateUserPreferenceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPreference> {
        const response = await this.partialUpdateUserPreferenceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateUserSpaceRaw(requestParameters: PartialUpdateUserSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSpace>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateUserSpace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/user-space/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: UserSpaceToJSON(requestParameters.userSpace),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserSpaceFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateUserSpace(requestParameters: PartialUpdateUserSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSpace> {
        const response = await this.partialUpdateUserSpaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async partialUpdateViewLogRaw(requestParameters: PartialUpdateViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ViewLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling partialUpdateViewLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/view-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PATCH',
            headers: headerParameters,
            query: queryParameters,
            body: ViewLogToJSON(requestParameters.viewLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ViewLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async partialUpdateViewLog(requestParameters: PartialUpdateViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ViewLog> {
        const response = await this.partialUpdateViewLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async relatedRecipeRaw(requestParameters: RelatedRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeSimple>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling relatedRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe/{id}/related/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeSimpleFromJSON(jsonValue));
    }

    /**
     * 
     */
    async relatedRecipe(requestParameters: RelatedRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeSimple> {
        const response = await this.relatedRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveAccessTokenRaw(requestParameters: RetrieveAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccessToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveAccessToken.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/access-token/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AccessTokenFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveAccessToken(requestParameters: RetrieveAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccessToken> {
        const response = await this.retrieveAccessTokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveAutomationRaw(requestParameters: RetrieveAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Automation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveAutomation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/automation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AutomationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveAutomation(requestParameters: RetrieveAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Automation> {
        const response = await this.retrieveAutomationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveBookmarkletImportRaw(requestParameters: RetrieveBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BookmarkletImport>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveBookmarkletImport.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/bookmarklet-import/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => BookmarkletImportFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveBookmarkletImport(requestParameters: RetrieveBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BookmarkletImport> {
        const response = await this.retrieveBookmarkletImportRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveCookLogRaw(requestParameters: RetrieveCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CookLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveCookLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/cook-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CookLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveCookLog(requestParameters: RetrieveCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CookLog> {
        const response = await this.retrieveCookLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveCustomFilterRaw(requestParameters: RetrieveCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CustomFilter>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveCustomFilter.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/custom-filter/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFilterFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveCustomFilter(requestParameters: RetrieveCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CustomFilter> {
        const response = await this.retrieveCustomFilterRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveExportLogRaw(requestParameters: RetrieveExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ExportLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveExportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/export-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveExportLog(requestParameters: RetrieveExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ExportLog> {
        const response = await this.retrieveExportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveFDCViewSetRaw(requestParameters: RetrieveFDCViewSetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveFDCViewSet.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/open-data-FDC/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * 
     */
    async retrieveFDCViewSet(requestParameters: RetrieveFDCViewSetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.retrieveFDCViewSetRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveFoodRaw(requestParameters: RetrieveFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveFood(requestParameters: RetrieveFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.retrieveFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveFoodInheritFieldRaw(requestParameters: RetrieveFoodInheritFieldRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FoodInheritField>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveFoodInheritField.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-inherit-field/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodInheritFieldFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveFoodInheritField(requestParameters: RetrieveFoodInheritFieldRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FoodInheritField> {
        const response = await this.retrieveFoodInheritFieldRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveGroupRaw(requestParameters: RetrieveGroupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Group>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveGroup.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/group/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => GroupFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveGroup(requestParameters: RetrieveGroupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Group> {
        const response = await this.retrieveGroupRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveImportLogRaw(requestParameters: RetrieveImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ImportLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveImportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/import-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ImportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveImportLog(requestParameters: RetrieveImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ImportLog> {
        const response = await this.retrieveImportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveIngredientRaw(requestParameters: RetrieveIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Ingredient>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveIngredient.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/ingredient/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => IngredientFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveIngredient(requestParameters: RetrieveIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Ingredient> {
        const response = await this.retrieveIngredientRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveInviteLinkRaw(requestParameters: RetrieveInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteLink>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveInviteLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/invite-link/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => InviteLinkFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveInviteLink(requestParameters: RetrieveInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteLink> {
        const response = await this.retrieveInviteLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveKeywordRaw(requestParameters: RetrieveKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Keyword>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveKeyword.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/keyword/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => KeywordFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveKeyword(requestParameters: RetrieveKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Keyword> {
        const response = await this.retrieveKeywordRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveMealPlanRaw(requestParameters: RetrieveMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealPlan>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveMealPlan.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/meal-plan/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealPlanFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveMealPlan(requestParameters: RetrieveMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealPlan> {
        const response = await this.retrieveMealPlanRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async retrieveMealTypeRaw(requestParameters: RetrieveMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealType>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveMealType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/meal-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealTypeFromJSON(jsonValue));
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async retrieveMealType(requestParameters: RetrieveMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealType> {
        const response = await this.retrieveMealTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataCategoryRaw(requestParameters: RetrieveOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataCategory(requestParameters: RetrieveOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
        const response = await this.retrieveOpenDataCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataConversionRaw(requestParameters: RetrieveOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataConversion(requestParameters: RetrieveOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
        const response = await this.retrieveOpenDataConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataFoodRaw(requestParameters: RetrieveOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataFood(requestParameters: RetrieveOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
        const response = await this.retrieveOpenDataFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataPropertyRaw(requestParameters: RetrieveOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataProperty(requestParameters: RetrieveOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
        const response = await this.retrieveOpenDataPropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataStoreRaw(requestParameters: RetrieveOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataStore.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataStore(requestParameters: RetrieveOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
        const response = await this.retrieveOpenDataStoreRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataUnitRaw(requestParameters: RetrieveOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataUnit(requestParameters: RetrieveOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
        const response = await this.retrieveOpenDataUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveOpenDataVersionRaw(requestParameters: RetrieveOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveOpenDataVersion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        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 retrieveOpenDataVersion(requestParameters: RetrieveOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
        const response = await this.retrieveOpenDataVersionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrievePropertyRaw(requestParameters: RetrievePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Property>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveProperty(requestParameters: RetrievePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Property> {
        const response = await this.retrievePropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrievePropertyTypeRaw(requestParameters: RetrievePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PropertyType>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrievePropertyType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/food-property-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyTypeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrievePropertyType(requestParameters: RetrievePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PropertyType> {
        const response = await this.retrievePropertyTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveRecipeRaw(requestParameters: RetrieveRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recipe>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveRecipe(requestParameters: RetrieveRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recipe> {
        const response = await this.retrieveRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveRecipeBookRaw(requestParameters: RetrieveRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBook>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveRecipeBook.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe-book/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveRecipeBook(requestParameters: RetrieveRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBook> {
        const response = await this.retrieveRecipeBookRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveRecipeBookEntryRaw(requestParameters: RetrieveRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBookEntry>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveRecipeBookEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/recipe-book-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveRecipeBookEntry(requestParameters: RetrieveRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBookEntry> {
        const response = await this.retrieveRecipeBookEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveShoppingListRaw(requestParameters: RetrieveShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingList>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveShoppingList.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveShoppingList(requestParameters: RetrieveShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingList> {
        const response = await this.retrieveShoppingListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveShoppingListEntryRaw(requestParameters: RetrieveShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListEntry>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveShoppingListEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveShoppingListEntry(requestParameters: RetrieveShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListEntry> {
        const response = await this.retrieveShoppingListEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveShoppingListRecipeRaw(requestParameters: RetrieveShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListRecipe>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveShoppingListRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/shopping-list-recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListRecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveShoppingListRecipe(requestParameters: RetrieveShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListRecipe> {
        const response = await this.retrieveShoppingListRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveSpaceRaw(requestParameters: RetrieveSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Space>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveSpace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/space/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SpaceFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveSpace(requestParameters: RetrieveSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Space> {
        const response = await this.retrieveSpaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveStepRaw(requestParameters: RetrieveStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Step>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveStep.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/step/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StepFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveStep(requestParameters: RetrieveStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Step> {
        const response = await this.retrieveStepRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveStorageRaw(requestParameters: RetrieveStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Storage>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveStorage.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/storage/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StorageFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveStorage(requestParameters: RetrieveStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Storage> {
        const response = await this.retrieveStorageRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveSupermarketRaw(requestParameters: RetrieveSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Supermarket>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveSupermarket.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveSupermarket(requestParameters: RetrieveSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Supermarket> {
        const response = await this.retrieveSupermarketRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveSupermarketCategoryRaw(requestParameters: RetrieveSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveSupermarketCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveSupermarketCategory(requestParameters: RetrieveSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategory> {
        const response = await this.retrieveSupermarketCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveSupermarketCategoryRelationRaw(requestParameters: RetrieveSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategoryRelation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveSupermarketCategoryRelation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/supermarket-category-relation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryRelationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveSupermarketCategoryRelation(requestParameters: RetrieveSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategoryRelation> {
        const response = await this.retrieveSupermarketCategoryRelationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveSyncRaw(requestParameters: RetrieveSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Sync>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveSync.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/sync/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SyncFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveSync(requestParameters: RetrieveSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Sync> {
        const response = await this.retrieveSyncRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveSyncLogRaw(requestParameters: RetrieveSyncLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SyncLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveSyncLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/sync-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SyncLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveSyncLog(requestParameters: RetrieveSyncLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SyncLog> {
        const response = await this.retrieveSyncLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveUnitRaw(requestParameters: RetrieveUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveUnit(requestParameters: RetrieveUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unit> {
        const response = await this.retrieveUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveUnitConversionRaw(requestParameters: RetrieveUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UnitConversion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveUnitConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/unit-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitConversionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveUnitConversion(requestParameters: RetrieveUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UnitConversion> {
        const response = await this.retrieveUnitConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveUserRaw(requestParameters: RetrieveUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<User>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveUser.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveUser(requestParameters: RetrieveUserRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<User> {
        const response = await this.retrieveUserRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveUserFileRaw(requestParameters: RetrieveUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveUserFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-file/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserFileFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveUserFile(requestParameters: RetrieveUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserFile> {
        const response = await this.retrieveUserFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveUserPreferenceRaw(requestParameters: RetrieveUserPreferenceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserPreference>> {
        if (requestParameters.user === null || requestParameters.user === undefined) {
            throw new runtime.RequiredError('user','Required parameter requestParameters.user was null or undefined when calling retrieveUserPreference.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-preference/{user}/`.replace(`{${"user"}}`, encodeURIComponent(String(requestParameters.user))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserPreferenceFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveUserPreference(requestParameters: RetrieveUserPreferenceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPreference> {
        const response = await this.retrieveUserPreferenceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveUserSpaceRaw(requestParameters: RetrieveUserSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSpace>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveUserSpace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/user-space/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserSpaceFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveUserSpace(requestParameters: RetrieveUserSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSpace> {
        const response = await this.retrieveUserSpaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveViewLogRaw(requestParameters: RetrieveViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ViewLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveViewLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/view-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ViewLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async retrieveViewLog(requestParameters: RetrieveViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ViewLog> {
        const response = await this.retrieveViewLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * function to download a user file securely (wrapping as zip to prevent any context based XSS problems) temporary solution until a real file manager is implemented
     */
    async retrievedownloadFileRaw(requestParameters: RetrievedownloadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        if (requestParameters.fileId === null || requestParameters.fileId === undefined) {
            throw new runtime.RequiredError('fileId','Required parameter requestParameters.fileId was null or undefined when calling retrievedownloadFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/download-file/{file_id}/`.replace(`{${"file_id"}}`, encodeURIComponent(String(requestParameters.fileId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * function to download a user file securely (wrapping as zip to prevent any context based XSS problems) temporary solution until a real file manager is implemented
     */
    async retrievedownloadFile(requestParameters: RetrievedownloadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.retrievedownloadFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async retrieveshareLinkRaw(requestParameters: RetrieveshareLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling retrieveshareLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/share-link/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * 
     */
    async retrieveshareLink(requestParameters: RetrieveshareLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.retrieveshareLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * api endpoint to switch space function
     */
    async retrieveswitchActiveSpaceRaw(requestParameters: RetrieveswitchActiveSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<any>> {
        if (requestParameters.spaceId === null || requestParameters.spaceId === undefined) {
            throw new runtime.RequiredError('spaceId','Required parameter requestParameters.spaceId was null or undefined when calling retrieveswitchActiveSpace.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const response = await this.request({
            path: `/api/switch-active-space/{space_id}/`.replace(`{${"space_id"}}`, encodeURIComponent(String(requestParameters.spaceId))),
            method: 'GET',
            headers: headerParameters,
            query: queryParameters,
        }, initOverrides);

        if (this.isJsonMime(response.headers.get('content-type'))) {
            return new runtime.JSONApiResponse<any>(response);
        } else {
            return new runtime.TextApiResponse(response) as any;
        }
    }

    /**
     * api endpoint to switch space function
     */
    async retrieveswitchActiveSpace(requestParameters: RetrieveswitchActiveSpaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<any> {
        const response = await this.retrieveswitchActiveSpaceRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async shoppingFoodRaw(requestParameters: ShoppingFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<FoodShoppingUpdate>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling shoppingFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/{id}/shopping/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: FoodShoppingUpdateToJSON(requestParameters.foodShoppingUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodShoppingUpdateFromJSON(jsonValue));
    }

    /**
     * 
     */
    async shoppingFood(requestParameters: ShoppingFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<FoodShoppingUpdate> {
        const response = await this.shoppingFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async shoppingRecipeRaw(requestParameters: ShoppingRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeShoppingUpdate>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling shoppingRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe/{id}/shopping/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeShoppingUpdateToJSON(requestParameters.recipeShoppingUpdate),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeShoppingUpdateFromJSON(jsonValue));
    }

    /**
     * 
     */
    async shoppingRecipe(requestParameters: ShoppingRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeShoppingUpdate> {
        const response = await this.shoppingRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateAccessTokenRaw(requestParameters: UpdateAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<AccessToken>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAccessToken.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/access-token/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: AccessTokenToJSON(requestParameters.accessToken),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AccessTokenFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateAccessToken(requestParameters: UpdateAccessTokenRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<AccessToken> {
        const response = await this.updateAccessTokenRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateAutomationRaw(requestParameters: UpdateAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Automation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateAutomation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/automation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: AutomationToJSON(requestParameters.automation),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => AutomationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateAutomation(requestParameters: UpdateAutomationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Automation> {
        const response = await this.updateAutomationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateBookmarkletImportRaw(requestParameters: UpdateBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BookmarkletImport>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateBookmarkletImport.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/bookmarklet-import/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: BookmarkletImportToJSON(requestParameters.bookmarkletImport),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => BookmarkletImportFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateBookmarkletImport(requestParameters: UpdateBookmarkletImportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BookmarkletImport> {
        const response = await this.updateBookmarkletImportRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateCookLogRaw(requestParameters: UpdateCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CookLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateCookLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/cook-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CookLogToJSON(requestParameters.cookLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CookLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateCookLog(requestParameters: UpdateCookLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CookLog> {
        const response = await this.updateCookLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateCustomFilterRaw(requestParameters: UpdateCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CustomFilter>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateCustomFilter.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/custom-filter/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: CustomFilterToJSON(requestParameters.customFilter),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => CustomFilterFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateCustomFilter(requestParameters: UpdateCustomFilterRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CustomFilter> {
        const response = await this.updateCustomFilterRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateExportLogRaw(requestParameters: UpdateExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ExportLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateExportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/export-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ExportLogToJSON(requestParameters.exportLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ExportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateExportLog(requestParameters: UpdateExportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ExportLog> {
        const response = await this.updateExportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateFoodRaw(requestParameters: UpdateFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Food>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: FoodToJSON(requestParameters.food),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => FoodFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateFood(requestParameters: UpdateFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Food> {
        const response = await this.updateFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateImportLogRaw(requestParameters: UpdateImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ImportLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateImportLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/import-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ImportLogToJSON(requestParameters.importLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ImportLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateImportLog(requestParameters: UpdateImportLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ImportLog> {
        const response = await this.updateImportLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateIngredientRaw(requestParameters: UpdateIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Ingredient>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateIngredient.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/ingredient/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: IngredientToJSON(requestParameters.ingredient),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => IngredientFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateIngredient(requestParameters: UpdateIngredientRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Ingredient> {
        const response = await this.updateIngredientRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateInviteLinkRaw(requestParameters: UpdateInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<InviteLink>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateInviteLink.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/invite-link/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: InviteLinkToJSON(requestParameters.inviteLink),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => InviteLinkFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateInviteLink(requestParameters: UpdateInviteLinkRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<InviteLink> {
        const response = await this.updateInviteLinkRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateKeywordRaw(requestParameters: UpdateKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Keyword>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateKeyword.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/keyword/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: KeywordToJSON(requestParameters.keyword),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => KeywordFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateKeyword(requestParameters: UpdateKeywordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Keyword> {
        const response = await this.updateKeywordRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateMealPlanRaw(requestParameters: UpdateMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealPlan>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMealPlan.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/meal-plan/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MealPlanToJSON(requestParameters.mealPlan),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealPlanFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateMealPlan(requestParameters: UpdateMealPlanRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealPlan> {
        const response = await this.updateMealPlanRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async updateMealTypeRaw(requestParameters: UpdateMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MealType>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateMealType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/meal-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: MealTypeToJSON(requestParameters.mealType),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => MealTypeFromJSON(jsonValue));
    }

    /**
     * returns list of meal types created by the requesting user ordered by the order field.
     */
    async updateMealType(requestParameters: UpdateMealTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MealType> {
        const response = await this.updateMealTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataCategoryRaw(requestParameters: UpdateOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataCategory(requestParameters: UpdateOpenDataCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataCategory> {
        const response = await this.updateOpenDataCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataConversionRaw(requestParameters: UpdateOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataConversion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataConversion(requestParameters: UpdateOpenDataConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataConversion> {
        const response = await this.updateOpenDataConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataFoodRaw(requestParameters: UpdateOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataFood>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataFood.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataFood(requestParameters: UpdateOpenDataFoodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataFood> {
        const response = await this.updateOpenDataFoodRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataPropertyRaw(requestParameters: UpdateOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataProperty>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataProperty(requestParameters: UpdateOpenDataPropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataProperty> {
        const response = await this.updateOpenDataPropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataStoreRaw(requestParameters: UpdateOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataStore>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataStore.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataStore(requestParameters: UpdateOpenDataStoreRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataStore> {
        const response = await this.updateOpenDataStoreRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataUnitRaw(requestParameters: UpdateOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataUnit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataUnit(requestParameters: UpdateOpenDataUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataUnit> {
        const response = await this.updateOpenDataUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateOpenDataVersionRaw(requestParameters: UpdateOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<OpenDataVersion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateOpenDataVersion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        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 updateOpenDataVersion(requestParameters: UpdateOpenDataVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<OpenDataVersion> {
        const response = await this.updateOpenDataVersionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updatePropertyRaw(requestParameters: UpdatePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Property>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateProperty.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food-property/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: PropertyToJSON(requestParameters.property),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateProperty(requestParameters: UpdatePropertyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Property> {
        const response = await this.updatePropertyRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updatePropertyTypeRaw(requestParameters: UpdatePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PropertyType>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updatePropertyType.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/food-property-type/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: PropertyTypeToJSON(requestParameters.propertyType),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => PropertyTypeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updatePropertyType(requestParameters: UpdatePropertyTypeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PropertyType> {
        const response = await this.updatePropertyTypeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateRecipeRaw(requestParameters: UpdateRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Recipe>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeToJSON(requestParameters.recipe),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateRecipe(requestParameters: UpdateRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Recipe> {
        const response = await this.updateRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateRecipeBookRaw(requestParameters: UpdateRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBook>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateRecipeBook.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-book/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeBookToJSON(requestParameters.recipeBook),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateRecipeBook(requestParameters: UpdateRecipeBookRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBook> {
        const response = await this.updateRecipeBookRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateRecipeBookEntryRaw(requestParameters: UpdateRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecipeBookEntry>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateRecipeBookEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/recipe-book-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: RecipeBookEntryToJSON(requestParameters.recipeBookEntry),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => RecipeBookEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateRecipeBookEntry(requestParameters: UpdateRecipeBookEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecipeBookEntry> {
        const response = await this.updateRecipeBookEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateShoppingListRaw(requestParameters: UpdateShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingList>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateShoppingList.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListToJSON(requestParameters.shoppingList),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateShoppingList(requestParameters: UpdateShoppingListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingList> {
        const response = await this.updateShoppingListRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateShoppingListEntryRaw(requestParameters: UpdateShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListEntry>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateShoppingListEntry.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-entry/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListEntryToJSON(requestParameters.shoppingListEntry),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListEntryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateShoppingListEntry(requestParameters: UpdateShoppingListEntryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListEntry> {
        const response = await this.updateShoppingListEntryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateShoppingListRecipeRaw(requestParameters: UpdateShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ShoppingListRecipe>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateShoppingListRecipe.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/shopping-list-recipe/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ShoppingListRecipeToJSON(requestParameters.shoppingListRecipe),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ShoppingListRecipeFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateShoppingListRecipe(requestParameters: UpdateShoppingListRecipeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ShoppingListRecipe> {
        const response = await this.updateShoppingListRecipeRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateStepRaw(requestParameters: UpdateStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Step>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateStep.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/step/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: StepToJSON(requestParameters.step),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StepFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateStep(requestParameters: UpdateStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Step> {
        const response = await this.updateStepRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateStorageRaw(requestParameters: UpdateStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Storage>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateStorage.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/storage/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: StorageToJSON(requestParameters.storage),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => StorageFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateStorage(requestParameters: UpdateStorageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Storage> {
        const response = await this.updateStorageRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateSupermarketRaw(requestParameters: UpdateSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Supermarket>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSupermarket.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketToJSON(requestParameters.supermarket),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateSupermarket(requestParameters: UpdateSupermarketRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Supermarket> {
        const response = await this.updateSupermarketRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateSupermarketCategoryRaw(requestParameters: UpdateSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategory>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSupermarketCategory.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryToJSON(requestParameters.supermarketCategory),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateSupermarketCategory(requestParameters: UpdateSupermarketCategoryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategory> {
        const response = await this.updateSupermarketCategoryRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateSupermarketCategoryRelationRaw(requestParameters: UpdateSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SupermarketCategoryRelation>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSupermarketCategoryRelation.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/supermarket-category-relation/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SupermarketCategoryRelationToJSON(requestParameters.supermarketCategoryRelation),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SupermarketCategoryRelationFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateSupermarketCategoryRelation(requestParameters: UpdateSupermarketCategoryRelationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SupermarketCategoryRelation> {
        const response = await this.updateSupermarketCategoryRelationRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateSyncRaw(requestParameters: UpdateSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Sync>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateSync.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/sync/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: SyncToJSON(requestParameters.sync),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => SyncFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateSync(requestParameters: UpdateSyncRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Sync> {
        const response = await this.updateSyncRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateUnitRaw(requestParameters: UpdateUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Unit>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateUnit.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UnitToJSON(requestParameters.unit),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateUnit(requestParameters: UpdateUnitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Unit> {
        const response = await this.updateUnitRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateUnitConversionRaw(requestParameters: UpdateUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UnitConversion>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateUnitConversion.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/unit-conversion/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: UnitConversionToJSON(requestParameters.unitConversion),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UnitConversionFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateUnitConversion(requestParameters: UpdateUnitConversionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UnitConversion> {
        const response = await this.updateUnitConversionRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateUserFileRaw(requestParameters: UpdateUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserFile>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateUserFile.');
        }

        if (requestParameters.name === null || requestParameters.name === undefined) {
            throw new runtime.RequiredError('name','Required parameter requestParameters.name was null or undefined when calling updateUserFile.');
        }

        if (requestParameters.file === null || requestParameters.file === undefined) {
            throw new runtime.RequiredError('file','Required parameter requestParameters.file was null or undefined when calling updateUserFile.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        const consumes: runtime.Consume[] = [
            { contentType: 'multipart/form-data' },
        ];
        // @ts-ignore: canConsumeForm may be unused
        const canConsumeForm = runtime.canConsumeForm(consumes);

        let formParams: { append(param: string, value: any): any };
        let useForm = false;
        // use FormData to transmit files using content-type "multipart/form-data"
        useForm = canConsumeForm;
        if (useForm) {
            formParams = new FormData();
        } else {
            formParams = new URLSearchParams();
        }

        if (requestParameters.id2 !== undefined) {
            formParams.append('id', requestParameters.id2 as any);
        }

        if (requestParameters.name !== undefined) {
            formParams.append('name', requestParameters.name as any);
        }

        if (requestParameters.file !== undefined) {
            formParams.append('file', requestParameters.file as any);
        }

        if (requestParameters.fileDownload !== undefined) {
            formParams.append('file_download', requestParameters.fileDownload as any);
        }

        if (requestParameters.preview !== undefined) {
            formParams.append('preview', requestParameters.preview as any);
        }

        if (requestParameters.fileSizeKb !== undefined) {
            formParams.append('file_size_kb', requestParameters.fileSizeKb as any);
        }

        const response = await this.request({
            path: `/api/user-file/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: formParams,
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => UserFileFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateUserFile(requestParameters: UpdateUserFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserFile> {
        const response = await this.updateUserFileRaw(requestParameters, initOverrides);
        return await response.value();
    }

    /**
     * 
     */
    async updateViewLogRaw(requestParameters: UpdateViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ViewLog>> {
        if (requestParameters.id === null || requestParameters.id === undefined) {
            throw new runtime.RequiredError('id','Required parameter requestParameters.id was null or undefined when calling updateViewLog.');
        }

        const queryParameters: any = {};

        const headerParameters: runtime.HTTPHeaders = {};

        headerParameters['Content-Type'] = 'application/json';

        const response = await this.request({
            path: `/api/view-log/{id}/`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters.id))),
            method: 'PUT',
            headers: headerParameters,
            query: queryParameters,
            body: ViewLogToJSON(requestParameters.viewLog),
        }, initOverrides);

        return new runtime.JSONApiResponse(response, (jsonValue) => ViewLogFromJSON(jsonValue));
    }

    /**
     * 
     */
    async updateViewLog(requestParameters: UpdateViewLogRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ViewLog> {
        const response = await this.updateViewLogRaw(requestParameters, initOverrides);
        return await response.value();
    }

}