/**
 * 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 { CategoryResponse } from '../model/categoryResponse'
// @ts-ignore
import { CheckinRequest } from '../model/checkinRequest'
// @ts-ignore
import { CreatePaymentIntentRequest } from '../model/createPaymentIntentRequest'
// @ts-ignore
import { CreatePaymentIntentResponse } from '../model/createPaymentIntentResponse'
// @ts-ignore
import { CreateReservationRequest } from '../model/createReservationRequest'
// @ts-ignore
import { CustomerAppSettings } from '../model/customerAppSettings'
// @ts-ignore
import { CustomerOrderItemRequest } from '../model/customerOrderItemRequest'
// @ts-ignore
import { CustomerReviewsResponse } from '../model/customerReviewsResponse'
// @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 { SendMessageRequest } from '../model/sendMessageRequest'
// @ts-ignore
import { TableTokenResponse } from '../model/tableTokenResponse'
// @ts-ignore
import { TimeSlot } from '../model/timeSlot'
// @ts-ignore
import { VerifyReservationResponse } from '../model/verifyReservationResponse'
// @ts-ignore
import { WidgetCreateReservationResponse } from '../model/widgetCreateReservationResponse'
// @ts-ignore
import { WidgetSettingsResponse } from '../model/widgetSettingsResponse'

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

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

	/**
	 * @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 customerMenuControllerFindAllCategories(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<CategoryResponse>>
	public customerMenuControllerFindAllCategories(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<CategoryResponse>>>
	public customerMenuControllerFindAllCategories(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<CategoryResponse>>>
	public customerMenuControllerFindAllCategories(
		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/customer/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 customerMenuControllerFindAllItem(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<MenuItemResponse>>
	public customerMenuControllerFindAllItem(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<MenuItemResponse>>>
	public customerMenuControllerFindAllItem(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<MenuItemResponse>>>
	public customerMenuControllerFindAllItem(
		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/customer/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 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 customerMessageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<MessageResponse>
	public customerMessageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<MessageResponse>>
	public customerMessageControllerSend(
		sendMessageRequest: SendMessageRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<MessageResponse>>
	public customerMessageControllerSend(
		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 customerMessageControllerSend.',
			)
		}

		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/customer/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 customerOrderItemRequest
	 * @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 customerOrderControllerAddOrderItems(
		orderId: string,
		customerOrderItemRequest: Array<CustomerOrderItemRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<OrderResponse>
	public customerOrderControllerAddOrderItems(
		orderId: string,
		customerOrderItemRequest: Array<CustomerOrderItemRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<OrderResponse>>
	public customerOrderControllerAddOrderItems(
		orderId: string,
		customerOrderItemRequest: Array<CustomerOrderItemRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<OrderResponse>>
	public customerOrderControllerAddOrderItems(
		orderId: string,
		customerOrderItemRequest: Array<CustomerOrderItemRequest>,
		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 customerOrderControllerAddOrderItems.',
			)
		}
		if (customerOrderItemRequest === null || customerOrderItemRequest === undefined) {
			throw new Error(
				'Required parameter customerOrderItemRequest was null or undefined when calling customerOrderControllerAddOrderItems.',
			)
		}

		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/customer/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: customerOrderItemRequest,
			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 customerOrderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<OrderResponse>
	public customerOrderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<OrderResponse>>
	public customerOrderControllerCheckin(
		checkinRequest: CheckinRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<OrderResponse>>
	public customerOrderControllerCheckin(
		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 customerOrderControllerCheckin.',
			)
		}

		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/customer/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 customerOrderControllerCheckout(
		orderId: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public customerOrderControllerCheckout(
		orderId: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public customerOrderControllerCheckout(
		orderId: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public customerOrderControllerCheckout(
		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 customerOrderControllerCheckout.')
		}

		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/customer/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 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 customerOrderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public customerOrderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public customerOrderControllerPayItemsViaCash(
		orderId: string,
		payOrderItemRequest: Array<PayOrderItemRequest>,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public customerOrderControllerPayItemsViaCash(
		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 customerOrderControllerPayItemsViaCash.',
			)
		}
		if (payOrderItemRequest === null || payOrderItemRequest === undefined) {
			throw new Error(
				'Required parameter payOrderItemRequest was null or undefined when calling customerOrderControllerPayItemsViaCash.',
			)
		}

		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/customer/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,
		})
	}

	/**
	 *
	 * Create a payment intent for the current tenant
	 * @param createPaymentIntentRequest
	 * @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 customerPaymentControllerCreatePaymentIntent(
		createPaymentIntentRequest: CreatePaymentIntentRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CreatePaymentIntentResponse>
	public customerPaymentControllerCreatePaymentIntent(
		createPaymentIntentRequest: CreatePaymentIntentRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CreatePaymentIntentResponse>>
	public customerPaymentControllerCreatePaymentIntent(
		createPaymentIntentRequest: CreatePaymentIntentRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CreatePaymentIntentResponse>>
	public customerPaymentControllerCreatePaymentIntent(
		createPaymentIntentRequest: CreatePaymentIntentRequest,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (createPaymentIntentRequest === null || createPaymentIntentRequest === undefined) {
			throw new Error(
				'Required parameter createPaymentIntentRequest was null or undefined when calling customerPaymentControllerCreatePaymentIntent.',
			)
		}

		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/customer/payment/intent`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CreatePaymentIntentResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createPaymentIntentRequest,
			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 customerReservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<WidgetCreateReservationResponse>
	public customerReservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<WidgetCreateReservationResponse>>
	public customerReservationControllerCreate(
		createReservationRequest: CreateReservationRequest,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<WidgetCreateReservationResponse>>
	public customerReservationControllerCreate(
		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 customerReservationControllerCreate.',
			)
		}

		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/customer/reservation`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<WidgetCreateReservationResponse>('post', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			body: createReservationRequest,
			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 customerReservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<Array<TimeSlot>>
	public customerReservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<Array<TimeSlot>>>
	public customerReservationControllerGetTimeSlotsByDate(
		date: Date,
		timezone?: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<Array<TimeSlot>>>
	public customerReservationControllerGetTimeSlotsByDate(
		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 customerReservationControllerGetTimeSlotsByDate.',
			)
		}

		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/customer/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 tableId
	 * @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 customerReservationControllerVerify(
		tableId: string,
		query: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<VerifyReservationResponse>
	public customerReservationControllerVerify(
		tableId: string,
		query: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<VerifyReservationResponse>>
	public customerReservationControllerVerify(
		tableId: string,
		query: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<VerifyReservationResponse>>
	public customerReservationControllerVerify(
		tableId: string,
		query: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (tableId === null || tableId === undefined) {
			throw new Error(
				'Required parameter tableId was null or undefined when calling customerReservationControllerVerify.',
			)
		}
		if (query === null || query === undefined) {
			throw new Error(
				'Required parameter query was null or undefined when calling customerReservationControllerVerify.',
			)
		}

		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/customer/reservation/verify/${this.configuration.encodeParam({ name: 'tableId', value: tableId, 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<VerifyReservationResponse>('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 customerReviewsControllerFind(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CustomerReviewsResponse>
	public customerReviewsControllerFind(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CustomerReviewsResponse>>
	public customerReviewsControllerFind(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CustomerReviewsResponse>>
	public customerReviewsControllerFind(
		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/customer/reviews`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CustomerReviewsResponse>('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 customerSettingsControllerFindAppSettings(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<CustomerAppSettings>
	public customerSettingsControllerFindAppSettings(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<CustomerAppSettings>>
	public customerSettingsControllerFindAppSettings(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<CustomerAppSettings>>
	public customerSettingsControllerFindAppSettings(
		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/customer/settings/app`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<CustomerAppSettings>('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 customerSettingsControllerFindWidgetSettings(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<WidgetSettingsResponse>
	public customerSettingsControllerFindWidgetSettings(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<WidgetSettingsResponse>>
	public customerSettingsControllerFindWidgetSettings(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<WidgetSettingsResponse>>
	public customerSettingsControllerFindWidgetSettings(
		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/customer/settings/widget`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<WidgetSettingsResponse>('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 tokenControllerGenerateQrCodes(
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<any>
	public tokenControllerGenerateQrCodes(
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<any>>
	public tokenControllerGenerateQrCodes(
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: undefined; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<any>>
	public tokenControllerGenerateQrCodes(
		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/customer/token/qrcode`
		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 token
	 * @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 tokenControllerVerify(
		token: string,
		observe?: 'body',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<TableTokenResponse>
	public tokenControllerVerify(
		token: string,
		observe?: 'response',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpResponse<TableTokenResponse>>
	public tokenControllerVerify(
		token: string,
		observe?: 'events',
		reportProgress?: boolean,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<HttpEvent<TableTokenResponse>>
	public tokenControllerVerify(
		token: string,
		observe: any = 'body',
		reportProgress: boolean = false,
		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean },
	): Observable<any> {
		if (token === null || token === undefined) {
			throw new Error('Required parameter token was null or undefined when calling tokenControllerVerify.')
		}

		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/customer/token/verify/${this.configuration.encodeParam({ name: 'token', value: token, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`
		const { basePath, withCredentials } = this.configuration
		return this.httpClient.request<TableTokenResponse>('get', `${basePath}${localVarPath}`, {
			context: localVarHttpContext,
			responseType: <any>responseType_,
			...(withCredentials ? { withCredentials } : {}),
			headers: localVarHeaders,
			observe: observe,
			transferCache: localVarTransferCache,
			reportProgress: reportProgress,
		})
	}
}