/* tslint:disable */
import { Injectable } from '@angular/core';
import { HttpClient, HttpRequest, HttpResponse, HttpHeaders } from '@angular/common/http';
import { BaseService as __BaseService } from '../base-service';
import { CheckoutConfiguration as __Configuration } from '../checkout-configuration';
import { StrictHttpResponse as __StrictHttpResponse } from '../strict-http-response';
import { Observable as __Observable } from 'rxjs';
import { map as __map, filter as __filter } from 'rxjs/operators';

import { ResponseArgsOfItemResult } from '../models/response-args-of-item-result';
import { ItemPayload } from '../models/item-payload';
import { ResponseArgsOfItemsResult } from '../models/response-args-of-items-result';
import { ResponseArgsOfBuyerResult } from '../models/response-args-of-buyer-result';
import { BuyerPayload } from '../models/buyer-payload';
import { ResponseArgsOfDestinationResult } from '../models/response-args-of-destination-result';
import { DestinationDTO } from '../models/destination-dto';
import { ResponseArgsOfShoppingCartDTO } from '../models/response-args-of-shopping-cart-dto';
import { AddToShoppingCartDTO } from '../models/add-to-shopping-cart-dto';
import { UpdateShoppingCartItemDTO } from '../models/update-shopping-cart-item-dto';
import { AvailabilityDTO } from '../models/availability-dto';
import { PromotionDTO } from '../models/promotion-dto';
import { ResponseArgsOfIEnumerableOfRequiredData } from '../models/response-args-of-ienumerable-of-required-data';
import { ResponseArgsOfCheckoutDTO } from '../models/response-args-of-checkout-dto';
import { ResponseArgsOfCheckoutStep } from '../models/response-args-of-checkout-step';
import { ResponseArgsOfNullableBoolean } from '../models/response-args-of-nullable-boolean';
import { UserAccountDTO } from '../models/user-account-dto';
import { BuyerDTO } from '../models/buyer-dto';
import { PayerDTO } from '../models/payer-dto';
import { ResponseArgsOfIEnumerableOfSupplierDTO } from '../models/response-args-of-ienumerable-of-supplier-dto';
import { ResponseArgsOfDestinationDTO } from '../models/response-args-of-destination-dto';
import { ResponseArgsOfIEnumerableOfCheckoutDeliveryDTO } from '../models/response-args-of-ienumerable-of-checkout-delivery-dto';
import { ResponseArgsOfCheckoutDeliveryDTO } from '../models/response-args-of-checkout-delivery-dto';
import { DeliveryContainer } from '../models/delivery-container';
import { ResponseArgsOfIEnumerableOfBranchDTO } from '../models/response-args-of-ienumerable-of-branch-dto';
import { BranchQueryTokenDTO } from '../models/branch-query-token-dto';
import { ResponseArgsOfIEnumerableOfCountryDTO } from '../models/response-args-of-ienumerable-of-country-dto';
import { KeyValuePairOfEntityDTOContainerOfCheckoutItemDTOAndNullableDecimal } from '../models/key-value-pair-of-entity-dtocontainer-of-checkout-item-dtoand-nullable-decimal';
import { ResponseArgsOfPaymentDTO } from '../models/response-args-of-payment-dto';
import { ResponseArgsOfIEnumerableOfSelectionDTOOfPaymentType } from '../models/response-args-of-ienumerable-of-selection-dtoof-payment-type';
import { NotificationChannel } from '../models/notification-channel';
import { ResponseArgsOfIEnumerableOfAvailabilityDTO } from '../models/response-args-of-ienumerable-of-availability-dto';
import { ListResponseArgsOfVATDTO } from '../models/list-response-args-of-vatdto';
import { ResponseArgsOfVATDTO } from '../models/response-args-of-vatdto';
import { ListResponseArgsOfLogisticianDTO } from '../models/list-response-args-of-logistician-dto';
import { ResponseArgsOfLogisticianDTO } from '../models/response-args-of-logistician-dto';
@Injectable({
  providedIn: 'root',
})
class StoreCheckoutService extends __BaseService {
  static readonly StoreCheckoutCanAddItemPath = '/store/shoppingcart/{shoppingCartId}/item/canadd';
  static readonly StoreCheckoutCanAddItemsPath = '/store/shoppingcart/{shoppingCartId}/items/canadd';
  static readonly StoreCheckoutCanAddBuyerPath = '/store/shoppingcart/{shoppingCartId}/buyer/canadd';
  static readonly StoreCheckoutCanAddDestinationPath = '/store/shoppingcart/{shoppingCartId}/destination/canadd';
  static readonly StoreCheckoutSetLogisticianOnDestinationsByBuyerPath = '/store/shoppingcart/{shoppingCartId}/item/destination';
  static readonly StoreCheckoutAddItemToShoppingCartPath = '/store/shoppingcart/{shoppingCartId}/item';
  static readonly StoreCheckoutGetShoppingCartPath = '/store/shoppingcart/{shoppingCartId}';
  static readonly StoreCheckoutUpdateShoppingCartItemPath = '/store/shoppingcart/{shoppingCartId}/item/{shoppingCartItemId}';
  static readonly StoreCheckoutUpdateShoppingCartItemAvailabilityPath = '/store/shoppingcart/{shoppingCartId}/item/{shoppingCartItemId}/availability';
  static readonly StoreCheckoutDeleteShoppingCartItemAvailabilityPath = '/store/shoppingcart/{shoppingCartId}/item/{shoppingCartItemId}/availability';
  static readonly StoreCheckoutUpdateShoppingCartItemPromotionPath = '/store/shoppingcart/{shoppingCartId}/item/{shoppingCartItemId}/promotion';
  static readonly StoreCheckoutDeleteShoppingCartItemPromotionPath = '/store/shoppingcart/{shoppingCartId}/item/{shoppingCartItemId}/promotion';
  static readonly StoreCheckoutCreateShoppingCartPath = '/store/shoppingcart';
  static readonly StoreCheckoutCreateShoppingCartAndAddItemPath = '/store/shoppingcart/item';
  static readonly StoreCheckoutRequiredDataForPayerPath = '/store/checkout/{checkoutId}/payer/requireddata';
  static readonly StoreCheckoutRequiredDataForDeliveryPath = '/store/checkout/{checkoutId}/destination/{destinationId}/requireddata';
  static readonly StoreCheckoutCreateOrRefreshCheckoutPath = '/store/checkout/shoppingcart/{shoppingCartId}';
  static readonly StoreCheckoutDiscardCheckoutPath = '/store/checkout/{checkoutId}';
  static readonly StoreCheckoutGetCheckoutPath = '/store/checkout/{checkoutId}';
  static readonly StoreCheckoutResetCheckoutPath = '/store/checkout/{checkoutId}/reset';
  static readonly StoreCheckoutCurrentCheckoutStepPath = '/store/checkout/{checkoutId}/requiredstep';
  static readonly StoreCheckoutEmailExistsPath = '/store/checkout/{checkoutPId}/emailexists';
  static readonly StoreCheckoutSetAccountValuesPath = '/store/checkout/{checkoutId}/account';
  static readonly StoreCheckoutSetBuyerPath = '/store/checkout/{checkoutId}/buyer';
  static readonly StoreCheckoutSetBuyer2Path = '/store/checkout/{checkoutId}/buyer';
  static readonly StoreCheckoutSetPayerPath = '/store/checkout/{checkoutId}/payer';
  static readonly StoreCheckoutSetPayer2Path = '/store/checkout/{checkoutId}/payer';
  static readonly StoreCheckoutGetSuppliersPath = '/store/suppliers';
  static readonly StoreCheckoutCreateDestinationPath = '/store/checkout/{checkoutId}/destination';
  static readonly StoreCheckoutUpdateDestinationPath = '/store/checkout/{checkoutId}/destination/{destinationId}';
  static readonly StoreCheckoutDeleteDestinationPath = '/store/checkout/{checkoutId}/destination/{destinationId}';
  static readonly StoreCheckoutGetDeliveriesPath = '/store/checkout/{checkoutId}/deliveries';
  static readonly StoreCheckoutCreateDeliveryPath = '/store/checkout/{checkoutId}/deliveries';
  static readonly StoreCheckoutUpdateDeliveryPath = '/store/checkout/{checkoutId}/deliveries/{deliveryId}';
  static readonly StoreCheckoutGetBranchesByCheckoutPath = '/store/checkout/{checkoutId}/branches';
  static readonly StoreCheckoutGetBranchesPath = '/store/branches';
  static readonly StoreCheckoutQueryBranchesPath = '/store/branches/s';
  static readonly StoreCheckoutGetCountriesByCheckoutPath = '/store/checkout/{checkoutId}/countries';
  static readonly StoreCheckoutGetCountriesPath = '/store/countries';
  static readonly StoreCheckoutUpdateCheckoutItemPath = '/store/checkout/{checkoutId}/items/{checkoutItemId}';
  static readonly StoreCheckoutDeleteCheckoutItemPath = '/store/checkout/{checkoutId}/items/{checkoutItemId}';
  static readonly StoreCheckoutSetDeliveryPath = '/store/checkout/{checkoutId}/items';
  static readonly StoreCheckoutGetCheckoutPaymentPath = '/store/checkout/{checkoutId}/payment';
  static readonly StoreCheckoutSetPaymentTypePath = '/store/checkout/{checkoutId}/payment';
  static readonly StoreCheckoutGetDeliveryPaymentPath = '/store/checkout/{checkoutId}/delivery/{deliveryId}/payment';
  static readonly StoreCheckoutSetNotificationChannelsPath = '/store/checkout/{checkoutId}/notificationchannel';
  static readonly StoreCheckoutAddVoucherPath = '/store/checkout/{checkoutId}/vouchers';
  static readonly StoreCheckoutDeleteVoucherPath = '/store/checkout/{checkoutId}/vouchers/{voucherId}';
  static readonly StoreCheckoutGetAvailabilitiesPath = '/store/checkout/availability';
  static readonly StoreCheckoutGetVATsPath = '/store/checkout/vat';
  static readonly StoreCheckoutGetVATPath = '/store/checkout/vat/{vatId}';
  static readonly StoreCheckoutGetLogisticiansPath = '/store/checkout/logistician';
  static readonly StoreCheckoutGetLogisticianByIdPath = '/store/checkout/logistician/{logisticianId}';

  constructor(
    config: __Configuration,
    http: HttpClient
  ) {
    super(config, http);
  }

  /**
   * Überprüfung, ob Artikel einem Warenkorb hinzugefügt werden kann
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddItemParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddItemResponse(params: StoreCheckoutService.StoreCheckoutCanAddItemParams): __Observable<__StrictHttpResponse<ResponseArgsOfItemResult>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.payload;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/canadd`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfItemResult>;
      })
    );
  }
  /**
   * Überprüfung, ob Artikel einem Warenkorb hinzugefügt werden kann
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddItemParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddItem(params: StoreCheckoutService.StoreCheckoutCanAddItemParams): __Observable<ResponseArgsOfItemResult> {
    return this.StoreCheckoutCanAddItemResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfItemResult)
    );
  }

  /**
   * Überprüfung, ob die übergebenen Artikel dem Warenkorb hinzugefügt werden können
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddItemsParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddItemsResponse(params: StoreCheckoutService.StoreCheckoutCanAddItemsParams): __Observable<__StrictHttpResponse<ResponseArgsOfItemsResult>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.payload;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/items/canadd`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfItemsResult>;
      })
    );
  }
  /**
   * Überprüfung, ob die übergebenen Artikel dem Warenkorb hinzugefügt werden können
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddItemsParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddItems(params: StoreCheckoutService.StoreCheckoutCanAddItemsParams): __Observable<ResponseArgsOfItemsResult> {
    return this.StoreCheckoutCanAddItemsResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfItemsResult)
    );
  }

  /**
   * Überprüfung, ob ein Kundentyp einem Warenkorb hinzugefügt werden kann
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddBuyerParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddBuyerResponse(params: StoreCheckoutService.StoreCheckoutCanAddBuyerParams): __Observable<__StrictHttpResponse<ResponseArgsOfBuyerResult>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.payload;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/buyer/canadd`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfBuyerResult>;
      })
    );
  }
  /**
   * Überprüfung, ob ein Kundentyp einem Warenkorb hinzugefügt werden kann
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddBuyerParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddBuyer(params: StoreCheckoutService.StoreCheckoutCanAddBuyerParams): __Observable<ResponseArgsOfBuyerResult> {
    return this.StoreCheckoutCanAddBuyerResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfBuyerResult)
    );
  }

  /**
   * Überprüfung, ob das übergebene Lieferziel dem Warenkorb hinzugefügt werden kann
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddDestinationParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddDestinationResponse(params: StoreCheckoutService.StoreCheckoutCanAddDestinationParams): __Observable<__StrictHttpResponse<ResponseArgsOfDestinationResult>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.payload;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/destination/canadd`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfDestinationResult>;
      })
    );
  }
  /**
   * Überprüfung, ob das übergebene Lieferziel dem Warenkorb hinzugefügt werden kann
   * @param params The `StoreCheckoutService.StoreCheckoutCanAddDestinationParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutCanAddDestination(params: StoreCheckoutService.StoreCheckoutCanAddDestinationParams): __Observable<ResponseArgsOfDestinationResult> {
    return this.StoreCheckoutCanAddDestinationResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfDestinationResult)
    );
  }

  /**
   * Alle Versand-Destinations anhand er übergebnenen Kundendaten aktualisieren
   * @param params The `StoreCheckoutService.StoreCheckoutSetLogisticianOnDestinationsByBuyerParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutSetLogisticianOnDestinationsByBuyerResponse(params: StoreCheckoutService.StoreCheckoutSetLogisticianOnDestinationsByBuyerParams): __Observable<__StrictHttpResponse<ResponseArgsOfBuyerResult>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.payload;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/destination`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfBuyerResult>;
      })
    );
  }
  /**
   * Alle Versand-Destinations anhand er übergebnenen Kundendaten aktualisieren
   * @param params The `StoreCheckoutService.StoreCheckoutSetLogisticianOnDestinationsByBuyerParams` containing the following parameters:
   *
   * - `shoppingCartId`: Warenkorb PK
   *
   * - `payload`: Daten
   *
   * - `locale`: Lokalisierung
   */
  StoreCheckoutSetLogisticianOnDestinationsByBuyer(params: StoreCheckoutService.StoreCheckoutSetLogisticianOnDestinationsByBuyerParams): __Observable<ResponseArgsOfBuyerResult> {
    return this.StoreCheckoutSetLogisticianOnDestinationsByBuyerResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfBuyerResult)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutAddItemToShoppingCartParams` containing the following parameters:
   *
   * - `shoppingCartId`:
   *
   * - `items`:
   *
   * - `locale`:
   */
  StoreCheckoutAddItemToShoppingCartResponse(params: StoreCheckoutService.StoreCheckoutAddItemToShoppingCartParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.items;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutAddItemToShoppingCartParams` containing the following parameters:
   *
   * - `shoppingCartId`:
   *
   * - `items`:
   *
   * - `locale`:
   */
  StoreCheckoutAddItemToShoppingCart(params: StoreCheckoutService.StoreCheckoutAddItemToShoppingCartParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutAddItemToShoppingCartResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetShoppingCartParams` containing the following parameters:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetShoppingCartResponse(params: StoreCheckoutService.StoreCheckoutGetShoppingCartParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetShoppingCartParams` containing the following parameters:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetShoppingCart(params: StoreCheckoutService.StoreCheckoutGetShoppingCartParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutGetShoppingCartResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemParams` containing the following parameters:
   *
   * - `values`:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateShoppingCartItemResponse(params: StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.values;


    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/${encodeURIComponent(params.shoppingCartItemId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemParams` containing the following parameters:
   *
   * - `values`:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateShoppingCartItem(params: StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutUpdateShoppingCartItemResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemAvailabilityParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `availability`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateShoppingCartItemAvailabilityResponse(params: StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemAvailabilityParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    __body = params.availability;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/${encodeURIComponent(params.shoppingCartItemId)}/availability`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemAvailabilityParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `availability`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateShoppingCartItemAvailability(params: StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemAvailabilityParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutUpdateShoppingCartItemAvailabilityResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemAvailabilityParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteShoppingCartItemAvailabilityResponse(params: StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemAvailabilityParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'DELETE',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/${encodeURIComponent(params.shoppingCartItemId)}/availability`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemAvailabilityParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteShoppingCartItemAvailability(params: StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemAvailabilityParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutDeleteShoppingCartItemAvailabilityResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemPromotionParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `promotion`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateShoppingCartItemPromotionResponse(params: StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemPromotionParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    __body = params.promotion;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/${encodeURIComponent(params.shoppingCartItemId)}/promotion`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemPromotionParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `promotion`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateShoppingCartItemPromotion(params: StoreCheckoutService.StoreCheckoutUpdateShoppingCartItemPromotionParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutUpdateShoppingCartItemPromotionResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemPromotionParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteShoppingCartItemPromotionResponse(params: StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemPromotionParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'DELETE',
      this.rootUrl + `/store/shoppingcart/${encodeURIComponent(params.shoppingCartId)}/item/${encodeURIComponent(params.shoppingCartItemId)}/promotion`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemPromotionParams` containing the following parameters:
   *
   * - `shoppingCartItemId`:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteShoppingCartItemPromotion(params: StoreCheckoutService.StoreCheckoutDeleteShoppingCartItemPromotionParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutDeleteShoppingCartItemPromotionResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param locale undefined
   */
  StoreCheckoutCreateShoppingCartResponse(locale?: null | string): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    if (locale != null) __params = __params.set('locale', locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param locale undefined
   */
  StoreCheckoutCreateShoppingCart(locale?: null | string): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutCreateShoppingCartResponse(locale).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateShoppingCartAndAddItemParams` containing the following parameters:
   *
   * - `items`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateShoppingCartAndAddItemResponse(params: StoreCheckoutService.StoreCheckoutCreateShoppingCartAndAddItemParams): __Observable<__StrictHttpResponse<ResponseArgsOfShoppingCartDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.items;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/shoppingcart/item`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfShoppingCartDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateShoppingCartAndAddItemParams` containing the following parameters:
   *
   * - `items`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateShoppingCartAndAddItem(params: StoreCheckoutService.StoreCheckoutCreateShoppingCartAndAddItemParams): __Observable<ResponseArgsOfShoppingCartDTO> {
    return this.StoreCheckoutCreateShoppingCartAndAddItemResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfShoppingCartDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutRequiredDataForPayerParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutRequiredDataForPayerResponse(params: StoreCheckoutService.StoreCheckoutRequiredDataForPayerParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfRequiredData>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/payer/requireddata`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfRequiredData>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutRequiredDataForPayerParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutRequiredDataForPayer(params: StoreCheckoutService.StoreCheckoutRequiredDataForPayerParams): __Observable<ResponseArgsOfIEnumerableOfRequiredData> {
    return this.StoreCheckoutRequiredDataForPayerResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfRequiredData)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutRequiredDataForDeliveryParams` containing the following parameters:
   *
   * - `destinationId`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutRequiredDataForDeliveryResponse(params: StoreCheckoutService.StoreCheckoutRequiredDataForDeliveryParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfRequiredData>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/destination/${encodeURIComponent(params.destinationId)}/requireddata`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfRequiredData>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutRequiredDataForDeliveryParams` containing the following parameters:
   *
   * - `destinationId`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutRequiredDataForDelivery(params: StoreCheckoutService.StoreCheckoutRequiredDataForDeliveryParams): __Observable<ResponseArgsOfIEnumerableOfRequiredData> {
    return this.StoreCheckoutRequiredDataForDeliveryResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfRequiredData)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateOrRefreshCheckoutParams` containing the following parameters:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateOrRefreshCheckoutResponse(params: StoreCheckoutService.StoreCheckoutCreateOrRefreshCheckoutParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/shoppingcart/${encodeURIComponent(params.shoppingCartId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateOrRefreshCheckoutParams` containing the following parameters:
   *
   * - `shoppingCartId`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateOrRefreshCheckout(params: StoreCheckoutService.StoreCheckoutCreateOrRefreshCheckoutParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutCreateOrRefreshCheckoutResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDiscardCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutDiscardCheckoutResponse(params: StoreCheckoutService.StoreCheckoutDiscardCheckoutParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'DELETE',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDiscardCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutDiscardCheckout(params: StoreCheckoutService.StoreCheckoutDiscardCheckoutParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutDiscardCheckoutResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCheckoutResponse(params: StoreCheckoutService.StoreCheckoutGetCheckoutParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCheckout(params: StoreCheckoutService.StoreCheckoutGetCheckoutParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutGetCheckoutResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutResetCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutResetCheckoutResponse(params: StoreCheckoutService.StoreCheckoutResetCheckoutParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PATCH',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/reset`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutResetCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutResetCheckout(params: StoreCheckoutService.StoreCheckoutResetCheckoutParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutResetCheckoutResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCurrentCheckoutStepParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutCurrentCheckoutStepResponse(params: StoreCheckoutService.StoreCheckoutCurrentCheckoutStepParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutStep>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/requiredstep`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutStep>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCurrentCheckoutStepParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutCurrentCheckoutStep(params: StoreCheckoutService.StoreCheckoutCurrentCheckoutStepParams): __Observable<ResponseArgsOfCheckoutStep> {
    return this.StoreCheckoutCurrentCheckoutStepResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutStep)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutEmailExistsParams` containing the following parameters:
   *
   * - `checkoutPId`:
   *
   * - `locale`:
   *
   * - `email`:
   *
   * - `checkoutId`:
   */
  StoreCheckoutEmailExistsResponse(params: StoreCheckoutService.StoreCheckoutEmailExistsParams): __Observable<__StrictHttpResponse<ResponseArgsOfNullableBoolean>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    if (params.email != null) __params = __params.set('email', params.email.toString());
    if (params.checkoutId != null) __params = __params.set('checkoutId', params.checkoutId.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutPId)}/emailexists`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfNullableBoolean>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutEmailExistsParams` containing the following parameters:
   *
   * - `checkoutPId`:
   *
   * - `locale`:
   *
   * - `email`:
   *
   * - `checkoutId`:
   */
  StoreCheckoutEmailExists(params: StoreCheckoutService.StoreCheckoutEmailExistsParams): __Observable<ResponseArgsOfNullableBoolean> {
    return this.StoreCheckoutEmailExistsResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfNullableBoolean)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetAccountValuesParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `accountValuesDTO`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetAccountValuesResponse(params: StoreCheckoutService.StoreCheckoutSetAccountValuesParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.accountValuesDTO;
    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/account`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetAccountValuesParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `accountValuesDTO`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetAccountValues(params: StoreCheckoutService.StoreCheckoutSetAccountValuesParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetAccountValuesResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetBuyerParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `buyerDTO`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetBuyerResponse(params: StoreCheckoutService.StoreCheckoutSetBuyerParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.buyerDTO;
    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/buyer`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetBuyerParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `buyerDTO`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetBuyer(params: StoreCheckoutService.StoreCheckoutSetBuyerParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetBuyerResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetBuyer2Params` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `buyerDTO`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetBuyer2Response(params: StoreCheckoutService.StoreCheckoutSetBuyer2Params): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.buyerDTO;
    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/buyer`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetBuyer2Params` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `buyerDTO`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetBuyer2(params: StoreCheckoutService.StoreCheckoutSetBuyer2Params): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetBuyer2Response(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetPayerParams` containing the following parameters:
   *
   * - `payerDTO`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetPayerResponse(params: StoreCheckoutService.StoreCheckoutSetPayerParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.payerDTO;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/payer`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetPayerParams` containing the following parameters:
   *
   * - `payerDTO`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetPayer(params: StoreCheckoutService.StoreCheckoutSetPayerParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetPayerResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetPayer2Params` containing the following parameters:
   *
   * - `payerDTO`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetPayer2Response(params: StoreCheckoutService.StoreCheckoutSetPayer2Params): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.payerDTO;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/payer`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetPayer2Params` containing the following parameters:
   *
   * - `payerDTO`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetPayer2(params: StoreCheckoutService.StoreCheckoutSetPayer2Params): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetPayer2Response(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetSuppliersParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   *
   * - `locale`:
   */
  StoreCheckoutGetSuppliersResponse(params: StoreCheckoutService.StoreCheckoutGetSuppliersParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfSupplierDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    if (params.take != null) __params = __params.set('take', params.take.toString());
    if (params.skip != null) __params = __params.set('skip', params.skip.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/suppliers`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfSupplierDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetSuppliersParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   *
   * - `locale`:
   */
  StoreCheckoutGetSuppliers(params: StoreCheckoutService.StoreCheckoutGetSuppliersParams): __Observable<ResponseArgsOfIEnumerableOfSupplierDTO> {
    return this.StoreCheckoutGetSuppliersResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfSupplierDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateDestinationParams` containing the following parameters:
   *
   * - `destinationDTO`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateDestinationResponse(params: StoreCheckoutService.StoreCheckoutCreateDestinationParams): __Observable<__StrictHttpResponse<ResponseArgsOfDestinationDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.destinationDTO;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/destination`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfDestinationDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateDestinationParams` containing the following parameters:
   *
   * - `destinationDTO`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateDestination(params: StoreCheckoutService.StoreCheckoutCreateDestinationParams): __Observable<ResponseArgsOfDestinationDTO> {
    return this.StoreCheckoutCreateDestinationResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfDestinationDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateDestinationParams` containing the following parameters:
   *
   * - `destinationId`:
   *
   * - `destinationDTO`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateDestinationResponse(params: StoreCheckoutService.StoreCheckoutUpdateDestinationParams): __Observable<__StrictHttpResponse<ResponseArgsOfDestinationDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.destinationDTO;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/destination/${encodeURIComponent(params.destinationId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfDestinationDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateDestinationParams` containing the following parameters:
   *
   * - `destinationId`:
   *
   * - `destinationDTO`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateDestination(params: StoreCheckoutService.StoreCheckoutUpdateDestinationParams): __Observable<ResponseArgsOfDestinationDTO> {
    return this.StoreCheckoutUpdateDestinationResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfDestinationDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteDestinationParams` containing the following parameters:
   *
   * - `destinationId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteDestinationResponse(params: StoreCheckoutService.StoreCheckoutDeleteDestinationParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'DELETE',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/destination/${encodeURIComponent(params.destinationId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteDestinationParams` containing the following parameters:
   *
   * - `destinationId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteDestination(params: StoreCheckoutService.StoreCheckoutDeleteDestinationParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutDeleteDestinationResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetDeliveriesParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetDeliveriesResponse(params: StoreCheckoutService.StoreCheckoutGetDeliveriesParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfCheckoutDeliveryDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/deliveries`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfCheckoutDeliveryDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetDeliveriesParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetDeliveries(params: StoreCheckoutService.StoreCheckoutGetDeliveriesParams): __Observable<ResponseArgsOfIEnumerableOfCheckoutDeliveryDTO> {
    return this.StoreCheckoutGetDeliveriesResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfCheckoutDeliveryDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateDeliveryParams` containing the following parameters:
   *
   * - `deliveryContainer`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateDeliveryResponse(params: StoreCheckoutService.StoreCheckoutCreateDeliveryParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDeliveryDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.deliveryContainer;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/deliveries`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDeliveryDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutCreateDeliveryParams` containing the following parameters:
   *
   * - `deliveryContainer`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutCreateDelivery(params: StoreCheckoutService.StoreCheckoutCreateDeliveryParams): __Observable<ResponseArgsOfCheckoutDeliveryDTO> {
    return this.StoreCheckoutCreateDeliveryResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDeliveryDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateDeliveryParams` containing the following parameters:
   *
   * - `deliveryId`:
   *
   * - `deliveryContainer`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateDeliveryResponse(params: StoreCheckoutService.StoreCheckoutUpdateDeliveryParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    __body = params.deliveryContainer;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/deliveries/${encodeURIComponent(params.deliveryId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateDeliveryParams` containing the following parameters:
   *
   * - `deliveryId`:
   *
   * - `deliveryContainer`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutUpdateDelivery(params: StoreCheckoutService.StoreCheckoutUpdateDeliveryParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutUpdateDeliveryResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetBranchesByCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetBranchesByCheckoutResponse(params: StoreCheckoutService.StoreCheckoutGetBranchesByCheckoutParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfBranchDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/branches`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfBranchDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetBranchesByCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetBranchesByCheckout(params: StoreCheckoutService.StoreCheckoutGetBranchesByCheckoutParams): __Observable<ResponseArgsOfIEnumerableOfBranchDTO> {
    return this.StoreCheckoutGetBranchesByCheckoutResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfBranchDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetBranchesParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   *
   * - `locale`:
   *
   * - `labelOnly`:
   */
  StoreCheckoutGetBranchesResponse(params: StoreCheckoutService.StoreCheckoutGetBranchesParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfBranchDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    if (params.take != null) __params = __params.set('take', params.take.toString());
    if (params.skip != null) __params = __params.set('skip', params.skip.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    if (params.labelOnly != null) __params = __params.set('labelOnly', params.labelOnly.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/branches`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfBranchDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetBranchesParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   *
   * - `locale`:
   *
   * - `labelOnly`:
   */
  StoreCheckoutGetBranches(params: StoreCheckoutService.StoreCheckoutGetBranchesParams): __Observable<ResponseArgsOfIEnumerableOfBranchDTO> {
    return this.StoreCheckoutGetBranchesResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfBranchDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutQueryBranchesParams` containing the following parameters:
   *
   * - `queryToken`:
   *
   * - `locale`:
   */
  StoreCheckoutQueryBranchesResponse(params: StoreCheckoutService.StoreCheckoutQueryBranchesParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfBranchDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.queryToken;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/branches/s`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfBranchDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutQueryBranchesParams` containing the following parameters:
   *
   * - `queryToken`:
   *
   * - `locale`:
   */
  StoreCheckoutQueryBranches(params: StoreCheckoutService.StoreCheckoutQueryBranchesParams): __Observable<ResponseArgsOfIEnumerableOfBranchDTO> {
    return this.StoreCheckoutQueryBranchesResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfBranchDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCountriesByCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCountriesByCheckoutResponse(params: StoreCheckoutService.StoreCheckoutGetCountriesByCheckoutParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfCountryDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/countries`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfCountryDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCountriesByCheckoutParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCountriesByCheckout(params: StoreCheckoutService.StoreCheckoutGetCountriesByCheckoutParams): __Observable<ResponseArgsOfIEnumerableOfCountryDTO> {
    return this.StoreCheckoutGetCountriesByCheckoutResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfCountryDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCountriesParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCountriesResponse(params: StoreCheckoutService.StoreCheckoutGetCountriesParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfCountryDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    if (params.take != null) __params = __params.set('take', params.take.toString());
    if (params.skip != null) __params = __params.set('skip', params.skip.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/countries`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfCountryDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCountriesParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCountries(params: StoreCheckoutService.StoreCheckoutGetCountriesParams): __Observable<ResponseArgsOfIEnumerableOfCountryDTO> {
    return this.StoreCheckoutGetCountriesResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfCountryDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateCheckoutItemParams` containing the following parameters:
   *
   * - `checkoutItemId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `quantity`:
   *
   * - `locale`:
   *
   * - `deliveryId`:
   */
  StoreCheckoutUpdateCheckoutItemResponse(params: StoreCheckoutService.StoreCheckoutUpdateCheckoutItemParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.quantity != null) __params = __params.set('quantity', params.quantity.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    if (params.deliveryId != null) __params = __params.set('deliveryId', params.deliveryId.toString());
    let req = new HttpRequest<any>(
      'PATCH',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/items/${encodeURIComponent(params.checkoutItemId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutUpdateCheckoutItemParams` containing the following parameters:
   *
   * - `checkoutItemId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `quantity`:
   *
   * - `locale`:
   *
   * - `deliveryId`:
   */
  StoreCheckoutUpdateCheckoutItem(params: StoreCheckoutService.StoreCheckoutUpdateCheckoutItemParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutUpdateCheckoutItemResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteCheckoutItemParams` containing the following parameters:
   *
   * - `checkoutItemId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteCheckoutItemResponse(params: StoreCheckoutService.StoreCheckoutDeleteCheckoutItemParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'DELETE',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/items/${encodeURIComponent(params.checkoutItemId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteCheckoutItemParams` containing the following parameters:
   *
   * - `checkoutItemId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteCheckoutItem(params: StoreCheckoutService.StoreCheckoutDeleteCheckoutItemParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutDeleteCheckoutItemResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetDeliveryParams` containing the following parameters:
   *
   * - `items`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   *
   * - `deliveryId`:
   */
  StoreCheckoutSetDeliveryResponse(params: StoreCheckoutService.StoreCheckoutSetDeliveryParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.items;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    if (params.deliveryId != null) __params = __params.set('deliveryId', params.deliveryId.toString());
    let req = new HttpRequest<any>(
      'PATCH',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/items`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetDeliveryParams` containing the following parameters:
   *
   * - `items`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   *
   * - `deliveryId`:
   */
  StoreCheckoutSetDelivery(params: StoreCheckoutService.StoreCheckoutSetDeliveryParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetDeliveryResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCheckoutPaymentParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCheckoutPaymentResponse(params: StoreCheckoutService.StoreCheckoutGetCheckoutPaymentParams): __Observable<__StrictHttpResponse<ResponseArgsOfPaymentDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/payment`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfPaymentDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetCheckoutPaymentParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetCheckoutPayment(params: StoreCheckoutService.StoreCheckoutGetCheckoutPaymentParams): __Observable<ResponseArgsOfPaymentDTO> {
    return this.StoreCheckoutGetCheckoutPaymentResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfPaymentDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetPaymentTypeParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `paymentType`:
   *
   * - `locale`:
   */
  StoreCheckoutSetPaymentTypeResponse(params: StoreCheckoutService.StoreCheckoutSetPaymentTypeParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.paymentType != null) __params = __params.set('paymentType', params.paymentType.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/payment`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetPaymentTypeParams` containing the following parameters:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `paymentType`:
   *
   * - `locale`:
   */
  StoreCheckoutSetPaymentType(params: StoreCheckoutService.StoreCheckoutSetPaymentTypeParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetPaymentTypeResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetDeliveryPaymentParams` containing the following parameters:
   *
   * - `deliveryId`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetDeliveryPaymentResponse(params: StoreCheckoutService.StoreCheckoutGetDeliveryPaymentParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfSelectionDTOOfPaymentType>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/delivery/${encodeURIComponent(params.deliveryId)}/payment`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfSelectionDTOOfPaymentType>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetDeliveryPaymentParams` containing the following parameters:
   *
   * - `deliveryId`:
   *
   * - `checkoutId`:
   *
   * - `locale`:
   */
  StoreCheckoutGetDeliveryPayment(params: StoreCheckoutService.StoreCheckoutGetDeliveryPaymentParams): __Observable<ResponseArgsOfIEnumerableOfSelectionDTOOfPaymentType> {
    return this.StoreCheckoutGetDeliveryPaymentResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfSelectionDTOOfPaymentType)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetNotificationChannelsParams` containing the following parameters:
   *
   * - `notificationChannel`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetNotificationChannelsResponse(params: StoreCheckoutService.StoreCheckoutSetNotificationChannelsParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.notificationChannel;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'PUT',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/notificationchannel`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutSetNotificationChannelsParams` containing the following parameters:
   *
   * - `notificationChannel`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutSetNotificationChannels(params: StoreCheckoutService.StoreCheckoutSetNotificationChannelsParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutSetNotificationChannelsResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutAddVoucherParams` containing the following parameters:
   *
   * - `voucherCode`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutAddVoucherResponse(params: StoreCheckoutService.StoreCheckoutAddVoucherParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.voucherCode;

    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/vouchers`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutAddVoucherParams` containing the following parameters:
   *
   * - `voucherCode`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutAddVoucher(params: StoreCheckoutService.StoreCheckoutAddVoucherParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutAddVoucherResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteVoucherParams` containing the following parameters:
   *
   * - `voucherId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteVoucherResponse(params: StoreCheckoutService.StoreCheckoutDeleteVoucherParams): __Observable<__StrictHttpResponse<ResponseArgsOfCheckoutDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;


    if (params.returnCheckout != null) __params = __params.set('returnCheckout', params.returnCheckout.toString());
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'DELETE',
      this.rootUrl + `/store/checkout/${encodeURIComponent(params.checkoutId)}/vouchers/${encodeURIComponent(params.voucherId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfCheckoutDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutDeleteVoucherParams` containing the following parameters:
   *
   * - `voucherId`:
   *
   * - `checkoutId`:
   *
   * - `returnCheckout`:
   *
   * - `locale`:
   */
  StoreCheckoutDeleteVoucher(params: StoreCheckoutService.StoreCheckoutDeleteVoucherParams): __Observable<ResponseArgsOfCheckoutDTO> {
    return this.StoreCheckoutDeleteVoucherResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfCheckoutDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetAvailabilitiesParams` containing the following parameters:
   *
   * - `shopItems`:
   *
   * - `locale`:
   */
  StoreCheckoutGetAvailabilitiesResponse(params: StoreCheckoutService.StoreCheckoutGetAvailabilitiesParams): __Observable<__StrictHttpResponse<ResponseArgsOfIEnumerableOfAvailabilityDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    __body = params.shopItems;
    if (params.locale != null) __params = __params.set('locale', params.locale.toString());
    let req = new HttpRequest<any>(
      'POST',
      this.rootUrl + `/store/checkout/availability`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfIEnumerableOfAvailabilityDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetAvailabilitiesParams` containing the following parameters:
   *
   * - `shopItems`:
   *
   * - `locale`:
   */
  StoreCheckoutGetAvailabilities(params: StoreCheckoutService.StoreCheckoutGetAvailabilitiesParams): __Observable<ResponseArgsOfIEnumerableOfAvailabilityDTO> {
    return this.StoreCheckoutGetAvailabilitiesResponse(params).pipe(
      __map(_r => _r.body as ResponseArgsOfIEnumerableOfAvailabilityDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetVATsParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   */
  StoreCheckoutGetVATsResponse(params: StoreCheckoutService.StoreCheckoutGetVATsParams): __Observable<__StrictHttpResponse<ListResponseArgsOfVATDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    if (params.take != null) __params = __params.set('take', params.take.toString());
    if (params.skip != null) __params = __params.set('skip', params.skip.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/vat`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ListResponseArgsOfVATDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetVATsParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   */
  StoreCheckoutGetVATs(params: StoreCheckoutService.StoreCheckoutGetVATsParams): __Observable<ListResponseArgsOfVATDTO> {
    return this.StoreCheckoutGetVATsResponse(params).pipe(
      __map(_r => _r.body as ListResponseArgsOfVATDTO)
    );
  }

  /**
   * @param vatId undefined
   */
  StoreCheckoutGetVATResponse(vatId: number): __Observable<__StrictHttpResponse<ResponseArgsOfVATDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/vat/${encodeURIComponent(vatId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfVATDTO>;
      })
    );
  }
  /**
   * @param vatId undefined
   */
  StoreCheckoutGetVAT(vatId: number): __Observable<ResponseArgsOfVATDTO> {
    return this.StoreCheckoutGetVATResponse(vatId).pipe(
      __map(_r => _r.body as ResponseArgsOfVATDTO)
    );
  }

  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetLogisticiansParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   */
  StoreCheckoutGetLogisticiansResponse(params: StoreCheckoutService.StoreCheckoutGetLogisticiansParams): __Observable<__StrictHttpResponse<ListResponseArgsOfLogisticianDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;
    if (params.take != null) __params = __params.set('take', params.take.toString());
    if (params.skip != null) __params = __params.set('skip', params.skip.toString());
    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/logistician`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ListResponseArgsOfLogisticianDTO>;
      })
    );
  }
  /**
   * @param params The `StoreCheckoutService.StoreCheckoutGetLogisticiansParams` containing the following parameters:
   *
   * - `take`:
   *
   * - `skip`:
   */
  StoreCheckoutGetLogisticians(params: StoreCheckoutService.StoreCheckoutGetLogisticiansParams): __Observable<ListResponseArgsOfLogisticianDTO> {
    return this.StoreCheckoutGetLogisticiansResponse(params).pipe(
      __map(_r => _r.body as ListResponseArgsOfLogisticianDTO)
    );
  }

  /**
   * @param logisticianId undefined
   */
  StoreCheckoutGetLogisticianByIdResponse(logisticianId: number): __Observable<__StrictHttpResponse<ResponseArgsOfLogisticianDTO>> {
    let __params = this.newParams();
    let __headers = new HttpHeaders();
    let __body: any = null;

    let req = new HttpRequest<any>(
      'GET',
      this.rootUrl + `/store/checkout/logistician/${encodeURIComponent(logisticianId)}`,
      __body,
      {
        headers: __headers,
        params: __params,
        responseType: 'json'
      });

    return this.http.request<any>(req).pipe(
      __filter(_r => _r instanceof HttpResponse),
      __map((_r) => {
        return _r as __StrictHttpResponse<ResponseArgsOfLogisticianDTO>;
      })
    );
  }
  /**
   * @param logisticianId undefined
   */
  StoreCheckoutGetLogisticianById(logisticianId: number): __Observable<ResponseArgsOfLogisticianDTO> {
    return this.StoreCheckoutGetLogisticianByIdResponse(logisticianId).pipe(
      __map(_r => _r.body as ResponseArgsOfLogisticianDTO)
    );
  }
}

module StoreCheckoutService {

  /**
   * Parameters for StoreCheckoutCanAddItem
   */
  export interface StoreCheckoutCanAddItemParams {

    /**
     * Warenkorb PK
     */
    shoppingCartId: number;

    /**
     * Daten
     */
    payload: ItemPayload;

    /**
     * Lokalisierung
     */
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCanAddItems
   */
  export interface StoreCheckoutCanAddItemsParams {

    /**
     * Warenkorb PK
     */
    shoppingCartId: number;

    /**
     * Daten
     */
    payload: Array<ItemPayload>;

    /**
     * Lokalisierung
     */
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCanAddBuyer
   */
  export interface StoreCheckoutCanAddBuyerParams {

    /**
     * Warenkorb PK
     */
    shoppingCartId: number;

    /**
     * Daten
     */
    payload: BuyerPayload;

    /**
     * Lokalisierung
     */
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCanAddDestination
   */
  export interface StoreCheckoutCanAddDestinationParams {

    /**
     * Warenkorb PK
     */
    shoppingCartId: number;

    /**
     * Daten
     */
    payload: DestinationDTO;

    /**
     * Lokalisierung
     */
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetLogisticianOnDestinationsByBuyer
   */
  export interface StoreCheckoutSetLogisticianOnDestinationsByBuyerParams {

    /**
     * Warenkorb PK
     */
    shoppingCartId: number;

    /**
     * Daten
     */
    payload: BuyerPayload;

    /**
     * Lokalisierung
     */
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutAddItemToShoppingCart
   */
  export interface StoreCheckoutAddItemToShoppingCartParams {
    shoppingCartId: number;
    items: Array<AddToShoppingCartDTO>;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetShoppingCart
   */
  export interface StoreCheckoutGetShoppingCartParams {
    shoppingCartId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutUpdateShoppingCartItem
   */
  export interface StoreCheckoutUpdateShoppingCartItemParams {
    values: UpdateShoppingCartItemDTO;
    shoppingCartItemId: number;
    shoppingCartId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutUpdateShoppingCartItemAvailability
   */
  export interface StoreCheckoutUpdateShoppingCartItemAvailabilityParams {
    shoppingCartItemId: number;
    shoppingCartId: number;
    availability: AvailabilityDTO;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutDeleteShoppingCartItemAvailability
   */
  export interface StoreCheckoutDeleteShoppingCartItemAvailabilityParams {
    shoppingCartItemId: number;
    shoppingCartId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutUpdateShoppingCartItemPromotion
   */
  export interface StoreCheckoutUpdateShoppingCartItemPromotionParams {
    shoppingCartItemId: number;
    shoppingCartId: number;
    promotion: PromotionDTO;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutDeleteShoppingCartItemPromotion
   */
  export interface StoreCheckoutDeleteShoppingCartItemPromotionParams {
    shoppingCartItemId: number;
    shoppingCartId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCreateShoppingCartAndAddItem
   */
  export interface StoreCheckoutCreateShoppingCartAndAddItemParams {
    items: Array<AddToShoppingCartDTO>;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutRequiredDataForPayer
   */
  export interface StoreCheckoutRequiredDataForPayerParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutRequiredDataForDelivery
   */
  export interface StoreCheckoutRequiredDataForDeliveryParams {
    destinationId: number;
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCreateOrRefreshCheckout
   */
  export interface StoreCheckoutCreateOrRefreshCheckoutParams {
    shoppingCartId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutDiscardCheckout
   */
  export interface StoreCheckoutDiscardCheckoutParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetCheckout
   */
  export interface StoreCheckoutGetCheckoutParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutResetCheckout
   */
  export interface StoreCheckoutResetCheckoutParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCurrentCheckoutStep
   */
  export interface StoreCheckoutCurrentCheckoutStepParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutEmailExists
   */
  export interface StoreCheckoutEmailExistsParams {
    checkoutPId: string;
    locale?: null | string;
    email?: null | string;
    checkoutId?: number;
  }

  /**
   * Parameters for StoreCheckoutSetAccountValues
   */
  export interface StoreCheckoutSetAccountValuesParams {
    checkoutId: number;
    accountValuesDTO: UserAccountDTO;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetBuyer
   */
  export interface StoreCheckoutSetBuyerParams {
    checkoutId: number;
    buyerDTO: BuyerDTO;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetBuyer2
   */
  export interface StoreCheckoutSetBuyer2Params {
    checkoutId: number;
    buyerDTO: BuyerDTO;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetPayer
   */
  export interface StoreCheckoutSetPayerParams {
    payerDTO: PayerDTO;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetPayer2
   */
  export interface StoreCheckoutSetPayer2Params {
    payerDTO: PayerDTO;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetSuppliers
   */
  export interface StoreCheckoutGetSuppliersParams {
    take?: null | number;
    skip?: null | number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCreateDestination
   */
  export interface StoreCheckoutCreateDestinationParams {
    destinationDTO: DestinationDTO;
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutUpdateDestination
   */
  export interface StoreCheckoutUpdateDestinationParams {
    destinationId: number;
    destinationDTO: DestinationDTO;
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutDeleteDestination
   */
  export interface StoreCheckoutDeleteDestinationParams {
    destinationId: number;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetDeliveries
   */
  export interface StoreCheckoutGetDeliveriesParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutCreateDelivery
   */
  export interface StoreCheckoutCreateDeliveryParams {
    deliveryContainer: DeliveryContainer;
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutUpdateDelivery
   */
  export interface StoreCheckoutUpdateDeliveryParams {
    deliveryId: number;
    deliveryContainer: DeliveryContainer;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetBranchesByCheckout
   */
  export interface StoreCheckoutGetBranchesByCheckoutParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetBranches
   */
  export interface StoreCheckoutGetBranchesParams {
    take?: null | number;
    skip?: null | number;
    locale?: null | string;
    labelOnly?: boolean;
  }

  /**
   * Parameters for StoreCheckoutQueryBranches
   */
  export interface StoreCheckoutQueryBranchesParams {
    queryToken: BranchQueryTokenDTO;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetCountriesByCheckout
   */
  export interface StoreCheckoutGetCountriesByCheckoutParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetCountries
   */
  export interface StoreCheckoutGetCountriesParams {
    take?: null | number;
    skip?: null | number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutUpdateCheckoutItem
   */
  export interface StoreCheckoutUpdateCheckoutItemParams {
    checkoutItemId: number;
    checkoutId: number;
    returnCheckout?: boolean;
    quantity?: null | number;
    locale?: null | string;
    deliveryId?: number;
  }

  /**
   * Parameters for StoreCheckoutDeleteCheckoutItem
   */
  export interface StoreCheckoutDeleteCheckoutItemParams {
    checkoutItemId: number;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetDelivery
   */
  export interface StoreCheckoutSetDeliveryParams {
    items: Array<KeyValuePairOfEntityDTOContainerOfCheckoutItemDTOAndNullableDecimal>;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
    deliveryId?: number;
  }

  /**
   * Parameters for StoreCheckoutGetCheckoutPayment
   */
  export interface StoreCheckoutGetCheckoutPaymentParams {
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetPaymentType
   */
  export interface StoreCheckoutSetPaymentTypeParams {
    checkoutId: number;
    returnCheckout?: boolean;
    paymentType?: 0 | 1 | 2 | 4 | 8 | 16 | 32 | 64 | 128 | 256 | 512 | 1024 | 2048 | 4096 | 8192 | 16384 | 32768;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetDeliveryPayment
   */
  export interface StoreCheckoutGetDeliveryPaymentParams {
    deliveryId: number;
    checkoutId: number;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutSetNotificationChannels
   */
  export interface StoreCheckoutSetNotificationChannelsParams {
    notificationChannel: NotificationChannel;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutAddVoucher
   */
  export interface StoreCheckoutAddVoucherParams {
    voucherCode: string;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutDeleteVoucher
   */
  export interface StoreCheckoutDeleteVoucherParams {
    voucherId: number;
    checkoutId: number;
    returnCheckout?: boolean;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetAvailabilities
   */
  export interface StoreCheckoutGetAvailabilitiesParams {
    shopItems: Array<number>;
    locale?: null | string;
  }

  /**
   * Parameters for StoreCheckoutGetVATs
   */
  export interface StoreCheckoutGetVATsParams {
    take?: null | number;
    skip?: null | number;
  }

  /**
   * Parameters for StoreCheckoutGetLogisticians
   */
  export interface StoreCheckoutGetLogisticiansParams {
    take?: null | number;
    skip?: null | number;
  }
}

export { StoreCheckoutService }
