/**
 * KADiCon API
 *
 *
 *
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */
/* tslint:disable:no-unused-variable member-ordering */

import { Inject, Injectable, Optional } from '@angular/core'
import {
	HttpClient,
	HttpHeaders,
	HttpParams,
	HttpResponse,
	HttpEvent,
	HttpParameterCodec,
	HttpContext,
} from '@angular/common/http'
import { CustomHttpParameterCodec } from '../encoder'
import { Observable } from 'rxjs'

// @ts-ignore
import { BillingProfileResponse } from '../model/billingProfileResponse'
// @ts-ignore
import { CategoryResponse } from '../model/categoryResponse'
// @ts-ignore
import { CheckinRequest } from '../model/checkinRequest'
// @ts-ignore
import { CompanyResponse } from '../model/companyResponse'
// @ts-ignore
import { CountryResponse } from '../model/countryResponse'
// @ts-ignore
import { CreateBillingProfileRequest } from '../model/createBillingProfileRequest'
// @ts-ignore
import { CreateBillingProfileResponse } from '../model/createBillingProfileResponse'
// @ts-ignore
import { CreateCategoryRequest } from '../model/createCategoryRequest'
// @ts-ignore
import { CreateMenuItemRequest } from '../model/createMenuItemRequest'
// @ts-ignore
import { CreateOrderItemRequest } from '../model/createOrderItemRequest'
// @ts-ignore
import { CreateReservationRequest } from '../model/createReservationRequest'
// @ts-ignore
import { CreateTableCombinationRequest } from '../model/createTableCombinationRequest'
// @ts-ignore
import { CreateTenantWithUserRequest } from '../model/createTenantWithUserRequest'
// @ts-ignore
import { CreateUserRequest } from '../model/createUserRequest'
// @ts-ignore
import { CurrencyResponse } from '../model/currencyResponse'
// @ts-ignore
import { CustomerData } from '../model/customerData'
// @ts-ignore
import { DashboardMessageView } from '../model/dashboardMessageView'
// @ts-ignore
import { DashboardTableView } from '../model/dashboardTableView'
// @ts-ignore
import { FileUploadResponse } from '../model/fileUploadResponse'
// @ts-ignore
import { FindAvailableTablesByTimeSlotResponse } from '../model/findAvailableTablesByTimeSlotResponse'
// @ts-ignore
import { FreeTableCountResponse } from '../model/freeTableCountResponse'
// @ts-ignore
import { HealthControllerCheck200Response } from '../model/healthControllerCheck200Response'
// @ts-ignore
import { HealthControllerCheck503Response } from '../model/healthControllerCheck503Response'
// @ts-ignore
import { ImportMenuItemRequest } from '../model/importMenuItemRequest'
// @ts-ignore
import { LoginRequest } from '../model/loginRequest'
// @ts-ignore
import { LoginResponse } from '../model/loginResponse'
// @ts-ignore
import { MenuItemResponse } from '../model/menuItemResponse'
// @ts-ignore
import { MessageResponse } from '../model/messageResponse'
// @ts-ignore
import { OrderResponse } from '../model/orderResponse'
// @ts-ignore
import { PayOrderItemRequest } from '../model/payOrderItemRequest'
// @ts-ignore
import { RequestResetPasswordRequest } from '../model/requestResetPasswordRequest'
// @ts-ignore
import { ReservationResponse } from '../model/reservationResponse'
// @ts-ignore
import { ResetPasswordRequest } from '../model/resetPasswordRequest'
// @ts-ignore
import { SaveSettingsRequest } from '../model/saveSettingsRequest'
// @ts-ignore
import { SaveTableRequest } from '../model/saveTableRequest'
// @ts-ignore
import { SendMessageRequest } from '../model/sendMessageRequest'
// @ts-ignore
import { SettingsResponse } from '../model/settingsResponse'
// @ts-ignore
import { StatisticsResponse } from '../model/statisticsResponse'
// @ts-ignore
import { TableCombinationResponse } from '../model/tableCombinationResponse'
// @ts-ignore
import { TableGraphResponse } from '../model/tableGraphResponse'
// @ts-ignore
import { TableResponse } from '../model/tableResponse'
// @ts-ignore
import { TimeSlot } from '../model/timeSlot'
// @ts-ignore
import { TimezoneResponse } from '../model/timezoneResponse'
// @ts-ignore
import { ToggleArchiveRequest } from '../model/toggleArchiveRequest'
// @ts-ignore
import { ToggleVisibleRequest } from '../model/toggleVisibleRequest'
// @ts-ignore
import { UpdateCategoryRequest } from '../model/updateCategoryRequest'
// @ts-ignore
import { UpdateItemsStateRequest } from '../model/updateItemsStateRequest'
// @ts-ignore
import { UpdateMenuItemRequest } from '../model/updateMenuItemRequest'
// @ts-ignore
import { UpdateMessagingTokenRequest } from '../model/updateMessagingTokenRequest'
// @ts-ignore
import { UpdatePasswordRequest } from '../model/updatePasswordRequest'
// @ts-ignore
import { UpdateReservationRequest } from '../model/updateReservationRequest'
// @ts-ignore
import { UpdateSortOrderRequest } from '../model/updateSortOrderRequest'
// @ts-ignore
import { UpdateUserRequest } from '../model/updateUserRequest'
// @ts-ignore
import { UserResponse } from '../model/userResponse'
// @ts-ignore
import { VerifyEmailRequest } from '../model/verifyEmailRequest'
// @ts-ignore
import { VerifyTokenRequest } from '../model/verifyTokenRequest'
// @ts-ignore
import { VerifyTokenResponse } from '../model/verifyTokenResponse'

// @ts-ignore
import { BASE_PATH, COLLECTION_FORMATS } from '../variables'
import { Configuration } from '../configuration'
import { BaseService } from '../api.base.service'

@Injectable({
	providedIn: 'root',
})
export class DefaultService extends BaseService {
	constructor(
		protected httpClient: HttpClient,
		@Optional() @Inject(BASE_PATH) basePath: string | string[],
		@Optional() configuration?: Configuration,
	) {
		super(basePath, configuration)
	}

	/**
	 * @param loginRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public authControllerLogin(
		loginRequest: LoginRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<LoginResponse>
	public authControllerLogin(
		loginRequest: LoginRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<LoginResponse>>
	public authControllerLogin(
		loginRequest: LoginRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<LoginResponse>>
	public authControllerLogin(
		loginRequest: LoginRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (loginRequest === null || loginRequest === undefined) {
			throw new Error('Required parameter loginRequest was null or undefined when calling authControllerLogin.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/auth/login`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<LoginResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: loginRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param resetPasswordRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public authControllerResetPassword(
		resetPasswordRequest: ResetPasswordRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public authControllerResetPassword(
		resetPasswordRequest: ResetPasswordRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public authControllerResetPassword(
		resetPasswordRequest: ResetPasswordRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public authControllerResetPassword(
		resetPasswordRequest: ResetPasswordRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (resetPasswordRequest === null || resetPasswordRequest === undefined) {
			throw new Error(
				'Required parameter resetPasswordRequest was null or undefined when calling authControllerResetPassword.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/auth/password/reset/new`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: resetPasswordRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param requestResetPasswordRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public authControllerSendResetPasswordEmail(
		requestResetPasswordRequest: RequestResetPasswordRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public authControllerSendResetPasswordEmail(
		requestResetPasswordRequest: RequestResetPasswordRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public authControllerSendResetPasswordEmail(
		requestResetPasswordRequest: RequestResetPasswordRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public authControllerSendResetPasswordEmail(
		requestResetPasswordRequest: RequestResetPasswordRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (requestResetPasswordRequest === null || requestResetPasswordRequest === undefined) {
			throw new Error(
				'Required parameter requestResetPasswordRequest was null or undefined when calling authControllerSendResetPasswordEmail.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/auth/password/reset`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: requestResetPasswordRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param updatePasswordRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public authControllerUpdatePassword(
		updatePasswordRequest: UpdatePasswordRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public authControllerUpdatePassword(
		updatePasswordRequest: UpdatePasswordRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public authControllerUpdatePassword(
		updatePasswordRequest: UpdatePasswordRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public authControllerUpdatePassword(
		updatePasswordRequest: UpdatePasswordRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (updatePasswordRequest === null || updatePasswordRequest === undefined) {
			throw new Error(
				'Required parameter updatePasswordRequest was null or undefined when calling authControllerUpdatePassword.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/auth/password`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updatePasswordRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param verifyEmailRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public authControllerVerifyEmail(
		verifyEmailRequest: VerifyEmailRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public authControllerVerifyEmail(
		verifyEmailRequest: VerifyEmailRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public authControllerVerifyEmail(
		verifyEmailRequest: VerifyEmailRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public authControllerVerifyEmail(
		verifyEmailRequest: VerifyEmailRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (verifyEmailRequest === null || verifyEmailRequest === undefined) {
			throw new Error(
				'Required parameter verifyEmailRequest was null or undefined when calling authControllerVerifyEmail.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/auth/verify`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: verifyEmailRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param verifyTokenRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public authControllerVerifyEmailToken(
		verifyTokenRequest: VerifyTokenRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<VerifyTokenResponse>
	public authControllerVerifyEmailToken(
		verifyTokenRequest: VerifyTokenRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<VerifyTokenResponse>>
	public authControllerVerifyEmailToken(
		verifyTokenRequest: VerifyTokenRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<VerifyTokenResponse>>
	public authControllerVerifyEmailToken(
		verifyTokenRequest: VerifyTokenRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (verifyTokenRequest === null || verifyTokenRequest === undefined) {
			throw new Error(
				'Required parameter verifyTokenRequest was null or undefined when calling authControllerVerifyEmailToken.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/auth/verify/token`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<VerifyTokenResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: verifyTokenRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * Create a billing profile for the current tenant
	 * @param createBillingProfileRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public billingControllerCreateBillingProfile(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CreateBillingProfileResponse>
	public billingControllerCreateBillingProfile(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CreateBillingProfileResponse>>
	public billingControllerCreateBillingProfile(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CreateBillingProfileResponse>>
	public billingControllerCreateBillingProfile(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createBillingProfileRequest === null || createBillingProfileRequest === undefined) {
			throw new Error(
				'Required parameter createBillingProfileRequest was null or undefined when calling billingControllerCreateBillingProfile.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/billing/profile`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CreateBillingProfileResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createBillingProfileRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * Get the billing profile for the current tenant
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public billingControllerFindBillingProfile(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<BillingProfileResponse>
	public billingControllerFindBillingProfile(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<BillingProfileResponse>>
	public billingControllerFindBillingProfile(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<BillingProfileResponse>>
	public billingControllerFindBillingProfile(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/billing/profile`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<BillingProfileResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * Get the onboarding URL for the current tenant
	 * @param createBillingProfileRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public billingControllerGetOnBoardingUrl(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CreateBillingProfileResponse>
	public billingControllerGetOnBoardingUrl(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CreateBillingProfileResponse>>
	public billingControllerGetOnBoardingUrl(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CreateBillingProfileResponse>>
	public billingControllerGetOnBoardingUrl(
		createBillingProfileRequest: CreateBillingProfileRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createBillingProfileRequest === null || createBillingProfileRequest === undefined) {
			throw new Error(
				'Required parameter createBillingProfileRequest was null or undefined when calling billingControllerGetOnBoardingUrl.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/billing/profile/onboarding`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CreateBillingProfileResponse>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createBillingProfileRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public dashboardControllerGetMessagesView(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<DashboardMessageView>>
	public dashboardControllerGetMessagesView(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<DashboardMessageView>>>
	public dashboardControllerGetMessagesView(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<DashboardMessageView>>>
	public dashboardControllerGetMessagesView(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/dashboard/message`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<DashboardMessageView>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public dashboardControllerGetTablesView(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<DashboardTableView>>
	public dashboardControllerGetTablesView(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<DashboardTableView>>>
	public dashboardControllerGetTablesView(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<DashboardTableView>>>
	public dashboardControllerGetTablesView(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/dashboard/table`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<DashboardTableView>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public healthControllerCheck(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HealthControllerCheck200Response>
	public healthControllerCheck(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<HealthControllerCheck200Response>>
	public healthControllerCheck(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<HealthControllerCheck200Response>>
	public healthControllerCheck(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/health`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<HealthControllerCheck200Response>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param createCategoryRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerCreateCategory(
		createCategoryRequest: CreateCategoryRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CategoryResponse>
	public menuControllerCreateCategory(
		createCategoryRequest: CreateCategoryRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CategoryResponse>>
	public menuControllerCreateCategory(
		createCategoryRequest: CreateCategoryRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CategoryResponse>>
	public menuControllerCreateCategory(
		createCategoryRequest: CreateCategoryRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createCategoryRequest === null || createCategoryRequest === undefined) {
			throw new Error(
				'Required parameter createCategoryRequest was null or undefined when calling menuControllerCreateCategory.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CategoryResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createCategoryRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param createMenuItemRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerCreateItem(
		createMenuItemRequest: CreateMenuItemRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<MenuItemResponse>
	public menuControllerCreateItem(
		createMenuItemRequest: CreateMenuItemRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<MenuItemResponse>>
	public menuControllerCreateItem(
		createMenuItemRequest: CreateMenuItemRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<MenuItemResponse>>
	public menuControllerCreateItem(
		createMenuItemRequest: CreateMenuItemRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createMenuItemRequest === null || createMenuItemRequest === undefined) {
			throw new Error(
				'Required parameter createMenuItemRequest was null or undefined when calling menuControllerCreateItem.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<MenuItemResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createMenuItemRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerDeleteCategoryById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerDeleteCategoryById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerDeleteCategoryById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerDeleteCategoryById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerDeleteCategoryById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerDeleteItemById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerDeleteItemById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerDeleteItemById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerDeleteItemById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerDeleteItemById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerFindAllCategories(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<CategoryResponse>>
	public menuControllerFindAllCategories(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<CategoryResponse>>>
	public menuControllerFindAllCategories(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<CategoryResponse>>>
	public menuControllerFindAllCategories(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<CategoryResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerFindAllItem(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<MenuItemResponse>>
	public menuControllerFindAllItem(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<MenuItemResponse>>>
	public menuControllerFindAllItem(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<MenuItemResponse>>>
	public menuControllerFindAllItem(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<MenuItemResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerFindCategoryById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CategoryResponse>
	public menuControllerFindCategoryById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CategoryResponse>>
	public menuControllerFindCategoryById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CategoryResponse>>
	public menuControllerFindCategoryById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerFindCategoryById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CategoryResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerFindItemById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<MenuItemResponse>
	public menuControllerFindItemById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<MenuItemResponse>>
	public menuControllerFindItemById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<MenuItemResponse>>
	public menuControllerFindItemById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerFindItemById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<MenuItemResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param importMenuItemRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerImport(
		importMenuItemRequest: Array<ImportMenuItemRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerImport(
		importMenuItemRequest: Array<ImportMenuItemRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerImport(
		importMenuItemRequest: Array<ImportMenuItemRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerImport(
		importMenuItemRequest: Array<ImportMenuItemRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (importMenuItemRequest === null || importMenuItemRequest === undefined) {
			throw new Error(
				'Required parameter importMenuItemRequest was null or undefined when calling menuControllerImport.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/import`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: importMenuItemRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param toggleArchiveRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerToggleCategoryArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerToggleCategoryArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerToggleCategoryArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerToggleCategoryArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerToggleCategoryArchive.')
		}
		if (toggleArchiveRequest === null || toggleArchiveRequest === undefined) {
			throw new Error(
				'Required parameter toggleArchiveRequest was null or undefined when calling menuControllerToggleCategoryArchive.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/archive`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: toggleArchiveRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param toggleVisibleRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerToggleCategoryVisible(
		id: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerToggleCategoryVisible(
		id: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerToggleCategoryVisible(
		id: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerToggleCategoryVisible(
		id: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerToggleCategoryVisible.')
		}
		if (toggleVisibleRequest === null || toggleVisibleRequest === undefined) {
			throw new Error(
				'Required parameter toggleVisibleRequest was null or undefined when calling menuControllerToggleCategoryVisible.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/visible`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: toggleVisibleRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param toggleArchiveRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerToggleItemArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerToggleItemArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerToggleItemArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerToggleItemArchive(
		id: string,
		toggleArchiveRequest: ToggleArchiveRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerToggleItemArchive.')
		}
		if (toggleArchiveRequest === null || toggleArchiveRequest === undefined) {
			throw new Error(
				'Required parameter toggleArchiveRequest was null or undefined when calling menuControllerToggleItemArchive.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/archive`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: toggleArchiveRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param categoryId
	 * @param toggleVisibleRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerToggleItemVisible(
		id: string,
		categoryId: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerToggleItemVisible(
		id: string,
		categoryId: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerToggleItemVisible(
		id: string,
		categoryId: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerToggleItemVisible(
		id: string,
		categoryId: string,
		toggleVisibleRequest: ToggleVisibleRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerToggleItemVisible.')
		}
		if (categoryId === null || categoryId === undefined) {
			throw new Error(
				'Required parameter categoryId was null or undefined when calling menuControllerToggleItemVisible.',
			)
		}
		if (toggleVisibleRequest === null || toggleVisibleRequest === undefined) {
			throw new Error(
				'Required parameter toggleVisibleRequest was null or undefined when calling menuControllerToggleItemVisible.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/visible/${this.configuration.encodeParam({ name: 'categoryId', value: categoryId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: toggleVisibleRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param updateCategoryRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerUpdateCategoryById(
		id: string,
		updateCategoryRequest: UpdateCategoryRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CategoryResponse>
	public menuControllerUpdateCategoryById(
		id: string,
		updateCategoryRequest: UpdateCategoryRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CategoryResponse>>
	public menuControllerUpdateCategoryById(
		id: string,
		updateCategoryRequest: UpdateCategoryRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CategoryResponse>>
	public menuControllerUpdateCategoryById(
		id: string,
		updateCategoryRequest: UpdateCategoryRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerUpdateCategoryById.')
		}
		if (updateCategoryRequest === null || updateCategoryRequest === undefined) {
			throw new Error(
				'Required parameter updateCategoryRequest was null or undefined when calling menuControllerUpdateCategoryById.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CategoryResponse>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateCategoryRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param updateSortOrderRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerUpdateCategorySortOrder(
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerUpdateCategorySortOrder(
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerUpdateCategorySortOrder(
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerUpdateCategorySortOrder(
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (updateSortOrderRequest === null || updateSortOrderRequest === undefined) {
			throw new Error(
				'Required parameter updateSortOrderRequest was null or undefined when calling menuControllerUpdateCategorySortOrder.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/category/sort`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateSortOrderRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param updateMenuItemRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerUpdateItemById(
		id: string,
		updateMenuItemRequest: UpdateMenuItemRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<MenuItemResponse>
	public menuControllerUpdateItemById(
		id: string,
		updateMenuItemRequest: UpdateMenuItemRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<MenuItemResponse>>
	public menuControllerUpdateItemById(
		id: string,
		updateMenuItemRequest: UpdateMenuItemRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<MenuItemResponse>>
	public menuControllerUpdateItemById(
		id: string,
		updateMenuItemRequest: UpdateMenuItemRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling menuControllerUpdateItemById.')
		}
		if (updateMenuItemRequest === null || updateMenuItemRequest === undefined) {
			throw new Error(
				'Required parameter updateMenuItemRequest was null or undefined when calling menuControllerUpdateItemById.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<MenuItemResponse>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateMenuItemRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param categoryId
	 * @param updateSortOrderRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public menuControllerUpdateItemSortOrder(
		categoryId: string,
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public menuControllerUpdateItemSortOrder(
		categoryId: string,
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public menuControllerUpdateItemSortOrder(
		categoryId: string,
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public menuControllerUpdateItemSortOrder(
		categoryId: string,
		updateSortOrderRequest: Array<UpdateSortOrderRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (categoryId === null || categoryId === undefined) {
			throw new Error(
				'Required parameter categoryId was null or undefined when calling menuControllerUpdateItemSortOrder.',
			)
		}
		if (updateSortOrderRequest === null || updateSortOrderRequest === undefined) {
			throw new Error(
				'Required parameter updateSortOrderRequest was null or undefined when calling menuControllerUpdateItemSortOrder.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/menu/item/sort/${this.configuration.encodeParam({ name: 'categoryId', value: categoryId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateSortOrderRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public messageControllerAcknowledge(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public messageControllerAcknowledge(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public messageControllerAcknowledge(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public messageControllerAcknowledge(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling messageControllerAcknowledge.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/message/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/acknowledge`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param date
	 * @param tableIds
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public messageControllerFindAll(
		date?: Date,
		tableIds?: Array<string>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<MessageResponse>>
	public messageControllerFindAll(
		date?: Date,
		tableIds?: Array<string>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<MessageResponse>>>
	public messageControllerFindAll(
		date?: Date,
		tableIds?: Array<string>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<MessageResponse>>>
	public messageControllerFindAll(
		date?: Date,
		tableIds?: Array<string>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>date, 'date')
		if (tableIds) {
			tableIds.forEach((element) => {
				localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>element, 'tableIds')
			})
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/message`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<MessageResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param sendMessageRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public messageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<MessageResponse>
	public messageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<MessageResponse>>
	public messageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<MessageResponse>>
	public messageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (sendMessageRequest === null || sendMessageRequest === undefined) {
			throw new Error('Required parameter sendMessageRequest was null or undefined when calling messageControllerSend.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/message`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<MessageResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: sendMessageRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param createOrderItemRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerAddOrderItems(
		orderId: string,
		createOrderItemRequest: Array<CreateOrderItemRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<OrderResponse>
	public orderControllerAddOrderItems(
		orderId: string,
		createOrderItemRequest: Array<CreateOrderItemRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<OrderResponse>>
	public orderControllerAddOrderItems(
		orderId: string,
		createOrderItemRequest: Array<CreateOrderItemRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<OrderResponse>>
	public orderControllerAddOrderItems(
		orderId: string,
		createOrderItemRequest: Array<CreateOrderItemRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerAddOrderItems.')
		}
		if (createOrderItemRequest === null || createOrderItemRequest === undefined) {
			throw new Error(
				'Required parameter createOrderItemRequest was null or undefined when calling orderControllerAddOrderItems.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/items`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<OrderResponse>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createOrderItemRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerCancel(
		orderId: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public orderControllerCancel(
		orderId: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public orderControllerCancel(
		orderId: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public orderControllerCancel(
		orderId: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerCancel.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/cancel`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param checkinRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<OrderResponse>
	public orderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<OrderResponse>>
	public orderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<OrderResponse>>
	public orderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (checkinRequest === null || checkinRequest === undefined) {
			throw new Error('Required parameter checkinRequest was null or undefined when calling orderControllerCheckin.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<OrderResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: checkinRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerCheckout(
		orderId: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public orderControllerCheckout(
		orderId: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public orderControllerCheckout(
		orderId: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public orderControllerCheckout(
		orderId: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerCheckout.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/checkout`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerFindAllOpenOrder(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<OrderResponse>>
	public orderControllerFindAllOpenOrder(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<OrderResponse>>>
	public orderControllerFindAllOpenOrder(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<OrderResponse>>>
	public orderControllerFindAllOpenOrder(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/open`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<OrderResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param reservationIds
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerFindOrdersByReservationIds(
		reservationIds: Array<string>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<OrderResponse>>
	public orderControllerFindOrdersByReservationIds(
		reservationIds: Array<string>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<OrderResponse>>>
	public orderControllerFindOrdersByReservationIds(
		reservationIds: Array<string>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<OrderResponse>>>
	public orderControllerFindOrdersByReservationIds(
		reservationIds: Array<string>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (reservationIds === null || reservationIds === undefined) {
			throw new Error(
				'Required parameter reservationIds was null or undefined when calling orderControllerFindOrdersByReservationIds.',
			)
		}

		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		if (reservationIds) {
			reservationIds.forEach((element) => {
				localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>element, 'reservationIds')
			})
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/reservation`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<OrderResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param payOrderItemRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public orderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public orderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public orderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerPayItemsViaCash.')
		}
		if (payOrderItemRequest === null || payOrderItemRequest === undefined) {
			throw new Error(
				'Required parameter payOrderItemRequest was null or undefined when calling orderControllerPayItemsViaCash.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/pay`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: payOrderItemRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerReOpenOrder(
		orderId: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public orderControllerReOpenOrder(
		orderId: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public orderControllerReOpenOrder(
		orderId: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public orderControllerReOpenOrder(
		orderId: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerReOpenOrder.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/open`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param itemId
	 * @param course
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerUpdateItemCourse(
		orderId: string,
		itemId: string,
		course: number,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public orderControllerUpdateItemCourse(
		orderId: string,
		itemId: string,
		course: number,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public orderControllerUpdateItemCourse(
		orderId: string,
		itemId: string,
		course: number,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public orderControllerUpdateItemCourse(
		orderId: string,
		itemId: string,
		course: number,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerUpdateItemCourse.')
		}
		if (itemId === null || itemId === undefined) {
			throw new Error('Required parameter itemId was null or undefined when calling orderControllerUpdateItemCourse.')
		}
		if (course === null || course === undefined) {
			throw new Error('Required parameter course was null or undefined when calling orderControllerUpdateItemCourse.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/items/${this.configuration.encodeParam({ name: 'itemId', value: itemId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/course/${this.configuration.encodeParam({ name: 'course', value: course, in: 'path', style: 'simple', explode: false, dataType: 'number', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderId
	 * @param updateItemsStateRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public orderControllerUpdateItemsState(
		orderId: string,
		updateItemsStateRequest: UpdateItemsStateRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public orderControllerUpdateItemsState(
		orderId: string,
		updateItemsStateRequest: UpdateItemsStateRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public orderControllerUpdateItemsState(
		orderId: string,
		updateItemsStateRequest: UpdateItemsStateRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public orderControllerUpdateItemsState(
		orderId: string,
		updateItemsStateRequest: UpdateItemsStateRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderId === null || orderId === undefined) {
			throw new Error('Required parameter orderId was null or undefined when calling orderControllerUpdateItemsState.')
		}
		if (updateItemsStateRequest === null || updateItemsStateRequest === undefined) {
			throw new Error(
				'Required parameter updateItemsStateRequest was null or undefined when calling orderControllerUpdateItemsState.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/order/${this.configuration.encodeParam({ name: 'orderId', value: orderId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/items/state`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateItemsStateRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerConfirmReservation(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public reservationControllerConfirmReservation(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public reservationControllerConfirmReservation(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public reservationControllerConfirmReservation(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error(
				'Required parameter id was null or undefined when calling reservationControllerConfirmReservation.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/confirm`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param createReservationRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<ReservationResponse>
	public reservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<ReservationResponse>>
	public reservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<ReservationResponse>>
	public reservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createReservationRequest === null || createReservationRequest === undefined) {
			throw new Error(
				'Required parameter createReservationRequest was null or undefined when calling reservationControllerCreate.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<ReservationResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createReservationRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param date
	 * @param tableIds
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerFindAll(
		date?: Date,
		tableIds?: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<ReservationResponse>>
	public reservationControllerFindAll(
		date?: Date,
		tableIds?: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<ReservationResponse>>>
	public reservationControllerFindAll(
		date?: Date,
		tableIds?: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<ReservationResponse>>>
	public reservationControllerFindAll(
		date?: Date,
		tableIds?: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>date, 'date')
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>tableIds, 'tableIds')

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<ReservationResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param date
	 * @param tableIds
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerFindAllOpen(
		date?: Date,
		tableIds?: Array<string>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<ReservationResponse>>
	public reservationControllerFindAllOpen(
		date?: Date,
		tableIds?: Array<string>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<ReservationResponse>>>
	public reservationControllerFindAllOpen(
		date?: Date,
		tableIds?: Array<string>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<ReservationResponse>>>
	public reservationControllerFindAllOpen(
		date?: Date,
		tableIds?: Array<string>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>date, 'date')
		if (tableIds) {
			tableIds.forEach((element) => {
				localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>element, 'tableIds')
			})
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/open`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<ReservationResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerFindById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<ReservationResponse>
	public reservationControllerFindById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<ReservationResponse>>
	public reservationControllerFindById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<ReservationResponse>>
	public reservationControllerFindById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling reservationControllerFindById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<ReservationResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param orderIds
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerFindByOrderIds(
		orderIds: Array<string>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<ReservationResponse>>
	public reservationControllerFindByOrderIds(
		orderIds: Array<string>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<ReservationResponse>>>
	public reservationControllerFindByOrderIds(
		orderIds: Array<string>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<ReservationResponse>>>
	public reservationControllerFindByOrderIds(
		orderIds: Array<string>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (orderIds === null || orderIds === undefined) {
			throw new Error(
				'Required parameter orderIds was null or undefined when calling reservationControllerFindByOrderIds.',
			)
		}

		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		if (orderIds) {
			orderIds.forEach((element) => {
				localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>element, 'orderIds')
			})
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/order`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<ReservationResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerFreeTableCount(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<FreeTableCountResponse>
	public reservationControllerFreeTableCount(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<FreeTableCountResponse>>
	public reservationControllerFreeTableCount(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<FreeTableCountResponse>>
	public reservationControllerFreeTableCount(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/tables/free`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<FreeTableCountResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param date
	 * @param timezone
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TimeSlot>>
	public reservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TimeSlot>>>
	public reservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TimeSlot>>>
	public reservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (date === null || date === undefined) {
			throw new Error(
				'Required parameter date was null or undefined when calling reservationControllerGetTimeSlotsByDate.',
			)
		}

		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>timezone, 'timezone')

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/slots/${this.configuration.encodeParam({ name: 'date', value: date, in: 'path', style: 'simple', explode: false, dataType: 'Date', dataFormat: 'date-time' })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<TimeSlot>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerRejectReservation(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public reservationControllerRejectReservation(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public reservationControllerRejectReservation(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public reservationControllerRejectReservation(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error(
				'Required parameter id was null or undefined when calling reservationControllerRejectReservation.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/reject`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param query
	 * @param open
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerSearchByQuery(
		query: string,
		open?: boolean,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<ReservationResponse>>
	public reservationControllerSearchByQuery(
		query: string,
		open?: boolean,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<ReservationResponse>>>
	public reservationControllerSearchByQuery(
		query: string,
		open?: boolean,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<ReservationResponse>>>
	public reservationControllerSearchByQuery(
		query: string,
		open?: boolean,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (query === null || query === undefined) {
			throw new Error('Required parameter query was null or undefined when calling reservationControllerSearchByQuery.')
		}

		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>open, 'open')

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/search/${this.configuration.encodeParam({ name: 'query', value: query, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<ReservationResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param field
	 * @param query
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerSearchCustomers(
		field: string,
		query: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<CustomerData>>
	public reservationControllerSearchCustomers(
		field: string,
		query: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<CustomerData>>>
	public reservationControllerSearchCustomers(
		field: string,
		query: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<CustomerData>>>
	public reservationControllerSearchCustomers(
		field: string,
		query: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (field === null || field === undefined) {
			throw new Error(
				'Required parameter field was null or undefined when calling reservationControllerSearchCustomers.',
			)
		}
		if (query === null || query === undefined) {
			throw new Error(
				'Required parameter query was null or undefined when calling reservationControllerSearchCustomers.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/customer/${this.configuration.encodeParam({ name: 'field', value: field, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/${this.configuration.encodeParam({ name: 'query', value: query, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<CustomerData>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerSendReviewEmail(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public reservationControllerSendReviewEmail(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public reservationControllerSendReviewEmail(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public reservationControllerSendReviewEmail(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling reservationControllerSendReviewEmail.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/review`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerUnConfirmReservation(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public reservationControllerUnConfirmReservation(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public reservationControllerUnConfirmReservation(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public reservationControllerUnConfirmReservation(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error(
				'Required parameter id was null or undefined when calling reservationControllerUnConfirmReservation.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/unconfirm`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('patch', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param updateReservationRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public reservationControllerUpdate(
		id: string,
		updateReservationRequest: UpdateReservationRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<ReservationResponse>
	public reservationControllerUpdate(
		id: string,
		updateReservationRequest: UpdateReservationRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<ReservationResponse>>
	public reservationControllerUpdate(
		id: string,
		updateReservationRequest: UpdateReservationRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<ReservationResponse>>
	public reservationControllerUpdate(
		id: string,
		updateReservationRequest: UpdateReservationRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling reservationControllerUpdate.')
		}
		if (updateReservationRequest === null || updateReservationRequest === undefined) {
			throw new Error(
				'Required parameter updateReservationRequest was null or undefined when calling reservationControllerUpdate.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/reservation/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<ReservationResponse>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateReservationRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param userId
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerFindAllSubscribedTablesByUserId(
		userId: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TableResponse>>
	public roomPlanControllerFindAllSubscribedTablesByUserId(
		userId: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TableResponse>>>
	public roomPlanControllerFindAllSubscribedTablesByUserId(
		userId: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TableResponse>>>
	public roomPlanControllerFindAllSubscribedTablesByUserId(
		userId: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (userId === null || userId === undefined) {
			throw new Error(
				'Required parameter userId was null or undefined when calling roomPlanControllerFindAllSubscribedTablesByUserId.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/subscriptions/${this.configuration.encodeParam({ name: 'userId', value: userId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<TableResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerFindAllTableCombinations(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TableCombinationResponse>>
	public roomPlanControllerFindAllTableCombinations(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TableCombinationResponse>>>
	public roomPlanControllerFindAllTableCombinations(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TableCombinationResponse>>>
	public roomPlanControllerFindAllTableCombinations(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table/combination`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<TableCombinationResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerFindAllTables(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TableResponse>>
	public roomPlanControllerFindAllTables(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TableResponse>>>
	public roomPlanControllerFindAllTables(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TableResponse>>>
	public roomPlanControllerFindAllTables(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<TableResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param type
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerFindAvailableTableById(
		id: string,
		type: 'Table' | 'TableCombination',
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<FindAvailableTablesByTimeSlotResponse>
	public roomPlanControllerFindAvailableTableById(
		id: string,
		type: 'Table' | 'TableCombination',
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<FindAvailableTablesByTimeSlotResponse>>
	public roomPlanControllerFindAvailableTableById(
		id: string,
		type: 'Table' | 'TableCombination',
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<FindAvailableTablesByTimeSlotResponse>>
	public roomPlanControllerFindAvailableTableById(
		id: string,
		type: 'Table' | 'TableCombination',
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error(
				'Required parameter id was null or undefined when calling roomPlanControllerFindAvailableTableById.',
			)
		}
		if (type === null || type === undefined) {
			throw new Error(
				'Required parameter type was null or undefined when calling roomPlanControllerFindAvailableTableById.',
			)
		}

		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>id, 'id')
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>type, 'type')

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table/available`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<FindAvailableTablesByTimeSlotResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param start
	 * @param end
	 * @param noOfPersons
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerFindAvailableTablesByTimeSlot(
		start: Date,
		end: Date,
		noOfPersons: number,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<FindAvailableTablesByTimeSlotResponse>>
	public roomPlanControllerFindAvailableTablesByTimeSlot(
		start: Date,
		end: Date,
		noOfPersons: number,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<FindAvailableTablesByTimeSlotResponse>>>
	public roomPlanControllerFindAvailableTablesByTimeSlot(
		start: Date,
		end: Date,
		noOfPersons: number,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<FindAvailableTablesByTimeSlotResponse>>>
	public roomPlanControllerFindAvailableTablesByTimeSlot(
		start: Date,
		end: Date,
		noOfPersons: number,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (start === null || start === undefined) {
			throw new Error(
				'Required parameter start was null or undefined when calling roomPlanControllerFindAvailableTablesByTimeSlot.',
			)
		}
		if (end === null || end === undefined) {
			throw new Error(
				'Required parameter end was null or undefined when calling roomPlanControllerFindAvailableTablesByTimeSlot.',
			)
		}
		if (noOfPersons === null || noOfPersons === undefined) {
			throw new Error(
				'Required parameter noOfPersons was null or undefined when calling roomPlanControllerFindAvailableTablesByTimeSlot.',
			)
		}

		let localVarQueryParameters = new HttpParams({ encoder: this.encoder })
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>start, 'start')
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>end, 'end')
		localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, <any>noOfPersons, 'noOfPersons')

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table/available/slot`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<FindAvailableTablesByTimeSlotResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			params: localVarQueryParameters,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerFindTableById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<TableResponse>
	public roomPlanControllerFindTableById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<TableResponse>>
	public roomPlanControllerFindTableById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<TableResponse>>
	public roomPlanControllerFindTableById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling roomPlanControllerFindTableById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<TableResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerGetTableGraph(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<TableGraphResponse>
	public roomPlanControllerGetTableGraph(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<TableGraphResponse>>
	public roomPlanControllerGetTableGraph(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<TableGraphResponse>>
	public roomPlanControllerGetTableGraph(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table/graph`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<TableGraphResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param createTableCombinationRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerSaveTableCombinations(
		createTableCombinationRequest: Array<CreateTableCombinationRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public roomPlanControllerSaveTableCombinations(
		createTableCombinationRequest: Array<CreateTableCombinationRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public roomPlanControllerSaveTableCombinations(
		createTableCombinationRequest: Array<CreateTableCombinationRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public roomPlanControllerSaveTableCombinations(
		createTableCombinationRequest: Array<CreateTableCombinationRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createTableCombinationRequest === null || createTableCombinationRequest === undefined) {
			throw new Error(
				'Required parameter createTableCombinationRequest was null or undefined when calling roomPlanControllerSaveTableCombinations.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table/combination`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createTableCombinationRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param saveTableRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerSaveTables(
		saveTableRequest: Array<SaveTableRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TableResponse>>
	public roomPlanControllerSaveTables(
		saveTableRequest: Array<SaveTableRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TableResponse>>>
	public roomPlanControllerSaveTables(
		saveTableRequest: Array<SaveTableRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TableResponse>>>
	public roomPlanControllerSaveTables(
		saveTableRequest: Array<SaveTableRequest>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (saveTableRequest === null || saveTableRequest === undefined) {
			throw new Error(
				'Required parameter saveTableRequest was null or undefined when calling roomPlanControllerSaveTables.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/table`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<TableResponse>>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: saveTableRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param userId
	 * @param requestBody
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public roomPlanControllerSaveUserTableSubscriptions(
		userId: string,
		requestBody: Array<string>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public roomPlanControllerSaveUserTableSubscriptions(
		userId: string,
		requestBody: Array<string>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public roomPlanControllerSaveUserTableSubscriptions(
		userId: string,
		requestBody: Array<string>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public roomPlanControllerSaveUserTableSubscriptions(
		userId: string,
		requestBody: Array<string>,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (userId === null || userId === undefined) {
			throw new Error(
				'Required parameter userId was null or undefined when calling roomPlanControllerSaveUserTableSubscriptions.',
			)
		}
		if (requestBody === null || requestBody === undefined) {
			throw new Error(
				'Required parameter requestBody was null or undefined when calling roomPlanControllerSaveUserTableSubscriptions.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/subscriptions/${this.configuration.encodeParam({ name: 'userId', value: userId, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: requestBody,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public settingsControllerFind(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<SettingsResponse>
	public settingsControllerFind(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<SettingsResponse>>
	public settingsControllerFind(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<SettingsResponse>>
	public settingsControllerFind(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/settings`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<SettingsResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param saveSettingsRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public settingsControllerSave(
		saveSettingsRequest: SaveSettingsRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public settingsControllerSave(
		saveSettingsRequest: SaveSettingsRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public settingsControllerSave(
		saveSettingsRequest: SaveSettingsRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public settingsControllerSave(
		saveSettingsRequest: SaveSettingsRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (saveSettingsRequest === null || saveSettingsRequest === undefined) {
			throw new Error(
				'Required parameter saveSettingsRequest was null or undefined when calling settingsControllerSave.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/settings`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: saveSettingsRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public staticControllerGetCountries(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<CountryResponse>>
	public staticControllerGetCountries(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<CountryResponse>>>
	public staticControllerGetCountries(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<CountryResponse>>>
	public staticControllerGetCountries(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/static/countries`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<CountryResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public staticControllerGetCurrencies(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<CurrencyResponse>>
	public staticControllerGetCurrencies(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<CurrencyResponse>>>
	public staticControllerGetCurrencies(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<CurrencyResponse>>>
	public staticControllerGetCurrencies(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/static/currencies`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<CurrencyResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public staticControllerGetTimezones(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TimezoneResponse>>
	public staticControllerGetTimezones(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TimezoneResponse>>>
	public staticControllerGetTimezones(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TimezoneResponse>>>
	public staticControllerGetTimezones(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/static/timezones`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<TimezoneResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public statisticsControllerFind(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<StatisticsResponse>
	public statisticsControllerFind(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<StatisticsResponse>>
	public statisticsControllerFind(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<StatisticsResponse>>
	public statisticsControllerFind(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/stats`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<StatisticsResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param file
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public storageControllerUploadFile(
		file: Blob,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<FileUploadResponse>
	public storageControllerUploadFile(
		file: Blob,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<FileUploadResponse>>
	public storageControllerUploadFile(
		file: Blob,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<FileUploadResponse>>
	public storageControllerUploadFile(
		file: Blob,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (file === null || file === undefined) {
			throw new Error('Required parameter file was null or undefined when calling storageControllerUploadFile.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['multipart/form-data']

		const canConsumeForm = this.canConsumeForm(consumes)

		let localVarFormParams: { append(param: string, value: any): any }
		let localVarUseForm = false
		let localVarConvertFormParamsToString = false
		// use FormData to transmit files using content-type "multipart/form-data"
		// see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data
		localVarUseForm = canConsumeForm
		if (localVarUseForm) {
			localVarFormParams = new FormData()
		} else {
			localVarFormParams = new HttpParams({ encoder: this.encoder })
		}

		if (file !== undefined) {
			localVarFormParams = (localVarFormParams.append('file', <any>file) as any) || localVarFormParams
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/file/upload`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<FileUploadResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: localVarConvertFormParamsToString ? localVarFormParams.toString() : localVarFormParams,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param createTenantWithUserRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public tenantControllerCreateTenant(
		createTenantWithUserRequest: CreateTenantWithUserRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public tenantControllerCreateTenant(
		createTenantWithUserRequest: CreateTenantWithUserRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public tenantControllerCreateTenant(
		createTenantWithUserRequest: CreateTenantWithUserRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public tenantControllerCreateTenant(
		createTenantWithUserRequest: CreateTenantWithUserRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createTenantWithUserRequest === null || createTenantWithUserRequest === undefined) {
			throw new Error(
				'Required parameter createTenantWithUserRequest was null or undefined when calling tenantControllerCreateTenant.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/tenant`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createTenantWithUserRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public tenantControllerFindById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CompanyResponse>
	public tenantControllerFindById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CompanyResponse>>
	public tenantControllerFindById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CompanyResponse>>
	public tenantControllerFindById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling tenantControllerFindById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/tenant/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CompanyResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param createUserRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerCreate(
		createUserRequest: CreateUserRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<UserResponse>
	public userControllerCreate(
		createUserRequest: CreateUserRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<UserResponse>>
	public userControllerCreate(
		createUserRequest: CreateUserRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<UserResponse>>
	public userControllerCreate(
		createUserRequest: CreateUserRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createUserRequest === null || createUserRequest === undefined) {
			throw new Error('Required parameter createUserRequest was null or undefined when calling userControllerCreate.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<UserResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createUserRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerDeleteById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public userControllerDeleteById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public userControllerDeleteById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public userControllerDeleteById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling userControllerDeleteById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerFindAll(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<UserResponse>>
	public userControllerFindAll(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<UserResponse>>>
	public userControllerFindAll(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<UserResponse>>>
	public userControllerFindAll(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<Array<UserResponse>>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerFindById(
		id: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<UserResponse>
	public userControllerFindById(
		id: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<UserResponse>>
	public userControllerFindById(
		id: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<UserResponse>>
	public userControllerFindById(
		id: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling userControllerFindById.')
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<UserResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerGetProfile(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<UserResponse>
	public userControllerGetProfile(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<UserResponse>>
	public userControllerGetProfile(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<UserResponse>>
	public userControllerGetProfile(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user/me`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<UserResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param updateUserRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerUpdateById(
		id: string,
		updateUserRequest: UpdateUserRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<UserResponse>
	public userControllerUpdateById(
		id: string,
		updateUserRequest: UpdateUserRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<UserResponse>>
	public userControllerUpdateById(
		id: string,
		updateUserRequest: UpdateUserRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<UserResponse>>
	public userControllerUpdateById(
		id: string,
		updateUserRequest: UpdateUserRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error('Required parameter id was null or undefined when calling userControllerUpdateById.')
		}
		if (updateUserRequest === null || updateUserRequest === undefined) {
			throw new Error(
				'Required parameter updateUserRequest was null or undefined when calling userControllerUpdateById.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json'])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<UserResponse>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateUserRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 * @param id
	 * @param updateMessagingTokenRequest
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public userControllerUpdateMessagingTokenById(
		id: string,
		updateMessagingTokenRequest: UpdateMessagingTokenRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public userControllerUpdateMessagingTokenById(
		id: string,
		updateMessagingTokenRequest: UpdateMessagingTokenRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public userControllerUpdateMessagingTokenById(
		id: string,
		updateMessagingTokenRequest: UpdateMessagingTokenRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public userControllerUpdateMessagingTokenById(
		id: string,
		updateMessagingTokenRequest: UpdateMessagingTokenRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (id === null || id === undefined) {
			throw new Error(
				'Required parameter id was null or undefined when calling userControllerUpdateMessagingTokenById.',
			)
		}
		if (updateMessagingTokenRequest === null || updateMessagingTokenRequest === undefined) {
			throw new Error(
				'Required parameter updateMessagingTokenRequest was null or undefined when calling userControllerUpdateMessagingTokenById.',
			)
		}

		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		// to determine the Content-Type header
		const consumes: string[] = ['application/json']
		const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes)
		if (httpContentTypeSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected)
		}

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/user/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/token`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('put', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: updateMessagingTokenRequest,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}

	/**
	 *
	 * Handles Stripe webhook events
	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
	 * @param reportProgress flag to report request and response progress.
	 */
	public webhookControllerHandleStripeWebhook(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public webhookControllerHandleStripeWebhook(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public webhookControllerHandleStripeWebhook(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public webhookControllerHandleStripeWebhook(
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		let localVarHeaders = this.defaultHeaders

		const localVarHttpHeaderAcceptSelected: string | undefined =
			options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept([])
		if (localVarHttpHeaderAcceptSelected !== undefined) {
			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected)
		}

		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext()

		const localVarTransferCache: boolean = options?.transferCache ?? true

		let responseType_: 'text' | 'json' | 'blob' = 'json'
		if (localVarHttpHeaderAcceptSelected) {
			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
				responseType_ = 'text'
			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
				responseType_ = 'json'
			} else {
				responseType_ = 'blob'
			}
		}

		let localVarPath = `/api/billing/stripe/webhook`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}
}