api_ingredients.go

/*
spoonacular API

The spoonacular Nutrition, Recipe, and Food API allows you to access over thousands of recipes, thousands of ingredients, 800,000 food products, over 100,000 menu items, and restaurants. Our food ontology and semantic recipe search engine makes it possible to search for recipes using natural language queries, such as \"gluten free brownies without sugar\" or \"low fat vegan cupcakes.\" You can automatically calculate the nutritional information for any recipe, analyze recipe costs, visualize ingredient lists, find recipes for what's in your fridge, find recipes based on special diets, nutritional requirements, or favorite ingredients, classify recipes into types and cuisines, convert ingredient amounts, or even compute an entire meal plan. With our powerful API, you can create many kinds of food and especially nutrition apps.  Special diets/dietary requirements currently available include: vegan, vegetarian, pescetarian, gluten free, grain free, dairy free, high protein, whole 30, low sodium, low carb, Paleo, ketogenic, FODMAP, and Primal.

API version: 2.0.1
Contact: mail@spoonacular.com
*/

// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.

package spoonacular

import (
	"bytes"
	"context"
	"io"
	"net/http"
	"net/url"
	"strings"
	"os"
)


// IngredientsAPIService IngredientsAPI service
type IngredientsAPIService service

type ApiAutocompleteIngredientSearchRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	query *string
	number *int32
	metaInformation *bool
	intolerances *string
	language *string
}

// The (natural language) search query.
func (r ApiAutocompleteIngredientSearchRequest) Query(query string) ApiAutocompleteIngredientSearchRequest {
	r.query = &query
	return r
}

// The maximum number of items to return (between 1 and 100). Defaults to 10.
func (r ApiAutocompleteIngredientSearchRequest) Number(number int32) ApiAutocompleteIngredientSearchRequest {
	r.number = &number
	return r
}

// Whether to return more meta information about the ingredients.
func (r ApiAutocompleteIngredientSearchRequest) MetaInformation(metaInformation bool) ApiAutocompleteIngredientSearchRequest {
	r.metaInformation = &metaInformation
	return r
}

// A comma-separated list of intolerances. All recipes returned must not contain ingredients that are not suitable for people with the intolerances entered. See a full list of supported intolerances.
func (r ApiAutocompleteIngredientSearchRequest) Intolerances(intolerances string) ApiAutocompleteIngredientSearchRequest {
	r.intolerances = &intolerances
	return r
}

// The language of the input. Either 'en' or 'de'.
func (r ApiAutocompleteIngredientSearchRequest) Language(language string) ApiAutocompleteIngredientSearchRequest {
	r.language = &language
	return r
}

func (r ApiAutocompleteIngredientSearchRequest) Execute() ([]AutocompleteIngredientSearch200ResponseInner, *http.Response, error) {
	return r.ApiService.AutocompleteIngredientSearchExecute(r)
}

/*
AutocompleteIngredientSearch Autocomplete Ingredient Search

Autocomplete the entry of an ingredient.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiAutocompleteIngredientSearchRequest
*/
func (a *IngredientsAPIService) AutocompleteIngredientSearch(ctx context.Context) ApiAutocompleteIngredientSearchRequest {
	return ApiAutocompleteIngredientSearchRequest{
		ApiService: a,
		ctx: ctx,
	}
}

// Execute executes the request
//  @return []AutocompleteIngredientSearch200ResponseInner
func (a *IngredientsAPIService) AutocompleteIngredientSearchExecute(r ApiAutocompleteIngredientSearchRequest) ([]AutocompleteIngredientSearch200ResponseInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  []AutocompleteIngredientSearch200ResponseInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.AutocompleteIngredientSearch")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/autocomplete"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.query == nil {
		return localVarReturnValue, nil, reportError("query is required and must be specified")
	}

	parameterAddToHeaderOrQuery(localVarQueryParams, "query", r.query, "")
	if r.number != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "number", r.number, "")
	} else {
		var defaultValue int32 = 10
		r.number = &defaultValue
	}
	if r.metaInformation != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "metaInformation", r.metaInformation, "")
	}
	if r.intolerances != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "intolerances", r.intolerances, "")
	}
	if r.language != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "language", r.language, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiComputeIngredientAmountRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	id int32
	nutrient *string
	target *int32
	unit *string
}

// The target nutrient. See a list of supported nutrients.
func (r ApiComputeIngredientAmountRequest) Nutrient(nutrient string) ApiComputeIngredientAmountRequest {
	r.nutrient = &nutrient
	return r
}

// The target number of the given nutrient.
func (r ApiComputeIngredientAmountRequest) Target(target int32) ApiComputeIngredientAmountRequest {
	r.target = &target
	return r
}

// The target unit.
func (r ApiComputeIngredientAmountRequest) Unit(unit string) ApiComputeIngredientAmountRequest {
	r.unit = &unit
	return r
}

func (r ApiComputeIngredientAmountRequest) Execute() (*ComputeIngredientAmount200Response, *http.Response, error) {
	return r.ApiService.ComputeIngredientAmountExecute(r)
}

/*
ComputeIngredientAmount Compute Ingredient Amount

Compute the amount you need of a certain ingredient for a certain nutritional goal. For example, how much pineapple do you have to eat to get 10 grams of protein?

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param id The id of the ingredient you want the amount for.
 @return ApiComputeIngredientAmountRequest
*/
func (a *IngredientsAPIService) ComputeIngredientAmount(ctx context.Context, id int32) ApiComputeIngredientAmountRequest {
	return ApiComputeIngredientAmountRequest{
		ApiService: a,
		ctx: ctx,
		id: id,
	}
}

// Execute executes the request
//  @return ComputeIngredientAmount200Response
func (a *IngredientsAPIService) ComputeIngredientAmountExecute(r ApiComputeIngredientAmountRequest) (*ComputeIngredientAmount200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *ComputeIngredientAmount200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.ComputeIngredientAmount")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/{id}/amount"
	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.nutrient == nil {
		return localVarReturnValue, nil, reportError("nutrient is required and must be specified")
	}
	if r.target == nil {
		return localVarReturnValue, nil, reportError("target is required and must be specified")
	}

	parameterAddToHeaderOrQuery(localVarQueryParams, "nutrient", r.nutrient, "")
	parameterAddToHeaderOrQuery(localVarQueryParams, "target", r.target, "")
	if r.unit != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "unit", r.unit, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetIngredientInformationRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	id int32
	amount *float32
	unit *string
}

// The amount of this ingredient.
func (r ApiGetIngredientInformationRequest) Amount(amount float32) ApiGetIngredientInformationRequest {
	r.amount = &amount
	return r
}

// The unit for the given amount.
func (r ApiGetIngredientInformationRequest) Unit(unit string) ApiGetIngredientInformationRequest {
	r.unit = &unit
	return r
}

func (r ApiGetIngredientInformationRequest) Execute() (*IngredientInformation, *http.Response, error) {
	return r.ApiService.GetIngredientInformationExecute(r)
}

/*
GetIngredientInformation Get Ingredient Information

Use an ingredient id to get all available information about an ingredient, such as its image and supermarket aisle.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param id The ingredient id.
 @return ApiGetIngredientInformationRequest
*/
func (a *IngredientsAPIService) GetIngredientInformation(ctx context.Context, id int32) ApiGetIngredientInformationRequest {
	return ApiGetIngredientInformationRequest{
		ApiService: a,
		ctx: ctx,
		id: id,
	}
}

// Execute executes the request
//  @return IngredientInformation
func (a *IngredientsAPIService) GetIngredientInformationExecute(r ApiGetIngredientInformationRequest) (*IngredientInformation, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *IngredientInformation
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.GetIngredientInformation")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/{id}/information"
	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.amount != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "amount", r.amount, "")
	}
	if r.unit != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "unit", r.unit, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetIngredientSubstitutesRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	ingredientName *string
}

// The name of the ingredient you want to replace.
func (r ApiGetIngredientSubstitutesRequest) IngredientName(ingredientName string) ApiGetIngredientSubstitutesRequest {
	r.ingredientName = &ingredientName
	return r
}

func (r ApiGetIngredientSubstitutesRequest) Execute() (*GetIngredientSubstitutes200Response, *http.Response, error) {
	return r.ApiService.GetIngredientSubstitutesExecute(r)
}

/*
GetIngredientSubstitutes Get Ingredient Substitutes

Search for substitutes for a given ingredient.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiGetIngredientSubstitutesRequest
*/
func (a *IngredientsAPIService) GetIngredientSubstitutes(ctx context.Context) ApiGetIngredientSubstitutesRequest {
	return ApiGetIngredientSubstitutesRequest{
		ApiService: a,
		ctx: ctx,
	}
}

// Execute executes the request
//  @return GetIngredientSubstitutes200Response
func (a *IngredientsAPIService) GetIngredientSubstitutesExecute(r ApiGetIngredientSubstitutesRequest) (*GetIngredientSubstitutes200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetIngredientSubstitutes200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.GetIngredientSubstitutes")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/substitutes"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.ingredientName == nil {
		return localVarReturnValue, nil, reportError("ingredientName is required and must be specified")
	}

	parameterAddToHeaderOrQuery(localVarQueryParams, "ingredientName", r.ingredientName, "")
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiGetIngredientSubstitutesByIDRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	id int32
}

func (r ApiGetIngredientSubstitutesByIDRequest) Execute() (*GetIngredientSubstitutes200Response, *http.Response, error) {
	return r.ApiService.GetIngredientSubstitutesByIDExecute(r)
}

/*
GetIngredientSubstitutesByID Get Ingredient Substitutes by ID

Search for substitutes for a given ingredient.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param id The id of the ingredient you want substitutes for.
 @return ApiGetIngredientSubstitutesByIDRequest
*/
func (a *IngredientsAPIService) GetIngredientSubstitutesByID(ctx context.Context, id int32) ApiGetIngredientSubstitutesByIDRequest {
	return ApiGetIngredientSubstitutesByIDRequest{
		ApiService: a,
		ctx: ctx,
		id: id,
	}
}

// Execute executes the request
//  @return GetIngredientSubstitutes200Response
func (a *IngredientsAPIService) GetIngredientSubstitutesByIDExecute(r ApiGetIngredientSubstitutesByIDRequest) (*GetIngredientSubstitutes200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *GetIngredientSubstitutes200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.GetIngredientSubstitutesByID")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/{id}/substitutes"
	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiIngredientSearchRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	query *string
	addChildren *bool
	minProteinPercent *float32
	maxProteinPercent *float32
	minFatPercent *float32
	maxFatPercent *float32
	minCarbsPercent *float32
	maxCarbsPercent *float32
	metaInformation *bool
	intolerances *string
	sort *string
	sortDirection *string
	offset *int32
	number *int32
	language *string
}

// The (natural language) search query.
func (r ApiIngredientSearchRequest) Query(query string) ApiIngredientSearchRequest {
	r.query = &query
	return r
}

// Whether to add children of found foods.
func (r ApiIngredientSearchRequest) AddChildren(addChildren bool) ApiIngredientSearchRequest {
	r.addChildren = &addChildren
	return r
}

// The minimum percentage of protein the food must have (between 0 and 100).
func (r ApiIngredientSearchRequest) MinProteinPercent(minProteinPercent float32) ApiIngredientSearchRequest {
	r.minProteinPercent = &minProteinPercent
	return r
}

// The maximum percentage of protein the food can have (between 0 and 100).
func (r ApiIngredientSearchRequest) MaxProteinPercent(maxProteinPercent float32) ApiIngredientSearchRequest {
	r.maxProteinPercent = &maxProteinPercent
	return r
}

// The minimum percentage of fat the food must have (between 0 and 100).
func (r ApiIngredientSearchRequest) MinFatPercent(minFatPercent float32) ApiIngredientSearchRequest {
	r.minFatPercent = &minFatPercent
	return r
}

// The maximum percentage of fat the food can have (between 0 and 100).
func (r ApiIngredientSearchRequest) MaxFatPercent(maxFatPercent float32) ApiIngredientSearchRequest {
	r.maxFatPercent = &maxFatPercent
	return r
}

// The minimum percentage of carbs the food must have (between 0 and 100).
func (r ApiIngredientSearchRequest) MinCarbsPercent(minCarbsPercent float32) ApiIngredientSearchRequest {
	r.minCarbsPercent = &minCarbsPercent
	return r
}

// The maximum percentage of carbs the food can have (between 0 and 100).
func (r ApiIngredientSearchRequest) MaxCarbsPercent(maxCarbsPercent float32) ApiIngredientSearchRequest {
	r.maxCarbsPercent = &maxCarbsPercent
	return r
}

// Whether to return more meta information about the ingredients.
func (r ApiIngredientSearchRequest) MetaInformation(metaInformation bool) ApiIngredientSearchRequest {
	r.metaInformation = &metaInformation
	return r
}

// A comma-separated list of intolerances. All recipes returned must not contain ingredients that are not suitable for people with the intolerances entered. See a full list of supported intolerances.
func (r ApiIngredientSearchRequest) Intolerances(intolerances string) ApiIngredientSearchRequest {
	r.intolerances = &intolerances
	return r
}

// The strategy to sort recipes by. See a full list of supported sorting options.
func (r ApiIngredientSearchRequest) Sort(sort string) ApiIngredientSearchRequest {
	r.sort = &sort
	return r
}

// The direction in which to sort. Must be either 'asc' (ascending) or 'desc' (descending).
func (r ApiIngredientSearchRequest) SortDirection(sortDirection string) ApiIngredientSearchRequest {
	r.sortDirection = &sortDirection
	return r
}

// The number of results to skip (between 0 and 900).
func (r ApiIngredientSearchRequest) Offset(offset int32) ApiIngredientSearchRequest {
	r.offset = &offset
	return r
}

// The maximum number of items to return (between 1 and 100). Defaults to 10.
func (r ApiIngredientSearchRequest) Number(number int32) ApiIngredientSearchRequest {
	r.number = &number
	return r
}

// The language of the input. Either 'en' or 'de'.
func (r ApiIngredientSearchRequest) Language(language string) ApiIngredientSearchRequest {
	r.language = &language
	return r
}

func (r ApiIngredientSearchRequest) Execute() (*IngredientSearch200Response, *http.Response, error) {
	return r.ApiService.IngredientSearchExecute(r)
}

/*
IngredientSearch Ingredient Search

Search for simple whole foods (e.g. fruits, vegetables, nuts, grains, meat, fish, dairy etc.).

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiIngredientSearchRequest
*/
func (a *IngredientsAPIService) IngredientSearch(ctx context.Context) ApiIngredientSearchRequest {
	return ApiIngredientSearchRequest{
		ApiService: a,
		ctx: ctx,
	}
}

// Execute executes the request
//  @return IngredientSearch200Response
func (a *IngredientsAPIService) IngredientSearchExecute(r ApiIngredientSearchRequest) (*IngredientSearch200Response, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *IngredientSearch200Response
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.IngredientSearch")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/search"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.query == nil {
		return localVarReturnValue, nil, reportError("query is required and must be specified")
	}

	parameterAddToHeaderOrQuery(localVarQueryParams, "query", r.query, "")
	if r.addChildren != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "addChildren", r.addChildren, "")
	}
	if r.minProteinPercent != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "minProteinPercent", r.minProteinPercent, "")
	}
	if r.maxProteinPercent != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "maxProteinPercent", r.maxProteinPercent, "")
	}
	if r.minFatPercent != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "minFatPercent", r.minFatPercent, "")
	}
	if r.maxFatPercent != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "maxFatPercent", r.maxFatPercent, "")
	}
	if r.minCarbsPercent != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "minCarbsPercent", r.minCarbsPercent, "")
	}
	if r.maxCarbsPercent != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "maxCarbsPercent", r.maxCarbsPercent, "")
	}
	if r.metaInformation != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "metaInformation", r.metaInformation, "")
	}
	if r.intolerances != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "intolerances", r.intolerances, "")
	}
	if r.sort != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "sort", r.sort, "")
	}
	if r.sortDirection != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "sortDirection", r.sortDirection, "")
	}
	if r.offset != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "offset", r.offset, "")
	}
	if r.number != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "number", r.number, "")
	} else {
		var defaultValue int32 = 10
		r.number = &defaultValue
	}
	if r.language != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "language", r.language, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiIngredientsByIDImageRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	id int32
	measure *string
}

// Whether the the measures should be 'us' or 'metric'.
func (r ApiIngredientsByIDImageRequest) Measure(measure string) ApiIngredientsByIDImageRequest {
	r.measure = &measure
	return r
}

func (r ApiIngredientsByIDImageRequest) Execute() (*os.File, *http.Response, error) {
	return r.ApiService.IngredientsByIDImageExecute(r)
}

/*
IngredientsByIDImage Ingredients by ID Image

Visualize a recipe's ingredient list.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @param id The recipe id.
 @return ApiIngredientsByIDImageRequest
*/
func (a *IngredientsAPIService) IngredientsByIDImage(ctx context.Context, id int32) ApiIngredientsByIDImageRequest {
	return ApiIngredientsByIDImageRequest{
		ApiService: a,
		ctx: ctx,
		id: id,
	}
}

// Execute executes the request
//  @return *os.File
func (a *IngredientsAPIService) IngredientsByIDImageExecute(r ApiIngredientsByIDImageRequest) (*os.File, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodGet
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  *os.File
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.IngredientsByIDImage")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/recipes/{id}/ingredientWidget.png"
	localVarPath = strings.Replace(localVarPath, "{"+"id"+"}", url.PathEscape(parameterValueToString(r.id, "id")), -1)

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}

	if r.measure != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "measure", r.measure, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"image/png"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiMapIngredientsToGroceryProductsRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	mapIngredientsToGroceryProductsRequest *MapIngredientsToGroceryProductsRequest
}

func (r ApiMapIngredientsToGroceryProductsRequest) MapIngredientsToGroceryProductsRequest(mapIngredientsToGroceryProductsRequest MapIngredientsToGroceryProductsRequest) ApiMapIngredientsToGroceryProductsRequest {
	r.mapIngredientsToGroceryProductsRequest = &mapIngredientsToGroceryProductsRequest
	return r
}

func (r ApiMapIngredientsToGroceryProductsRequest) Execute() ([]MapIngredientsToGroceryProducts200ResponseInner, *http.Response, error) {
	return r.ApiService.MapIngredientsToGroceryProductsExecute(r)
}

/*
MapIngredientsToGroceryProducts Map Ingredients to Grocery Products

Map a set of ingredients to products you can buy in the grocery store.

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiMapIngredientsToGroceryProductsRequest
*/
func (a *IngredientsAPIService) MapIngredientsToGroceryProducts(ctx context.Context) ApiMapIngredientsToGroceryProductsRequest {
	return ApiMapIngredientsToGroceryProductsRequest{
		ApiService: a,
		ctx: ctx,
	}
}

// Execute executes the request
//  @return []MapIngredientsToGroceryProducts200ResponseInner
func (a *IngredientsAPIService) MapIngredientsToGroceryProductsExecute(r ApiMapIngredientsToGroceryProductsRequest) ([]MapIngredientsToGroceryProducts200ResponseInner, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  []MapIngredientsToGroceryProducts200ResponseInner
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.MapIngredientsToGroceryProducts")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/food/ingredients/map"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.mapIngredientsToGroceryProductsRequest == nil {
		return localVarReturnValue, nil, reportError("mapIngredientsToGroceryProductsRequest is required and must be specified")
	}

	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/json"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"application/json"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	// body params
	localVarPostBody = r.mapIngredientsToGroceryProductsRequest
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}

type ApiVisualizeIngredientsRequest struct {
	ctx context.Context
	ApiService *IngredientsAPIService
	ingredientList *string
	servings *float32
	language *string
	measure *string
	view *string
	defaultCss *bool
	showBacklink *bool
}

// The ingredient list of the recipe, one ingredient per line (separate lines with \\\\n).
func (r ApiVisualizeIngredientsRequest) IngredientList(ingredientList string) ApiVisualizeIngredientsRequest {
	r.ingredientList = &ingredientList
	return r
}

// The number of servings.
func (r ApiVisualizeIngredientsRequest) Servings(servings float32) ApiVisualizeIngredientsRequest {
	r.servings = &servings
	return r
}

// The language of the input. Either 'en' or 'de'.
func (r ApiVisualizeIngredientsRequest) Language(language string) ApiVisualizeIngredientsRequest {
	r.language = &language
	return r
}

// The original system of measurement, either 'metric' or 'us'.
func (r ApiVisualizeIngredientsRequest) Measure(measure string) ApiVisualizeIngredientsRequest {
	r.measure = &measure
	return r
}

// How to visualize the ingredients, either 'grid' or 'list'.
func (r ApiVisualizeIngredientsRequest) View(view string) ApiVisualizeIngredientsRequest {
	r.view = &view
	return r
}

// Whether the default CSS should be added to the response.
func (r ApiVisualizeIngredientsRequest) DefaultCss(defaultCss bool) ApiVisualizeIngredientsRequest {
	r.defaultCss = &defaultCss
	return r
}

// Whether to show a backlink to spoonacular. If set false, this call counts against your quota.
func (r ApiVisualizeIngredientsRequest) ShowBacklink(showBacklink bool) ApiVisualizeIngredientsRequest {
	r.showBacklink = &showBacklink
	return r
}

func (r ApiVisualizeIngredientsRequest) Execute() (string, *http.Response, error) {
	return r.ApiService.VisualizeIngredientsExecute(r)
}

/*
VisualizeIngredients Ingredients Widget

Visualize ingredients of a recipe. You can play around with that endpoint!

 @param ctx context.Context - for authentication, logging, cancellation, deadlines, tracing, etc. Passed from http.Request or context.Background().
 @return ApiVisualizeIngredientsRequest
*/
func (a *IngredientsAPIService) VisualizeIngredients(ctx context.Context) ApiVisualizeIngredientsRequest {
	return ApiVisualizeIngredientsRequest{
		ApiService: a,
		ctx: ctx,
	}
}

// Execute executes the request
//  @return string
func (a *IngredientsAPIService) VisualizeIngredientsExecute(r ApiVisualizeIngredientsRequest) (string, *http.Response, error) {
	var (
		localVarHTTPMethod   = http.MethodPost
		localVarPostBody     interface{}
		formFiles            []formFile
		localVarReturnValue  string
	)

	localBasePath, err := a.client.cfg.ServerURLWithContext(r.ctx, "IngredientsAPIService.VisualizeIngredients")
	if err != nil {
		return localVarReturnValue, nil, &GenericOpenAPIError{error: err.Error()}
	}

	localVarPath := localBasePath + "/recipes/visualizeIngredients"

	localVarHeaderParams := make(map[string]string)
	localVarQueryParams := url.Values{}
	localVarFormParams := url.Values{}
	if r.ingredientList == nil {
		return localVarReturnValue, nil, reportError("ingredientList is required and must be specified")
	}
	if r.servings == nil {
		return localVarReturnValue, nil, reportError("servings is required and must be specified")
	}

	if r.language != nil {
		parameterAddToHeaderOrQuery(localVarQueryParams, "language", r.language, "")
	}
	// to determine the Content-Type header
	localVarHTTPContentTypes := []string{"application/x-www-form-urlencoded"}

	// set Content-Type header
	localVarHTTPContentType := selectHeaderContentType(localVarHTTPContentTypes)
	if localVarHTTPContentType != "" {
		localVarHeaderParams["Content-Type"] = localVarHTTPContentType
	}

	// to determine the Accept header
	localVarHTTPHeaderAccepts := []string{"text/html"}

	// set Accept header
	localVarHTTPHeaderAccept := selectHeaderAccept(localVarHTTPHeaderAccepts)
	if localVarHTTPHeaderAccept != "" {
		localVarHeaderParams["Accept"] = localVarHTTPHeaderAccept
	}
	parameterAddToHeaderOrQuery(localVarFormParams, "ingredientList", r.ingredientList, "")
	parameterAddToHeaderOrQuery(localVarFormParams, "servings", r.servings, "")
	if r.measure != nil {
		parameterAddToHeaderOrQuery(localVarFormParams, "measure", r.measure, "")
	}
	if r.view != nil {
		parameterAddToHeaderOrQuery(localVarFormParams, "view", r.view, "")
	}
	if r.defaultCss != nil {
		parameterAddToHeaderOrQuery(localVarFormParams, "defaultCss", r.defaultCss, "")
	}
	if r.showBacklink != nil {
		parameterAddToHeaderOrQuery(localVarFormParams, "showBacklink", r.showBacklink, "")
	}
	if r.ctx != nil {
		// API Key Authentication
		if auth, ok := r.ctx.Value(ContextAPIKeys).(map[string]APIKey); ok {
			if apiKey, ok := auth["apiKeyScheme"]; ok {
				var key string
				if apiKey.Prefix != "" {
					key = apiKey.Prefix + " " + apiKey.Key
				} else {
					key = apiKey.Key
				}
				localVarHeaderParams["x-api-key"] = key
			}
		}
	}
	req, err := a.client.prepareRequest(r.ctx, localVarPath, localVarHTTPMethod, localVarPostBody, localVarHeaderParams, localVarQueryParams, localVarFormParams, formFiles)
	if err != nil {
		return localVarReturnValue, nil, err
	}

	localVarHTTPResponse, err := a.client.callAPI(req)
	if err != nil || localVarHTTPResponse == nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	localVarBody, err := io.ReadAll(localVarHTTPResponse.Body)
	localVarHTTPResponse.Body.Close()
	localVarHTTPResponse.Body = io.NopCloser(bytes.NewBuffer(localVarBody))
	if err != nil {
		return localVarReturnValue, localVarHTTPResponse, err
	}

	if localVarHTTPResponse.StatusCode >= 300 {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: localVarHTTPResponse.Status,
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	err = a.client.decode(&localVarReturnValue, localVarBody, localVarHTTPResponse.Header.Get("Content-Type"))
	if err != nil {
		newErr := &GenericOpenAPIError{
			body:  localVarBody,
			error: err.Error(),
		}
		return localVarReturnValue, localVarHTTPResponse, newErr
	}

	return localVarReturnValue, localVarHTTPResponse, nil
}