@tripian/core 9.3.6 → 9.3.7

package/api/API.js

@@ -0,0 +1,1663 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-param-reassign */
+// eslint-disable-next-line import/no-extraneous-dependencies
+const model_1 = __importStar(require("@tripian/model"));
+const moment_1 = __importDefault(require("moment"));
+// import XHR from '../xhr/xhr';
+const xhrFetch_1 = __importDefault(require("../xhr/xhrFetch"));
+const APICONST_1 = __importDefault(require("./const/APICONST"));
+const easy_1 = __importDefault(require("../easy/easy"));
+const Cached_1 = __importDefault(require("../easy/handle/cache/Cached"));
+const cacheCommon_1 = require("../easy/handle/cache/cacheCommon");
+const dataClear_1 = __importDefault(require("../data/dataClear"));
+const sleep = async (milisecond = 750) => {
+    // console.log(milisecond, 'sn uyumaya geldik');
+    return new Promise((resolve) => setTimeout(() => resolve(true), milisecond));
+};
+class API {
+    constructor(apiSettings, lang, useCache) {
+        this.getToken = () => this.xhr.getToken();
+        this.setToken = (token) => this.xhr.setToken(token);
+        this.removeToken = () => this.xhr.removeToken();
+        this.setLang = (lang) => {
+            this.lang = lang;
+            this.xhr.setLang(lang);
+        };
+        this.configList = () => this.xhr.req(APICONST_1.default.CONFIG.METHOD)(APICONST_1.default.CONFIG.PATH, APICONST_1.default.CONFIG.DATA_KEY);
+        /**
+         ******************************************************************************
+         *
+         * Cities
+         *
+         */
+        this.citiesPage = async (page, limit = 1000) => {
+            return this.xhr.reqWithPage(APICONST_1.default.CITIES.METHOD)(APICONST_1.default.CITIES.PATH, APICONST_1.default.CITIES.DATA_KEY, {
+                limit,
+                page,
+            });
+        };
+        this.citiesAll = async () => {
+            var _a, _b;
+            const hierarchy = (cs) => {
+                return cs;
+                /* const csClone = helper.deepCopy(cs);
+                csClone.forEach((c: Model.City) => {
+                  if (c.parentLocationId !== null) {
+                    const parentName: string = cs.find((x) => x.id === c.parentLocationId)?.name || '';
+          
+                    if (parentName !== '') {
+                      c.name += ` - ${parentName}`;
+                    }
+                  }
+                });
+                return csClone; */
+            };
+            if (!this.forceRequest) {
+                const cachedCities = Cached_1.default.cities(this.lang);
+                if (cachedCities)
+                    return Promise.resolve(hierarchy(cachedCities));
+            }
+            // Dynamic Paging
+            let responseCities = [];
+            let pageNumber = 0;
+            let lastPage = false;
+            while (!lastPage) {
+                pageNumber += 1;
+                // eslint-disable-next-line no-await-in-loop
+                const responsePage = await this.citiesPage(pageNumber);
+                responseCities = responseCities.concat(responsePage.data);
+                // if (responsePage.pagination?.links.next === null) lastPage = true;
+                if (responsePage.pagination && ((_a = responsePage.pagination) === null || _a === void 0 ? void 0 : _a.currentPage) === ((_b = responsePage.pagination) === null || _b === void 0 ? void 0 : _b.totalPages))
+                    lastPage = true;
+            }
+            return Promise.resolve(hierarchy(responseCities));
+        };
+        this.city = async (cityId) => {
+            if (!this.forceRequest) {
+                const cachedCity = Cached_1.default.city(this.lang, cityId);
+                if (cachedCity)
+                    return Promise.resolve(cachedCity);
+            }
+            return this.xhr.req(APICONST_1.default.CITY.METHOD)(easy_1.default.setParameterId(APICONST_1.default.CITY.PATH, cityId, 'cityId'), APICONST_1.default.CITY.DATA_KEY);
+        };
+        this.cityInfo = async (cityId) => {
+            if (!this.forceRequest) {
+                const cachedCityInfo = Cached_1.default.cityInfo(this.lang, cityId);
+                if (cachedCityInfo)
+                    return Promise.resolve(cachedCityInfo);
+            }
+            return this.xhr.req(APICONST_1.default.CITY_INFO.METHOD)(easy_1.default.setParameterId(APICONST_1.default.CITY_INFO.PATH, cityId, 'cityId'), APICONST_1.default.CITY_INFO.DATA_KEY);
+        };
+        this.cityEvents = async (cityId) => {
+            if (!this.forceRequest) {
+                const cachedCityEvents = Cached_1.default.citiesEvents(this.lang, cityId);
+                if (cachedCityEvents)
+                    return Promise.resolve(cachedCityEvents);
+            }
+            return this.xhr.req(APICONST_1.default.CITY_EVENTS.METHOD)(easy_1.default.setParameterId(APICONST_1.default.CITY_EVENTS.PATH, cityId, 'cityId'), APICONST_1.default.CITY_EVENTS.DATA_KEY);
+        };
+        this.citiesSearch = async (name) => this.xhr.req(APICONST_1.default.CITIES.METHOD)(APICONST_1.default.CITIES.PATH, APICONST_1.default.CITIES.DATA_KEY, { search: name });
+        this.cityFind = async ({ lat, lng }) => this.xhr.req(APICONST_1.default.CITIES.METHOD)(APICONST_1.default.CITIES.PATH, APICONST_1.default.CITIES.DATA_KEY, { coordinate: `${lat},${lng}` });
+        /**
+         * POI
+         */
+        // poiCategories = async (limit: number = 100): Promise<Model.PoiCategory[]> => {
+        //   if (!this.forceRequest) {
+        //     const poiCategories = Cached.poiCategories(this.lang);
+        //     if (poiCategories) {
+        //       return poiCategories;
+        //     }
+        //   }
+        //   return this.xhr.req(API_CONST.POI_CATEGORIES.METHOD)<Model.PoiCategory[]>(API_CONST.POI_CATEGORIES.PATH, API_CONST.POI_CATEGORIES.DATA_KEY, {
+        //     limit,
+        //   });
+        // };
+        this.suggestCity = async (text) => this.xhr.req(APICONST_1.default.SUGGEST_CITY.METHOD)(APICONST_1.default.SUGGEST_CITY.PATH, APICONST_1.default.SUGGEST_CITY.DATA_KEY, {
+            text,
+        });
+        this.poiCategories = async (limit = 100, version = 2) => {
+            if (!this.forceRequest) {
+                const poiCategories = Cached_1.default.poiCategories(this.lang);
+                if (poiCategories) {
+                    return poiCategories;
+                }
+            }
+            return this.xhr.req(APICONST_1.default.POI_CATEGORIES.METHOD)(APICONST_1.default.POI_CATEGORIES.PATH, APICONST_1.default.POI_CATEGORIES.DATA_KEY, {
+                version,
+                limit,
+            });
+        };
+        this.poisSearch = async (poisRequest) => this.xhr.reqWithPage(APICONST_1.default.POIS.METHOD)(APICONST_1.default.POIS.PATH, APICONST_1.default.POIS.DATA_KEY, {
+            ...poisRequest,
+            withOffers: poisRequest.withOffers,
+        });
+        this.poisNameSearch = async ({ cityId, search, poiCategories, showOffersOnly = true, showBookingsOnly = false, limit = 100, page = 1, }) => {
+            if (!this.forceRequest) {
+                if (search === '' && poiCategories && poiCategories.length > 0 && page === 1) {
+                    const cachedPoisAll = Cached_1.default.poisAll(this.lang, cityId || 0, poiCategories, Number(showOffersOnly), Number(showBookingsOnly));
+                    if (cachedPoisAll)
+                        return Promise.resolve(cachedPoisAll);
+                }
+            }
+            return this.poisSearch({
+                cityId,
+                search,
+                poiCategories,
+                withOffers: Number(showOffersOnly),
+                limit: limit > 100 ? limit : limit,
+                page,
+            }).then((resultPoisDataPayload) => {
+                const resultPoisDataPayloadActives = {
+                    ...resultPoisDataPayload,
+                    data: resultPoisDataPayload.data.filter((p) => p.status),
+                };
+                return resultPoisDataPayloadActives;
+            });
+        };
+        this.poisOpenSearch = async ({ cityId, search, poiCategories, showOffersOnly, showBookingsOnly, showBookingsRestaurant, showHotelRecommended, showVisaDestinations, limit = 100, page = 1, }) => {
+            if (!this.forceRequest) {
+                if (search === '' && poiCategories && poiCategories.length > 0 && page === 1) {
+                    const cachedPoisAll = Cached_1.default.poisAll(this.lang, cityId || 0, poiCategories, Number(showOffersOnly), Number(showBookingsOnly));
+                    if (cachedPoisAll)
+                        return Promise.resolve(cachedPoisAll);
+                }
+            }
+            return this.xhr.reqWithPage(APICONST_1.default.POIS.METHOD)(APICONST_1.default.POIS_OPEN_SEARCH.PATH, APICONST_1.default.POIS_OPEN_SEARCH.DATA_KEY, {
+                cityId,
+                search,
+                poiCategories,
+                showOffersOnly: Number(showOffersOnly),
+                withBookings: Number(showBookingsOnly),
+                withBookingsRestaurant: Number(showBookingsRestaurant),
+                hotelRecommended: Number(showHotelRecommended),
+                visaDestinations: Number(showVisaDestinations),
+                limit,
+                page,
+            });
+        };
+        this.poisOpenSearchSort = async ({ cityId, search, poiCategories, showOffersOnly, showBookingsOnly, limit = 100, page = 1, sort, rating, }) => {
+            if (!this.forceRequest) {
+                if (search === '' && poiCategories && poiCategories.length > 0 && page === 1) {
+                    const cachedPoisAll = Cached_1.default.poisAll(this.lang, cityId || 0, poiCategories, Number(showOffersOnly), Number(showBookingsOnly));
+                    if (cachedPoisAll)
+                        return Promise.resolve(cachedPoisAll);
+                }
+            }
+            return this.xhr.reqWithPage(APICONST_1.default.POIS.METHOD)(APICONST_1.default.POIS_OPEN_SEARCH.PATH, APICONST_1.default.POIS_OPEN_SEARCH.DATA_KEY, {
+                cityId,
+                search,
+                poiCategories,
+                showOffersOnly: Number(showOffersOnly),
+                withBookings: Number(showBookingsOnly),
+                limit,
+                page,
+                sort,
+                rating,
+            });
+        };
+        this.poisSearchAutoComplete = async () => {
+            return this.xhr
+                .req(APICONST_1.default.POIS_SEARCH_AUTO_COMPLETE.METHOD)(APICONST_1.default.POIS_SEARCH_AUTO_COMPLETE.PATH, APICONST_1.default.POIS_SEARCH_AUTO_COMPLETE.DATA_KEY)
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        this.poisSearchAutoCompleteTags = async (cityId, poiCategories) => {
+            if (!this.forceRequest) {
+                if (poiCategories && poiCategories.length > 0) {
+                    const cachedTagsAll = Cached_1.default.autoCompleteTagsAll(this.lang, cityId || 0, poiCategories);
+                    if (cachedTagsAll)
+                        return Promise.resolve(cachedTagsAll);
+                }
+            }
+            return this.xhr
+                .req(APICONST_1.default.POIS_SEARCH_AUTO_COMPLETE_TAGS.METHOD)(APICONST_1.default.POIS_SEARCH_AUTO_COMPLETE_TAGS.PATH, APICONST_1.default.POIS_SEARCH_AUTO_COMPLETE_TAGS.DATA_KEY, { cityId, poiCategories: poiCategories || undefined })
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        this.poisCoordinateSearch = async ({ poiCategories, coordinate, distance, bounds, showOffersOnly, limit, }) => this.poisSearch({
+            poiCategories,
+            coordinate,
+            distance,
+            bounds,
+            withOffers: Number(showOffersOnly),
+            limit,
+        }).then((dataPayloadResult) => dataPayloadResult.data);
+        this.poisMustTrySearch = async ({ cityId, mustTryIds, limit = 100 }) => this.poisSearch({
+            cityId,
+            mustTryIds,
+            limit,
+        }).then((resultPoisDataPayload) => resultPoisDataPayload.data.filter((p) => p.status));
+        this.pois = async (poiIds, withOffers, cityId, force = false) => {
+            const uniquePoiIds = model_1.helper.removeDuplicateValues(poiIds, (p1, p2) => p1 === p2);
+            if (!this.forceRequest && !force) {
+                const cachedPois = Cached_1.default.pois(this.lang, withOffers, uniquePoiIds);
+                if (cachedPois)
+                    return Promise.resolve(cachedPois);
+            }
+            return this.poisSearch({ poiIds: uniquePoiIds.join(','), withOffers, cityId }).then((dataPayloadResult) => dataPayloadResult.data);
+        };
+        this.poi = async (poiId, withOffers = 1) => {
+            if (!this.forceRequest) {
+                const cachedPoi = Cached_1.default.poi(this.lang, poiId);
+                if (cachedPoi)
+                    return Promise.resolve(cachedPoi);
+            }
+            return this.xhr.req(APICONST_1.default.POI.METHOD)(easy_1.default.setParameterId(APICONST_1.default.POI.PATH, poiId, 'poiId'), APICONST_1.default.POI.DATA_KEY, {
+                withOffers,
+            });
+        };
+        this.customPois = async (name) => {
+            return this.xhr.req(APICONST_1.default.CUSTOM_POIS.METHOD)(APICONST_1.default.CUSTOM_POIS.PATH, APICONST_1.default.CUSTOM_POIS.DATA_KEY, {
+                search: name,
+            });
+        };
+        /**
+         * Top 10
+         */
+        this.topTen = (cityId, poiCategories) => {
+            if (!this.forceRequest) {
+                const cachedTopTen = Cached_1.default.topTen(this.lang, cityId);
+                if (cachedTopTen)
+                    return Promise.resolve(cachedTopTen);
+            }
+            return this.xhr.req(APICONST_1.default.TOP_TEN.METHOD)(APICONST_1.default.TOP_TEN.PATH, APICONST_1.default.TOP_TEN.DATA_KEY, {
+                cityId,
+                poiCategories,
+            });
+        };
+        /**
+         * Registers
+         */
+        this.register = async (registerRequest) => {
+            return this.xhr.req(APICONST_1.default.REGISTER.METHOD)(APICONST_1.default.REGISTER.PATH, APICONST_1.default.REGISTER.DATA_KEY, registerRequest);
+        };
+        /**
+         * Guest
+         */
+        this.loginGuest = async (uniqueId) => {
+            return this.xhr.req(APICONST_1.default.LOGIN_GUEST.METHOD)(APICONST_1.default.LOGIN_GUEST.PATH, APICONST_1.default.LOGIN_GUEST.DATA_KEY, {
+                email: `${uniqueId}@tripianguest.com`,
+                password: 'tripian123.',
+            });
+            // .then(() => this.refreshToken());
+        };
+        /**
+         * Logins
+         */
+        this.login = async (loginRequest) => {
+            return this.xhr.req(APICONST_1.default.LOGIN.METHOD)(APICONST_1.default.LOGIN.PATH, APICONST_1.default.LOGIN.DATA_KEY, loginRequest);
+            // .then(() => this.refreshToken());
+        };
+        this.loginEmail = async (email, password, business) => this.login({ email, password, business });
+        this.loginCognito = async (code, redirectUrl, device) => this.xhr.req(APICONST_1.default.LOGIN_COGNITO.METHOD)(APICONST_1.default.LOGIN_COGNITO.PATH, APICONST_1.default.LOGIN_COGNITO.DATA_KEY, {
+            code,
+            redirectUrl,
+            device,
+        });
+        // logout = async (): Promise<Model.DeleteUpdateResponse> => {
+        //   return this.xhr
+        //     .req(API_CONST.LOGOUT.METHOD)<Model.DeleteUpdateResponse>(API_CONST.LOGOUT.PATH, API_CONST.LOGOUT.DATA_KEY, {
+        //       refreshToken: this.getToken()?.refreshToken,
+        //     })
+        //     .then((update: Model.DeleteUpdateResponse) => {
+        //       this.removeToken();
+        //       dataClear();
+        //       return update;
+        //     });
+        // };
+        this.logout = () => {
+            this.removeToken();
+            (0, dataClear_1.default)();
+        };
+        // Light
+        this.lightRegisterLogin = async (uniqueId) => {
+            return this.xhr.req(APICONST_1.default.LIGHT_REGISTER_LOGIN.METHOD)(APICONST_1.default.LIGHT_REGISTER_LOGIN.PATH, APICONST_1.default.LIGHT_REGISTER_LOGIN.DATA_KEY, { uniqueId });
+        };
+        this.lightLoginHash = async (tripHash) => {
+            return this.xhr.req(APICONST_1.default.LIGHT_HASH_LOGIN.METHOD)(APICONST_1.default.LIGHT_HASH_LOGIN.PATH, APICONST_1.default.LIGHT_HASH_LOGIN.DATA_KEY, {
+                tripHash,
+            });
+        };
+        this.refreshToken = async (force = false) => {
+            const accessTokenLiveSeconds = 60 * 60; // 1 hour - access token live.
+            const accessTokenStartBufferSeconds = 6 * 60; // 6 mins - if ex access token will expire in 6 minutes for init; force refresh now
+            const accessTokenEndBufferSeconds = 60; // 1 min - if any access token will expire in 1 minutes; force refresh now. if access token will expire 60 minutes later(means access token is new); force refresh 59 minutes later
+            const refreshTokenEndBufferSeconds = 60 * 60 * 24; // 1 day - if refresh token will expire in 24 hours for init; force login
+            const currentToken = this.xhr.getToken();
+            /* console.log('refreshToken fn called. force: ', force); */
+            if (currentToken) {
+                /**
+                 * xhr has token object
+                 */
+                const tokenPayload = easy_1.default.parseToken(currentToken);
+                if (tokenPayload) {
+                    /**
+                     * FORCE refresh token
+                     */
+                    if (force) {
+                        /* console.log('refreshToken fn: force calling'); */
+                        return this.xhr
+                            .req(APICONST_1.default.REFRESH_TOKEN.METHOD)(APICONST_1.default.REFRESH_TOKEN.PATH, APICONST_1.default.REFRESH_TOKEN.DATA_KEY, {
+                            refreshToken: currentToken.refreshToken,
+                        })
+                            .then((token) => {
+                            const fullToken = { ...token, refreshToken: currentToken.refreshToken };
+                            this.setToken(fullToken);
+                            /* console.log('refreshToken fn: force called, token set'); */
+                            /**
+                             * set timeout refresh access_token at live - end buffer (end of 59. min)
+                             */
+                            /* console.log(
+                              'refreshToken fn: force called, settimeout set after (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000',
+                              (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000,
+                            ); */
+                            setTimeout(() => {
+                                this.refreshToken(true);
+                                /* console.log('refreshToken fn: force called, OK after (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000'); */
+                            }, (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000);
+                            return fullToken;
+                        });
+                    }
+                    /**
+                     * xhr token object is valid
+                     */
+                    const accessTokenExpireSeconds = easy_1.default.accessTokenExpSecond(tokenPayload);
+                    if (accessTokenExpireSeconds > accessTokenStartBufferSeconds) {
+                        /* console.log(
+                          'refreshToken fn: accessTokenExpireSeconds > accessTokenStartBufferSeconds',
+                          accessTokenExpireSeconds,
+                          accessTokenStartBufferSeconds,
+                        ); */
+                        /**
+                         * access_token is still valid
+                         */
+                        /**
+                         * set timeout refresh access_token before end buffer expire - (1 min)
+                         */
+                        /* console.log(
+                          'refreshToken fn: accessTokenExpireSeconds > accessTokenStartBufferSeconds. settimeout set after (accessTokenExpireSeconds - accessTokenEndBufferSeconds) * 1000:',
+                          (accessTokenExpireSeconds - accessTokenEndBufferSeconds) * 1000,
+                        ); */
+                        setTimeout(() => {
+                            this.refreshToken(true);
+                            /* console.log(
+                              'refreshToken fn: accessTokenExpireSeconds > accessTokenStartBufferSeconds. OK after (accessTokenExpireSeconds - accessTokenEndBufferSeconds) * 1000:',
+                            ); */
+                        }, (accessTokenExpireSeconds - accessTokenEndBufferSeconds) * 1000);
+                        /**
+                         * access_token is still valid
+                         * returned currentToken.
+                         */
+                        return new Promise((resolve) => resolve(currentToken));
+                    }
+                    // console.log(
+                    //   'refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds:',
+                    //   accessTokenExpireSeconds,
+                    //   accessTokenStartBufferSeconds,
+                    // );
+                    /**
+                     * access_token expired or expire impending in start buffer
+                     */
+                    const { refreshToken } = currentToken;
+                    const refreshTokenExpireSeconds = easy_1.default.refreshTokenExpSecond(tokenPayload);
+                    /**
+                     * If refresh token will not expire refresh end buffer (today)
+                     */
+                    if (refreshTokenExpireSeconds > refreshTokenEndBufferSeconds) {
+                        /* console.log(
+                          'refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds and',
+                          'refreshTokenExpireSeconds > refreshTokenEndBufferSeconds: ',
+                          refreshTokenExpireSeconds,
+                          refreshTokenEndBufferSeconds,
+                        ); */
+                        /**
+                         * refresh_token is still valid
+                         * we will refresh access_token here.
+                         */
+                        /* console.log('refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds. refresh calling'); */
+                        return this.xhr
+                            .req(APICONST_1.default.REFRESH_TOKEN.METHOD)(APICONST_1.default.REFRESH_TOKEN.PATH, APICONST_1.default.REFRESH_TOKEN.DATA_KEY, {
+                            refreshToken,
+                        })
+                            .then((token) => {
+                            const fullToken = { ...token, refreshToken };
+                            this.setToken(fullToken);
+                            /* console.log('refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds, token set'); */
+                            /**
+                             * set timeout refresh access_token at live - end buffer (end of 59. min)
+                             */
+                            /* console.log(
+                              'refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds, settimeout set after (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000',
+                              (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000,
+                            ); */
+                            setTimeout(() => {
+                                this.refreshToken(true);
+                                /* console.log(
+                                  'refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds, OK after (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000',
+                                ); */
+                            }, (accessTokenLiveSeconds - accessTokenEndBufferSeconds) * 1000);
+                            return fullToken;
+                        });
+                    }
+                    /* console.log(
+                      'refreshToken fn: accessTokenExpireSeconds <= accessTokenStartBufferSeconds and',
+                      'refreshTokenExpireSeconds <= refreshTokenEndBufferSeconds: ',
+                      refreshTokenExpireSeconds,
+                      refreshTokenEndBufferSeconds,
+                      'ERROR',
+                    ); */
+                    /**
+                     * refresh_token expired or expire impending (in 1 day)
+                     */
+                    // console.log('Tcore refresh token expired');
+                    throw new Error('Tcore refresh token expired');
+                }
+                /**
+                 * xhr token object is invalid
+                 */
+                // console.log("Tcore doesn't have a valid token object"); // eslint-disable-line quotes
+                throw new Error("Tcore doesn't have a valid token object"); // eslint-disable-line quotes
+            }
+            /**
+             * xhr has not token object
+             */
+            // eslint-disable-next-line quotes
+            // console.log("Tcore doesn't have a token object"); // eslint-disable-line quotes
+            throw new Error("Tcore doesn't have a token object"); // eslint-disable-line quotes
+        };
+        /**
+         * User
+         */
+        this.user = async (force = this.forceRequest) => {
+            if (!force) {
+                const cachedUser = Cached_1.default.user();
+                if (cachedUser)
+                    return Promise.resolve(cachedUser);
+            }
+            return this.xhr.req(APICONST_1.default.USER.METHOD)(APICONST_1.default.USER.PATH, APICONST_1.default.USER.DATA_KEY);
+        };
+        this.userUpdate = async (userUpdateRequest) => {
+            return this.xhr.req(APICONST_1.default.USER_UPDATE.METHOD)(APICONST_1.default.USER_UPDATE.PATH, APICONST_1.default.USER_UPDATE.DATA_KEY, {
+                ...userUpdateRequest,
+            });
+        };
+        this.userDelete = async () => {
+            return this.xhr
+                .req(APICONST_1.default.USER_DELETE.METHOD)(APICONST_1.default.USER_DELETE.PATH, APICONST_1.default.USER_DELETE.DATA_KEY)
+                .then((deleted) => {
+                this.removeToken();
+                (0, dataClear_1.default)();
+                return deleted;
+            });
+        };
+        this.userResetPassword = async (email, resetPasswordUrl) => {
+            return this.xhr.req(APICONST_1.default.USER_RESET_PASSWORD.METHOD)(APICONST_1.default.USER_RESET_PASSWORD.PATH, APICONST_1.default.USER_UPDATE.DATA_KEY, { email, resetPasswordUrl });
+        };
+        this.userUpdatePassword = async (password, hash) => {
+            return this.xhr.req(APICONST_1.default.USER_UPDATE_PASSWORD.METHOD)(APICONST_1.default.USER_UPDATE_PASSWORD.PATH, APICONST_1.default.USER_UPDATE_PASSWORD.DATA_KEY, { password, hash });
+        };
+        /**
+         * Notifications
+         */
+        this.notifications = async () => {
+            return this.xhr
+                .req(APICONST_1.default.NOTIFICATIONS.METHOD)(APICONST_1.default.NOTIFICATIONS.PATH, APICONST_1.default.NOTIFICATIONS.DATA_KEY)
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        this.notificationsUnseen = async () => {
+            return this.xhr
+                .req(APICONST_1.default.NOTIFICATIONS_UNSEEN.METHOD)(APICONST_1.default.NOTIFICATIONS_UNSEEN.PATH, APICONST_1.default.NOTIFICATIONS_UNSEEN.DATA_KEY)
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        this.notificationsUpdateUnseen = async () => {
+            return this.xhr.req(APICONST_1.default.NOTIFICATIONS_UPDATE_UNSEEN.METHOD)(APICONST_1.default.NOTIFICATIONS_UPDATE_UNSEEN.PATH, APICONST_1.default.NOTIFICATIONS_UPDATE_UNSEEN.DATA_KEY);
+        };
+        this.notificationsSettings = async () => {
+            return this.xhr
+                .req(APICONST_1.default.NOTIFICATIONS_SETTINGS.METHOD)(APICONST_1.default.NOTIFICATIONS_SETTINGS.PATH, APICONST_1.default.NOTIFICATIONS_SETTINGS.DATA_KEY)
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        this.notificationsUpdateSettings = async (settingId, checked) => {
+            return this.xhr
+                .req(APICONST_1.default.NOTIFICATIONS_UPDATE_SETTINGS.METHOD)(APICONST_1.default.NOTIFICATIONS_UPDATE_SETTINGS.PATH, APICONST_1.default.NOTIFICATIONS_UPDATE_SETTINGS.DATA_KEY, { settingId, checked })
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        /**
+         * Companions
+         */
+        this.companions = async (force = this.forceRequest) => {
+            if (!force) {
+                const cachedCompanions = Cached_1.default.companions(this.lang);
+                if (cachedCompanions)
+                    return Promise.resolve(cachedCompanions);
+            }
+            return this.xhr
+                .reqWithPage(APICONST_1.default.COMPANIONS.METHOD)(APICONST_1.default.COMPANIONS.PATH, APICONST_1.default.COMPANIONS.DATA_KEY, {
+                limit: 100,
+            })
+                .then((dataPayloadResult) => dataPayloadResult.data);
+        };
+        this.companionAdd = async (newCompanion) => this.xhr.req(APICONST_1.default.COMPANION_ADD.METHOD)(APICONST_1.default.COMPANION_ADD.PATH, APICONST_1.default.COMPANION_ADD.DATA_KEY, {
+            ...newCompanion,
+        });
+        // .then(() => this.companions());
+        this.companionUpdate = async (companion) => this.xhr.req(APICONST_1.default.COMPANION_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.COMPANION_UPDATE.PATH, companion.id, 'companionId'), APICONST_1.default.COMPANION_UPDATE.DATA_KEY, {
+            title: companion.title,
+            name: companion.name,
+            answers: companion.answers,
+            age: companion.age,
+        });
+        // .then(() => this.companions());
+        this.companionDelete = async (companionId) => this.xhr
+            .req(APICONST_1.default.COMPANION_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.COMPANION_DELETE.PATH, companionId, 'companionId'), APICONST_1.default.COMPANION_DELETE.DATA_KEY)
+            .then((deleted) => deleted.recordId);
+        /**
+         * Favorites
+         */
+        this.favorites = async (cityId) => {
+            if (!this.forceRequest && cityId) {
+                const cachedFavorites = Cached_1.default.favorites(this.lang, cityId);
+                if (cachedFavorites)
+                    return Promise.resolve(cachedFavorites);
+            }
+            return this.xhr
+                .reqWithPage(APICONST_1.default.FAVORITES.METHOD)(APICONST_1.default.FAVORITES.PATH, APICONST_1.default.FAVORITES.DATA_KEY, {
+                cityId,
+            })
+                .then((dataPayloadResult) => dataPayloadResult.data);
+        };
+        this.favoriteAdd = async (poiId, tripHash) => this.xhr.req(APICONST_1.default.FAVORITE_ADD.METHOD)(APICONST_1.default.FAVORITE_ADD.PATH, APICONST_1.default.FAVORITE_ADD.DATA_KEY, {
+            poiId,
+            tripHash,
+        });
+        // .then((addedFavorite: Model.Favorite) => this.favorites(addedFavorite.city_id || 0));
+        this.favoriteDelete = async (favoriteId) => this.xhr
+            .req(APICONST_1.default.FAVORITE_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.FAVORITE_DELETE.PATH, favoriteId, 'favoriteId'), APICONST_1.default.FAVORITE_DELETE.DATA_KEY)
+            .then((deleted) => deleted.recordId);
+        /**
+         * Reactions
+         */
+        this.reactions = async (tripHash, reaction, page = 1) => {
+            if (!this.forceRequest) {
+                const cachedReactions = Cached_1.default.userReactions(this.lang, tripHash);
+                if (cachedReactions)
+                    return Promise.resolve(cachedReactions);
+            }
+            return this.xhr
+                .reqWithPage(APICONST_1.default.REACTIONS.METHOD)(APICONST_1.default.REACTIONS.PATH, APICONST_1.default.REACTIONS.DATA_KEY, {
+                reaction,
+                tripHash,
+                page,
+                limit: 100,
+            })
+                .then((dataPayloadResult) => dataPayloadResult.data);
+        };
+        this.reactionAdd = async (reactionRequest) => this.xhr.req(APICONST_1.default.REACTION_ADD.METHOD)(APICONST_1.default.REACTION_ADD.PATH, APICONST_1.default.REACTION_ADD.DATA_KEY, reactionRequest);
+        // .then((addedReaction: Model.UserReaction) => this.reactions(addedReaction.trip_hash));
+        this.reactionUpdate = async (id, comment) => this.xhr.req(APICONST_1.default.REACTION_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.REACTION_UPDATE.PATH, id, 'reactionId'), APICONST_1.default.REACTION_UPDATE.DATA_KEY, { comment });
+        // .then((updatedReaction: Model.UserReaction) => this.reactions(updatedReaction.trip_hash));
+        this.reactionDelete = async (reactionId) => this.xhr
+            .req(APICONST_1.default.REACTION_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.REACTION_DELETE.PATH, reactionId, 'reactionId'), APICONST_1.default.REACTION_DELETE.DATA_KEY)
+            .then((deleted) => deleted.recordId);
+        /**
+         * Plan
+         */
+        this.plan = async (planId, generate = true, sleepMs = 2000, retryCount = 30) => {
+            return this.xhr
+                .req(APICONST_1.default.PLAN.METHOD)(easy_1.default.setParameterId(APICONST_1.default.PLAN.PATH, planId, 'planId'), APICONST_1.default.PLAN.DATA_KEY, {})
+                .then(async (plan) => {
+                if (generate && plan.generatedStatus === 0) {
+                    if (retryCount > 0) {
+                        // console.log('trip info', minPlanIndex, 'plan daha olmamış. Uyuyom ben 200ms');
+                        const result = await sleep(sleepMs);
+                        // console.log('trip info', result, 'şimdi uyandık bakalım.');
+                        if (result)
+                            return this.plan(planId, generate, sleepMs, retryCount - 1);
+                    }
+                }
+                return plan;
+            });
+        };
+        this.planRouteUrl = async (planId, tripHash) => this.xhr.req(APICONST_1.default.PLAN_ROUTE_URL.METHOD)(APICONST_1.default.PLAN_ROUTE_URL.PATH, APICONST_1.default.PLAN_ROUTE_URL.DATA_KEY, {
+            planId,
+            tripHash,
+        });
+        this.planUpdate = async (id, planUpdateRequest) => this.xhr.req(APICONST_1.default.PLAN_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.PLAN_UPDATE.PATH, id, 'planId'), APICONST_1.default.PLAN_UPDATE.DATA_KEY, { ...planUpdateRequest });
+        this.planUpdateOrders = async (planId, stepOrders) => this.planUpdate(planId, { stepOrders }); // .then(() => this.trip(data.trip?.trip_hash || '', undefined, true));
+        this.planUpdateTime = async (planId, startTime, endTime) => this.planUpdate(planId, { startTime, endTime }); // .then(() => this.trip(data.trip?.trip_hash || '', undefined, true));
+        /**
+         * Step
+         */
+        this.stepAdd = async (planId, poiId, startTime, endTime) => {
+            return this.xhr.req(APICONST_1.default.STEP_ADD.METHOD)(APICONST_1.default.STEP_ADD.PATH, APICONST_1.default.STEP_ADD.DATA_KEY, {
+                planId,
+                poiId,
+                startTime,
+                endTime,
+            });
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.customStepAdd = async (planId, customPoi, stepType, startTime, endTime) => {
+            return this.xhr.req(APICONST_1.default.STEP_ADD.METHOD)(APICONST_1.default.STEP_ADD.PATH, APICONST_1.default.STEP_ADD.DATA_KEY, {
+                planId,
+                customPoi,
+                stepType,
+                startTime,
+                endTime,
+            });
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.stepUpdateTimes = async (stepId, startTime, endTime) => {
+            return this.xhr.req(APICONST_1.default.STEP_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.STEP_UPDATE.PATH, stepId, 'stepId'), APICONST_1.default.STEP_UPDATE.DATA_KEY, { startTime, endTime });
+        };
+        this.stepReplace = async (stepId, newPoiId) => {
+            return this.xhr.req(APICONST_1.default.STEP_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.STEP_UPDATE.PATH, stepId, 'stepId'), APICONST_1.default.STEP_UPDATE.DATA_KEY, { poiId: newPoiId });
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.stepDelete = async (stepId) => {
+            return this.xhr
+                .req(APICONST_1.default.STEP_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.STEP_DELETE.PATH, stepId, 'stepId'), APICONST_1.default.STEP_DELETE.DATA_KEY)
+                .then((deleted) => deleted.recordId);
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        /**
+         * Questions
+         */
+        this.questions = async (cityId, category = model_1.default.QUESTIONS_CATEGORY.TRIP) => {
+            const dataKey = `${APICONST_1.default.QUESTIONS.DATA_KEY}-${category}`;
+            if (!this.forceRequest) {
+                const cachedQuestions = Cached_1.default.questions(this.lang, dataKey);
+                if (cachedQuestions)
+                    return Promise.resolve(cachedQuestions);
+            }
+            return this.xhr
+                .reqWithPage(APICONST_1.default.QUESTIONS.METHOD)(APICONST_1.default.QUESTIONS.PATH, dataKey, {
+                cityId,
+                category,
+                version: 2,
+            })
+                .then((dataPayloadResult) => dataPayloadResult.data.filter((x) => x.answers.length > 0))
+                .then((questionsResponse) => {
+                (0, cacheCommon_1.allQuestionsData)(this.lang);
+                return questionsResponse;
+            });
+        };
+        this.questionsTrip = async (cityId) => this.questions(cityId, model_1.default.QUESTIONS_CATEGORY.TRIP);
+        this.questionsProfile = async (cityId) => this.questions(cityId, model_1.default.QUESTIONS_CATEGORY.PROFILE);
+        this.questionsCompanion = async (cityId) => this.questions(cityId, model_1.default.QUESTIONS_CATEGORY.COMPANION);
+        this.questionsAll = async (cityId) => {
+            const questionsTripPromise = this.questionsTrip(cityId);
+            const questionsProfilePromise = this.questionsProfile(cityId);
+            const questionsCompanionPromise = this.questionsCompanion(cityId);
+            return Promise.all([questionsTripPromise, questionsProfilePromise, questionsCompanionPromise]).then((qAllArray) => {
+                const qAll = [];
+                return qAll.concat(...qAllArray);
+            });
+        };
+        /**
+         * Trips
+         */
+        this.tripRefs = async (limit = 40) => {
+            if (!this.forceRequest) {
+                const cachedTripRefs = Cached_1.default.tripRefs();
+                if (cachedTripRefs)
+                    return Promise.resolve(cachedTripRefs);
+            }
+            return this.xhr
+                .reqWithPage(APICONST_1.default.TRIPS.METHOD)(APICONST_1.default.TRIPS.PATH, APICONST_1.default.TRIPS.DATA_KEY, { limit })
+                .then((dataPayloadResult) => {
+                return dataPayloadResult.data;
+            });
+        };
+        /* tripSavedRefs = async (limit: number = 40, force = false): Promise<Model.TripReference[]> => {
+          if (!this.forceRequest && !force) {
+            const cachedTripSavedRefs = Cached.tripSavedRefs();
+            if (cachedTripSavedRefs) return Promise.resolve(cachedTripSavedRefs);
+          }
+      
+          return this.xhr
+            .reqWithPage(API_CONST.TRIPS_SAVED.METHOD)<Model.TripReference[]>(API_CONST.TRIPS_SAVED.PATH, API_CONST.TRIPS_SAVED.DATA_KEY, { limit })
+            .then((dataPayloadResult) => {
+              return dataPayloadResult.data;
+            });
+        }; */
+        this.tripRef = async (hash) => {
+            return this.xhr
+                .req(APICONST_1.default.TRIP_WITH_HASH.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_WITH_HASH.PATH, { key: 'hash', value: hash }), APICONST_1.default.TRIP_WITH_HASH.DATA_KEY)
+                .then((dataPayloadResult) => dataPayloadResult);
+        };
+        this.trip = async (tripHash, minDayIndex = 0, force = this.forceRequest, sleepMs = 2000, retryCount = 30) => {
+            if (!force) {
+                const cachedTrip = Cached_1.default.trip(this.lang, tripHash, minDayIndex);
+                if (cachedTrip) {
+                    return Promise.resolve(cachedTrip);
+                }
+            }
+            return this.xhr
+                .req(APICONST_1.default.TRIP.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP.DATA_KEY)
+                .then(async (tripData) => {
+                // console.log('trip info', minDayIndex, 'plan için bekliyorduk.');
+                const minPlanIndex = tripData.plans.length - 1 < minDayIndex ? tripData.plans.length - 1 : minDayIndex;
+                if (tripData.plans[minPlanIndex].generatedStatus === 0 || tripData.plans[minPlanIndex].generatedStatus === -2) {
+                    // console.log('retryCount', retryCount);
+                    if (retryCount > 0) {
+                        // console.log('trip info', minPlanIndex, 'plan daha olmamış. Uyuyom ben 200ms');
+                        const result = await sleep(sleepMs);
+                        // console.log('trip info', result, 'şimdi uyandık bakalım.');
+                        if (result)
+                            return this.trip(tripData.tripHash, minPlanIndex, force, undefined, retryCount - 1);
+                    }
+                }
+                // console.log('tripAdd', minPlanIndex, 'plan olmuş al.');
+                return tripData;
+            });
+        };
+        this.tripAdd = async (tripProfile, minDayIndex) => this.xhr
+            .req(APICONST_1.default.TRIP_ADD.METHOD)(APICONST_1.default.TRIP_ADD.PATH, APICONST_1.default.TRIP_ADD.DATA_KEY, { ...tripProfile })
+            .then((tripData) => (minDayIndex === undefined ? tripData : this.trip(tripData.tripHash, minDayIndex)));
+        this.tripClone = async (tripHash) => this.xhr
+            .req(APICONST_1.default.TRIP_CLONE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_CLONE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_CLONE.DATA_KEY)
+            .then((tripData) => tripData);
+        this.tripCloneCombo = async (tripHash) => this.tripClone(tripHash).then(async (tripCloneData) => {
+            const tripReferences = await this.tripRefs();
+            return {
+                trip: tripCloneData,
+                tripReferences,
+            };
+        });
+        this.tripUpdate = async (tripHash, tripProfile, minDayIndex = 0) => {
+            return this.xhr
+                .req(APICONST_1.default.TRIP_UPDATE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_UPDATE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_UPDATE.DATA_KEY, { ...tripProfile })
+                .then((tripData) => this.trip(tripData.tripHash, minDayIndex));
+        };
+        this.tripNameUpdate = async (tripHash, tripProfile) => {
+            return this.xhr
+                .req(APICONST_1.default.TRIP_UPDATE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_UPDATE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_UPDATE.DATA_KEY, { ...tripProfile })
+                .then((tripData) => tripData);
+        };
+        this.tripDelete = async (tripHash) => {
+            return this.xhr
+                .req(APICONST_1.default.TRIP_DELETE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_DELETE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_DELETE.DATA_KEY)
+                .then((deleted) => deleted.recordId);
+            // .then(() => this.trips());
+        };
+        this.tripDownloadIcs = async (tripHash) => this.xhr
+            .req(APICONST_1.default.TRIP_DOWNLOAD_ICS.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_DOWNLOAD_ICS.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_DOWNLOAD_ICS.DATA_KEY, undefined, {
+            headers: { 'Content-Type': 'text/calendar' },
+            responseType: 'blob',
+        })
+            .then((response) => {
+            const href = URL.createObjectURL(response.data);
+            const link = document.createElement('a');
+            link.href = href;
+            const headerLine = response.headers['content-disposition'];
+            const fileName = headerLine
+                .split(';')[1]
+                .split('=')[1]
+                .replace(/"/g, '');
+            link.setAttribute('download', fileName);
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+            URL.revokeObjectURL(href);
+        });
+        /* tripSavedAdd = async (tripHash: string): Promise<Model.TripReference[]> => {
+          return this.xhr
+            .req(API_CONST.TRIPS_SAVED_ADD.METHOD)<Model.TripReference[]>(API_CONST.TRIPS_SAVED_ADD.PATH, API_CONST.TRIPS_SAVED.DATA_KEY, {
+              tripHash,
+            })
+            .then((dataPayloadResult) => {
+              return dataPayloadResult;
+            });
+        }; */
+        /* tripSavedRemove = async (tripHash: string): Promise<Model.TripReference[]> => {
+          return this.xhr
+            .req(API_CONST.TRIPS_SAVED_DELETE.METHOD)<Model.TripReference[]>(
+              easy.setParameter(API_CONST.TRIPS_SAVED_DELETE.PATH, { key: 'tripHash', value: tripHash }),
+              API_CONST.TRIPS_SAVED_DELETE.DATA_KEY,
+            )
+            .then((dataPayloadResult) => {
+              return dataPayloadResult;
+            });
+        }; */
+        this.tripGetShared = async (tripHash, delay = true) => {
+            return this.xhr
+                .req(APICONST_1.default.TRIP_GET_SHARED.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_GET_SHARED.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_GET_SHARED.DATA_KEY)
+                .then(async (sharedTripData) => {
+                const nowToArrivalWeek = (0, moment_1.default)(sharedTripData.tripProfile.arrivalDatetime).diff((0, moment_1.default)(), 'weeks', false);
+                if (nowToArrivalWeek < 4 && delay) {
+                    const displayTrip = model_1.helper.deepCopy(sharedTripData);
+                    const willAddedWeeks = 4 - nowToArrivalWeek;
+                    const displayArrivalDate = (0, moment_1.default)(displayTrip.tripProfile.arrivalDatetime).add(willAddedWeeks, 'weeks');
+                    const displayDepartureDate = (0, moment_1.default)(displayTrip.tripProfile.departureDatetime).add(willAddedWeeks, 'weeks');
+                    displayTrip.tripProfile.arrivalDatetime = displayArrivalDate.format('YYYY-MM-DDTHH:mm:ss[Z]');
+                    displayTrip.tripProfile.departureDatetime = displayDepartureDate.format('YYYY-MM-DDTHH:mm:ss[Z]');
+                    displayTrip.plans.forEach((plan, i) => {
+                        plan.date = displayArrivalDate
+                            .clone()
+                            .add(i, 'days')
+                            .format('YYYY-MM-DD');
+                    });
+                    return displayTrip;
+                }
+                return sharedTripData;
+            });
+        };
+        this.tripShare = async (tripHash, share) => {
+            return this.xhr
+                .req(APICONST_1.default.TRIP_SHARE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TRIP_SHARE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TRIP_SHARE.DATA_KEY, { share })
+                .then(async (sharedData) => {
+                // console.log('shared trip', sharedTripData, 'shared trip read only al.');
+                return sharedData.share;
+            });
+        };
+        /**
+         * Timeline
+         */
+        this.timeline = async (tripHash, minDayIndex = 0, force = this.forceRequest, sleepMs = 2000, retryCount = 30) => {
+            return this.xhr
+                .req(APICONST_1.default.TIMELINE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TIMELINE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TIMELINE.DATA_KEY)
+                .then(async (tripData) => {
+                // console.log('trip info', minDayIndex, 'plan için bekliyorduk.');
+                const minPlanIndex = tripData.plans.length - 1 < minDayIndex ? tripData.plans.length - 1 : minDayIndex;
+                if (tripData.plans[minPlanIndex].generatedStatus === 0 || tripData.plans[minPlanIndex].generatedStatus === -2) {
+                    // console.log('retryCount', retryCount);
+                    if (retryCount > 0) {
+                        // console.log('trip info', minPlanIndex, 'plan daha olmamış. Uyuyom ben 200ms');
+                        const result = await sleep(sleepMs);
+                        // console.log('trip info', result, 'şimdi uyandık bakalım.');
+                        if (result)
+                            return this.timeline(tripData.tripHash, minPlanIndex, force, undefined, retryCount - 1);
+                    }
+                }
+                // console.log('tripAdd', minPlanIndex, 'plan olmuş al.');
+                return tripData;
+            });
+        };
+        this.timelineTripAdd = async (tripProfile, minDayIndex) => this.xhr
+            .req(APICONST_1.default.TIMELINE_TRIP_ADD.METHOD)(APICONST_1.default.TIMELINE_TRIP_ADD.PATH, APICONST_1.default.TIMELINE_TRIP_ADD.DATA_KEY, {
+            ...tripProfile,
+        })
+            .then((tripData) => (minDayIndex === undefined ? tripData : this.timeline(tripData.tripHash, minDayIndex)));
+        this.timelineTrips = async (limit = 40) => {
+            return this.xhr
+                .reqWithPage(APICONST_1.default.TIMELINE_TRIPS.METHOD)(APICONST_1.default.TIMELINE_TRIPS.PATH, APICONST_1.default.TIMELINE_TRIPS.DATA_KEY, { limit })
+                .then((dataPayloadResult) => {
+                return dataPayloadResult.data;
+            });
+        };
+        this.timelineStepAdd = async (planId, poiId, startTime, endTime) => {
+            return this.xhr.req(APICONST_1.default.TIMELINE_STEP_ADD.METHOD)(APICONST_1.default.TIMELINE_STEP_ADD.PATH, APICONST_1.default.TIMELINE_STEP_ADD.DATA_KEY, {
+                planId,
+                poiId,
+                startTime,
+                endTime,
+            });
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.timelineCustomStepAdd = async (planId, customPoi, stepType, startTime, endTime) => {
+            return this.xhr.req(APICONST_1.default.TIMELINE_STEP_ADD.METHOD)(APICONST_1.default.TIMELINE_STEP_ADD.PATH, APICONST_1.default.TIMELINE_STEP_ADD.DATA_KEY, {
+                planId,
+                customPoi,
+                stepType,
+                startTime,
+                endTime,
+            });
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.timelineStepUpdateTimes = async (stepId, startTime, endTime) => {
+            return this.xhr.req(APICONST_1.default.TIMELINE_STEP_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.TIMELINE_STEP_UPDATE.PATH, stepId, 'stepId'), APICONST_1.default.TIMELINE_STEP_UPDATE.DATA_KEY, { startTime, endTime });
+        };
+        this.timelineStepReplace = async (stepId, newPoiId) => {
+            return this.xhr.req(APICONST_1.default.TIMELINE_STEP_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.TIMELINE_STEP_UPDATE.PATH, stepId, 'stepId'), APICONST_1.default.TIMELINE_STEP_UPDATE.DATA_KEY, { poiId: newPoiId });
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.timelineStepDelete = async (stepId) => {
+            return this.xhr
+                .req(APICONST_1.default.TIMELINE_STEP_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.TIMELINE_STEP_DELETE.PATH, stepId, 'stepId'), APICONST_1.default.TIMELINE_STEP_DELETE.DATA_KEY)
+                .then((deleted) => deleted.recordId);
+            // .then(() => this.trip(data.trip?.trip_hash || ''));
+        };
+        this.timelineUpdate = async (tripHash, tripProfile) => {
+            return this.xhr
+                .req(APICONST_1.default.TIMELINE_UPDATE.METHOD)(easy_1.default.setParameter(APICONST_1.default.TIMELINE_UPDATE.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TIMELINE_UPDATE.DATA_KEY, { ...tripProfile })
+                .then((response) => response);
+        };
+        this.timelineSegmentDelete = async (tripHash, segmentIndex) => {
+            const path = easy_1.default.setParameter(APICONST_1.default.TIMELINE_DELETE.PATH, { key: 'tripHash', value: tripHash });
+            const fullPath = easy_1.default.setParameter(path, { key: 'segmentIndex', value: String(segmentIndex) });
+            return this.xhr
+                .req(APICONST_1.default.TIMELINE_DELETE.METHOD)(fullPath, APICONST_1.default.TIMELINE_DELETE.DATA_KEY)
+                .then((response) => response);
+        };
+        this.timelineGetShared = async (tripHash) => {
+            return this.xhr
+                .req(APICONST_1.default.TIMELINE_GET_SHARED.METHOD)(easy_1.default.setParameter(APICONST_1.default.TIMELINE_GET_SHARED.PATH, { key: 'tripHash', value: tripHash }), APICONST_1.default.TIMELINE_GET_SHARED.DATA_KEY)
+                .then(async (sharedTripData) => {
+                return sharedTripData;
+            });
+        };
+        /**
+         * Reservations
+         */
+        this.reservations = async (cityId, tripHash, poiId, provider, dateFrom, dateTo, limit = 100) => {
+            if (!this.forceRequest) {
+                const cachedReservations = Cached_1.default.reservations(this.lang);
+                if (cachedReservations)
+                    return Promise.resolve(cachedReservations);
+            }
+            return this.xhr
+                .reqWithPage(APICONST_1.default.RESERVATIONS.METHOD)(APICONST_1.default.RESERVATIONS.PATH, APICONST_1.default.RESERVATIONS.DATA_KEY, {
+                cityId,
+                tripHash,
+                poiId,
+                provider,
+                dateFrom,
+                dateTo,
+                limit,
+            })
+                .then((dataPayloadResult) => dataPayloadResult.data);
+        };
+        this.reservationAdd = async (reservationRequest) => this.xhr.req(APICONST_1.default.RESERVATION_ADD.METHOD)(APICONST_1.default.RESERVATION_ADD.PATH, APICONST_1.default.RESERVATION_ADD.DATA_KEY, {
+            ...reservationRequest,
+        });
+        // .then(() => Cached.reservations() || []); // @TODO @PenguenUmut this.reservations() için cityId lazım! Ya da eklenen UserReservation dönülecek.
+        this.reservationUpdate = async (reservation) => this.xhr.req(APICONST_1.default.RESERVATION_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.RESERVATION_UPDATE.PATH, reservation.id, 'reservationId'), APICONST_1.default.RESERVATION_UPDATE.DATA_KEY, {
+            key: reservation.key,
+            value: reservation.value,
+            provider: reservation.provider,
+            tripHash: reservation.tripHash,
+            poiId: reservation.poiId,
+        });
+        // .then(() => Cached.reservations() || []); // @TODO @PenguenUmut this.reservations() için cityId lazım! Ya da eklenen UserReservation dönülecek.
+        this.reservationDelete = async (reservationId) => this.xhr
+            .req(APICONST_1.default.RESERVATION_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.RESERVATION_DELETE.PATH, reservationId, 'reservationId'), APICONST_1.default.RESERVATION_DELETE.DATA_KEY)
+            .then((deleted) => deleted.recordId);
+        // .then(() => Cached.reservations() || []); // @TODO @PenguenUmut this.reservations() için cityId lazım! Ya da void olacak.
+        /**
+         * Feedbacks
+         */
+        this.feedbacks = async () => {
+            // if (!this.forceRequest) {
+            //   const allFeedbacks = Cached.feedbacks(this.lang);
+            //   if (allFeedbacks) return allFeedbacks;
+            // }
+            return this.xhr.req(APICONST_1.default.FEEDBACKS.METHOD)(APICONST_1.default.FEEDBACKS.PATH, APICONST_1.default.FEEDBACKS.DATA_KEY);
+        };
+        this.userFeedbacks = async (forceOnce = false) => {
+            if (!this.forceRequest && !forceOnce) {
+                const allUserFeedbacks = Cached_1.default.userFeedbacks(this.lang);
+                if (allUserFeedbacks)
+                    return allUserFeedbacks;
+            }
+            return this.xhr.req(APICONST_1.default.USER_FEEDBACKS.METHOD)(APICONST_1.default.USER_FEEDBACKS.PATH, APICONST_1.default.USER_FEEDBACKS.DATA_KEY);
+        };
+        this.feedbackSend = async (feedbackRequest) => this.xhr
+            .req(APICONST_1.default.SEND_FEEDBACK.METHOD)(APICONST_1.default.SEND_FEEDBACK.PATH, APICONST_1.default.SEND_FEEDBACK.DATA_KEY, { ...feedbackRequest })
+            .then(() => this.userFeedbacks(true));
+        this.feedbackReply = async (feedbackRequest) => this.xhr
+            .req(APICONST_1.default.SEND_FEEDBACK.METHOD)(APICONST_1.default.REPLY_FEEDBACK.PATH, APICONST_1.default.SEND_FEEDBACK.DATA_KEY, { ...feedbackRequest })
+            .then(() => this.userFeedbacks(true));
+        this.feedbackUpdate = async (feedbackId, isRead) => this.xhr
+            .req(APICONST_1.default.UPDATE_FEEDBACK.METHOD)(easy_1.default.setParameterId(APICONST_1.default.UPDATE_FEEDBACK.PATH, feedbackId, 'feedbackId'), APICONST_1.default.UPDATE_FEEDBACK.DATA_KEY, {
+            isRead,
+        })
+            .then(() => this.userFeedbacks(true));
+        /**
+         * Offers
+         */
+        this.productTypes = async () => this.xhr
+            .req(APICONST_1.default.OFFER_PRODUCT_TYPES.METHOD)(APICONST_1.default.OFFER_PRODUCT_TYPES.PATH, APICONST_1.default.OFFER_PRODUCT_TYPES.DATA_KEY)
+            .then((productTypes) => productTypes);
+        this.offerSearch = async (dateFrom, dateTo, boundary, showOffersOnly) => this.xhr
+            .reqWithPage(APICONST_1.default.OFFERS.METHOD)(APICONST_1.default.OFFERS.PATH, APICONST_1.default.OFFERS.DATA_KEY, {
+            dateFrom,
+            dateTo,
+            boundary,
+            page: 1,
+            limit: 50,
+        })
+            .then((offers) => {
+            if (offers.data.length === 0)
+                return [];
+            const poiIds = offers.data.map((o) => o.tripianPoiId);
+            return this.pois(poiIds, Number(showOffersOnly), undefined, true);
+        });
+        this.offersOptIn = async (dateFrom, dateTo) => this.xhr.req(APICONST_1.default.OFFERS_OPT_IN.METHOD)(APICONST_1.default.OFFERS_OPT_IN.PATH, APICONST_1.default.OFFERS_OPT_IN.DATA_KEY, {
+            dateFrom,
+            dateTo,
+        });
+        /* .then((offers) => {
+                  if (offers.length === 0) return [];
+                  const poiIds = offers.map((o) => o.tripianPoiId);
+                  return this.pois(poiIds);
+                }); */
+        this.myCampaignOffers = async (campaignId) => this.xhr.req(APICONST_1.default.OFFERS_OPT_IN.METHOD)(APICONST_1.default.OFFERS_OPT_IN.PATH, APICONST_1.default.OFFERS_OPT_IN.DATA_KEY, {
+            campaignId,
+        });
+        this.offerSearchCampaign = async (campaignId, showOffersOnly) => this.xhr
+            .reqWithPage(APICONST_1.default.OFFERS.METHOD)(APICONST_1.default.OFFERS.PATH, APICONST_1.default.OFFERS.DATA_KEY, {
+            campaignId,
+        })
+            .then((offers) => {
+            if (offers.data.length === 0)
+                return [];
+            const poiIds = offers.data.map((o) => o.tripianPoiId);
+            return this.pois(poiIds, Number(showOffersOnly), undefined, true);
+        });
+        this.offerSearchNew = async (dateFrom, dateTo, boundary) => this.xhr.reqWithPage(APICONST_1.default.OFFERS.METHOD)(APICONST_1.default.OFFERS.PATH, APICONST_1.default.OFFERS.DATA_KEY, {
+            dateFrom,
+            dateTo,
+            boundary,
+            page: 1,
+            limit: 50,
+        });
+        this.offer = async (offerId) => this.xhr
+            .req(APICONST_1.default.OFFER.METHOD)(easy_1.default.setParameterId(APICONST_1.default.OFFER.PATH, offerId, 'offerId'), APICONST_1.default.OFFER.DATA_KEY, {})
+            .then((offer) => offer);
+        this.offerUpdateOptIn = async (offerId, optInDate) => this.xhr
+            .req(APICONST_1.default.OFFER_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.OFFER_UPDATE.PATH, offerId, 'offerId'), APICONST_1.default.OFFER_UPDATE.DATA_KEY, { optInDate })
+            .then((dataResult) => dataResult);
+        this.offerDelete = async (offerId) => this.xhr
+            .req(APICONST_1.default.OFFER_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.OFFER_DELETE.PATH, offerId, 'offerId'), APICONST_1.default.OFFER_DELETE.DATA_KEY)
+            .then((dataResult) => dataResult);
+        this.offerRedeemStatusUpdate = async (offerId, status) => this.xhr
+            .req(APICONST_1.default.OFFER_REDEEM_STATUS_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.OFFER_REDEEM_STATUS_UPDATE.PATH, offerId, 'offerId'), APICONST_1.default.OFFER_REDEEM_STATUS_UPDATE.DATA_KEY, { status })
+            .then((dataResult) => dataResult.status);
+        this.offerRedeemStatus = async (offerId) => this.xhr
+            .req(APICONST_1.default.OFFER_REDEEM_STATUS.METHOD)(easy_1.default.setParameterId(APICONST_1.default.OFFER_REDEEM_STATUS.PATH, offerId, 'offerId'), APICONST_1.default.OFFER_REDEEM_STATUS.DATA_KEY)
+            .then((dataResult) => dataResult.status);
+        /**
+         * Small Business Tools
+         */
+        this.businessSearch = async (q, cityId, bounds) => this.xhr.req(APICONST_1.default.BUSINESS_SEARCH.METHOD)(APICONST_1.default.BUSINESS_SEARCH.PATH, APICONST_1.default.BUSINESS_SEARCH.DATA_KEY, {
+            q,
+            cityId,
+            bounds,
+        });
+        this.businessAssign = async (tripianPoiId) => {
+            return this.xhr.req(APICONST_1.default.BUSINESS_USER_ASSIGN.METHOD)(APICONST_1.default.BUSINESS_USER_ASSIGN.PATH, APICONST_1.default.BUSINESS_USER_ASSIGN.DATA_KEY, {
+                tripianPoiId,
+            });
+        };
+        this.startVerify = async (to_, channel) => this.xhr.req(APICONST_1.default.BUSINESS_VERIFY_START.METHOD)(APICONST_1.default.BUSINESS_VERIFY_START.PATH, APICONST_1.default.BUSINESS_VERIFY_START.DATA_KEY, { to_, channel });
+        this.checkVerify = async (to_, channel, code) => this.xhr.req(APICONST_1.default.BUSINESS_VERIFY_CHECK.METHOD)(APICONST_1.default.BUSINESS_VERIFY_CHECK.PATH, APICONST_1.default.BUSINESS_VERIFY_CHECK.DATA_KEY, { to_, channel, code });
+        this.business = async () => this.xhr.req(APICONST_1.default.BUSINESS.METHOD)(APICONST_1.default.BUSINESS.PATH, APICONST_1.default.BUSINESS.DATA_KEY);
+        /* businessUpdate = async (offerId: number, image: Model.Image): Promise<Model.Business> =>
+          this.xhr
+            .req(API_CONST.BUSINESS_OFFER_UPDATE.METHOD)<Model.Business>(
+              easy.setParameterId(API_CONST.BUSINESS_OFFER_UPDATE.PATH, offerId, 'offerId'),
+              API_CONST.BUSINESS_OFFER_UPDATE.DATA_KEY,
+              { offerId, image },
+            )
+             */
+        this.businessOffers = async (statuses, page = 1, limit) => this.xhr.reqWithPage(APICONST_1.default.BUSINESS_OFFERS.METHOD)(APICONST_1.default.BUSINESS_OFFERS.PATH, APICONST_1.default.BUSINESS_OFFERS.DATA_KEY, {
+            status: `${statuses.join(',')}`,
+            page,
+            limit,
+        });
+        this.businessOfferAdd = async (offerAddRequest) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER_ADD.METHOD)(APICONST_1.default.BUSINESS_OFFER_ADD.PATH, APICONST_1.default.BUSINESS_OFFER_ADD.DATA_KEY, {
+            ...offerAddRequest,
+        });
+        this.businessVoucherOfferAdd = async (voucherOfferAddRequest) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER_ADD.METHOD)(APICONST_1.default.BUSINESS_OFFER_ADD.PATH, APICONST_1.default.BUSINESS_OFFER_ADD.DATA_KEY, {
+            ...voucherOfferAddRequest,
+        });
+        this.businessOffer = async (offerId) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_OFFER.PATH, offerId, 'offerId'), APICONST_1.default.BUSINESS_OFFER.DATA_KEY);
+        this.businessOfferStatusUpdate = async (offerId, status) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_OFFER_UPDATE.PATH, offerId, 'offerId'), APICONST_1.default.BUSINESS_OFFER_UPDATE.DATA_KEY, { offerId, status });
+        this.businessOfferImageUpdate = async (offerId, imageUrl) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_OFFER_UPDATE.PATH, offerId, 'offerId'), APICONST_1.default.BUSINESS_OFFER_UPDATE.DATA_KEY, { offerId, imageUrl });
+        this.businessOfferDelete = async (offerId) => this.xhr
+            .req(APICONST_1.default.BUSINESS_OFFER_DELETE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_OFFER_DELETE.PATH, offerId, 'offerId'), APICONST_1.default.BUSINESS_OFFER_DELETE.DATA_KEY)
+            .then((deleted) => deleted.recordId);
+        this.businessOfferCustomers = async (offerId) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER_CUSTOMERS.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_OFFER_CUSTOMERS.PATH, offerId, 'offerId'), APICONST_1.default.BUSINESS_OFFER_CUSTOMERS.DATA_KEY);
+        this.businessOfferFileUpload = async (file) => this.xhr.req(APICONST_1.default.BUSINESS_OFFER_FILE_UPLOAD.METHOD)(APICONST_1.default.BUSINESS_OFFER_FILE_UPLOAD.PATH, APICONST_1.default.BUSINESS_OFFER_FILE_UPLOAD.DATA_KEY, { file }, { 'Content-Type': 'multipart/form-data' });
+        this.businessOfferRedeemStatusUpdate = async (offerId, userId, status) => this.xhr
+            .req(APICONST_1.default.BUSINESS_OFFER_REDEEM_STATUS_UPDATE.METHOD)(easy_1.default.setParameters(APICONST_1.default.BUSINESS_OFFER_REDEEM_STATUS_UPDATE.PATH, [
+            { key: 'offerId', value: offerId.toString() },
+            { key: 'userId', value: userId.toString() },
+        ]), APICONST_1.default.BUSINESS_OFFER_REDEEM_STATUS_UPDATE.DATA_KEY, { status })
+            .then((dataResult) => dataResult.status);
+        this.businessOfferRedeemStatus = async (offerId, userId) => this.xhr
+            .req(APICONST_1.default.BUSINESS_OFFER_REDEEM_STATUS.METHOD)(easy_1.default.setParameters(APICONST_1.default.BUSINESS_OFFER_REDEEM_STATUS.PATH, [
+            { key: 'offerId', value: offerId.toString() },
+            { key: 'userId', value: userId.toString() },
+        ]), APICONST_1.default.BUSINESS_OFFER_REDEEM_STATUS.DATA_KEY)
+            .then((dataResult) => dataResult.status);
+        /**
+         * Business Pre Registers
+         */
+        this.businessPreRegister = async (preRegister) => {
+            return this.xhr.req(APICONST_1.default.BUSINESS_PRE_REGISTER.METHOD)(APICONST_1.default.BUSINESS_PRE_REGISTER.PATH, APICONST_1.default.BUSINESS_PRE_REGISTER.DATA_KEY, preRegister);
+        };
+        /**
+         * Campaign
+         */
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.businessCampaigns = async (page, limit = 1000) => {
+            // await sleep();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // return mockCampaigns;
+            return this.xhr.reqWithPage(APICONST_1.default.BUSINESS_CAMPAIGNS.METHOD)(APICONST_1.default.BUSINESS_CAMPAIGNS.PATH, APICONST_1.default.BUSINESS_CAMPAIGNS.DATA_KEY, {
+                limit,
+                page,
+            });
+        };
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.businessCampaign = async (campaignId) => {
+            // await sleep();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // return mockCampaigns.data.find((x) => x.id);
+            return this.xhr.req(APICONST_1.default.BUSINESS_CAMPAIGN.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_CAMPAIGN.PATH, campaignId, 'campaignId'), APICONST_1.default.BUSINESS_CAMPAIGN.DATA_KEY);
+        };
+        this.businessCampaignUpdate = async (campaignId, campaignRequest) => this.xhr
+            .req(APICONST_1.default.BUSINESS_CAMPAIGN_UPDATE.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_CAMPAIGN_UPDATE.PATH, campaignId, 'campaignId'), APICONST_1.default.BUSINESS_CAMPAIGN_UPDATE.DATA_KEY, campaignRequest)
+            .then((dataResult) => dataResult.updated);
+        this.businessCampaignAdd = async (campaignRequest) => this.xhr
+            .req(APICONST_1.default.BUSINESS_CAMPAIGN_ADD.METHOD)(APICONST_1.default.BUSINESS_CAMPAIGN_ADD.PATH, APICONST_1.default.BUSINESS_CAMPAIGN_ADD.DATA_KEY, campaignRequest)
+            .then((dataResult) => dataResult.campaignId);
+        /**
+         * Coupon
+         */
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.businessCouponApplications = async (page, status, limit = 150) => {
+            // await sleep();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // return mockCouponApplications;
+            return this.xhr.reqWithPage(APICONST_1.default.BUSINESS_COUPON_APPLICATIONS.METHOD)(APICONST_1.default.BUSINESS_COUPON_APPLICATIONS.PATH, APICONST_1.default.BUSINESS_COUPON_APPLICATIONS.DATA_KEY, {
+                page,
+                status,
+                limit,
+            });
+        };
+        this.businessCouponApplication = async (applicationId) => {
+            // await sleep();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // return mockCouponApplications.data.find((x) => x.id === applicationId);
+            return this.xhr.req(APICONST_1.default.BUSINESS_COUPON_APPLICATION.METHOD)(easy_1.default.setParameterId(APICONST_1.default.BUSINESS_COUPON_APPLICATION.PATH, applicationId, 'applicationId'), APICONST_1.default.BUSINESS_COUPON_APPLICATION.DATA_KEY);
+        };
+        this.businessCouponApplicationAdd = async (couponApplicationRequest) => this.xhr
+            .req(APICONST_1.default.BUSINESS_COUPON_APPLICATION_ADD.METHOD)(APICONST_1.default.BUSINESS_COUPON_APPLICATION_ADD.PATH, APICONST_1.default.BUSINESS_COUPON_APPLICATION_ADD.DATA_KEY, { formDatas: couponApplicationRequest })
+            .then((dataResult) => dataResult.applicationId);
+        this.businessCouponApplicationUserUpdate = async (applicationId, travelerId, status, campaignId = 0, bookingDate, notes, amount) => this.xhr
+            .req(APICONST_1.default.BUSINESS_COUPON_APPLICATION_USER_UPDATE.METHOD)(easy_1.default.setParameters(APICONST_1.default.BUSINESS_COUPON_APPLICATION_USER_UPDATE.PATH, [
+            { key: 'applicationId', value: applicationId.toString() },
+            { key: 'travelerId', value: travelerId.toString() },
+        ]), APICONST_1.default.BUSINESS_COUPON_APPLICATION_USER_UPDATE.DATA_KEY, { campaignId, status: status ? 1 : -1, bookingDate, notes, amount })
+            .then((response) => response.updated);
+        this.businessCouponApplicationUserApprove = async (applicationId, travelerId, campaignId, bookingDate, amount) => this.businessCouponApplicationUserUpdate(applicationId, travelerId, true, campaignId, bookingDate, undefined, amount).then((updated) => {
+            if (updated)
+                return this.businessCouponApplication(applicationId);
+            return undefined;
+        });
+        this.businessCouponApplicationUserReject = async (applicationId, travelerId, campaignId, bookingDate, notes) => this.businessCouponApplicationUserUpdate(applicationId, travelerId, false, campaignId, bookingDate, notes).then((updated) => {
+            if (updated)
+                return this.businessCouponApplication(applicationId);
+            return undefined;
+        });
+        this.businessCouponApplicationFileUpload = async (file) => this.xhr.req(APICONST_1.default.BUSINESS_COUPON_FILE_UPLOAD.METHOD)(APICONST_1.default.BUSINESS_COUPON_FILE_UPLOAD.PATH, APICONST_1.default.BUSINESS_COUPON_FILE_UPLOAD.DATA_KEY, { file }, { 'Content-Type': 'multipart/form-data' });
+        /**
+         * Wallet
+         */
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        this.coupons = async (page, limit = 1000) => {
+            // await sleep();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // return mockCoupons;
+            return this.xhr.reqWithPage(APICONST_1.default.COUPONS.METHOD)(APICONST_1.default.COUPONS.PATH, APICONST_1.default.COUPONS.DATA_KEY, {
+                limit,
+                page,
+            });
+        };
+        this.payment = async (voucherOfferId) => {
+            // await sleep();
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // const newBalance = mockCoupons.data[0].balance - voucherOfferId;
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            // return { ...mockCoupons.data[0], balance: newBalance } as Model.Coupon;
+            return this.xhr.req(APICONST_1.default.PAYMENT.METHOD)(easy_1.default.setParameters(APICONST_1.default.PAYMENT.PATH, [{ key: 'offerId', value: voucherOfferId.toString() }]), APICONST_1.default.PAYMENT.DATA_KEY);
+        };
+        /**
+         * Wallet
+         */
+        this.campaignReport = async (campaignId, query) => {
+            return this.xhr.reqWithPage(APICONST_1.default.CAMPAIGN_REPORT.METHOD)(easy_1.default.setParameters(APICONST_1.default.CAMPAIGN_REPORT.PATH, [{ key: 'campaignId', value: campaignId.toString() }]), APICONST_1.default.CAMPAIGN_REPORT.DATA_KEY, { ...query });
+        };
+        this.campaignReportPay = async (campaignId, id) => {
+            return this.xhr
+                .req(APICONST_1.default.CAMPAIGN_REPORT_PAY.METHOD)(easy_1.default.setParameters(APICONST_1.default.CAMPAIGN_REPORT_PAY.PATH, [
+                { key: 'campaignId', value: campaignId.toString() },
+                { key: 'id', value: id.toString() },
+            ]), APICONST_1.default.CAMPAIGN_REPORT.DATA_KEY)
+                .then((res) => res.updated);
+        };
+        this.campaignCustomerReport = async (campaignId, query) => {
+            return this.xhr
+                .reqWithPage(APICONST_1.default.CAMPAIGN_CUSTOMER_REPORT.METHOD)(easy_1.default.setParameters(APICONST_1.default.CAMPAIGN_CUSTOMER_REPORT.PATH, [{ key: 'campaignId', value: campaignId.toString() }]), APICONST_1.default.CAMPAIGN_CUSTOMER_REPORT.DATA_KEY, {
+                ...query,
+            })
+                .then((datas) => {
+                datas.data.forEach((d) => {
+                    d.lengthOfStay = (0, moment_1.default)(d.customerDepartureDate).diff((0, moment_1.default)(d.customerArrivalDate), 'days', false);
+                });
+                return datas;
+            });
+        };
+        this.businessReport = async (query) => {
+            return this.xhr.reqWithPage(APICONST_1.default.BUSINESS_REPORT.METHOD)(APICONST_1.default.BUSINESS_REPORT.PATH, APICONST_1.default.BUSINESS_REPORT.DATA_KEY, {
+                ...query,
+            });
+        };
+        this.businessPreRegisterReport = async (query) => {
+            return this.xhr.reqWithPage(APICONST_1.default.BUSINESS_PRE_REGISTER_REPORT.METHOD)(APICONST_1.default.BUSINESS_PRE_REGISTER_REPORT.PATH, APICONST_1.default.BUSINESS_PRE_REGISTER_REPORT.DATA_KEY, {
+                ...query,
+            });
+        };
+        this.businessOfferReport = async (page = 1, limit = 1000) => {
+            return this.xhr.reqWithPage(APICONST_1.default.BUSINESS_OFFER_REPORT.METHOD)(APICONST_1.default.BUSINESS_OFFER_REPORT.PATH, APICONST_1.default.BUSINESS_OFFER_REPORT.DATA_KEY, {
+                page,
+                limit,
+            });
+        };
+        this.businessExport = async (reportType, campaignId) => this.xhr.req(APICONST_1.default.BUSINESS_EXPORT.METHOD)(APICONST_1.default.BUSINESS_EXPORT.PATH, APICONST_1.default.BUSINESS_EXPORT.DATA_KEY, {
+            reportType,
+            campaignId,
+        });
+        /**
+         * Translations
+         */
+        this.translationList = async () => this.xhr.req(APICONST_1.default.TRANSLATIONS.METHOD)(APICONST_1.default.TRANSLATIONS.PATH, APICONST_1.default.TRANSLATIONS.DATA_KEY);
+        /**
+         * Logs
+         */
+        this.log = async (message, dataPayload = {}, type = 'ERROR') => {
+            var _a;
+            const { baseURL, xApiKey, email } = this.xhr.info();
+            return this.xhr.req(APICONST_1.default.LOGS.METHOD)(APICONST_1.default.LOGS.PATH, APICONST_1.default.LOGS.DATA_KEY, {
+                message: {
+                    /* static datas */
+                    platform: 'web',
+                    type,
+                    g_api_customer_id: 0,
+                    user_id: 0,
+                    uri_params: {},
+                    query_params: { apibaseURL: baseURL },
+                    /* app static datas */
+                    api_key: xApiKey,
+                    endpoint: (_a = window === null || window === void 0 ? void 0 : window.location.href) !== null && _a !== void 0 ? _a : '',
+                    /* log messages */
+                    response_msg: message,
+                    request_params: {
+                        email,
+                        ...dataPayload,
+                    },
+                },
+            });
+        };
+        this.visaIframeToken = async () => this.xhr
+            .req(APICONST_1.default.VISA_IFRAME_TOKEN.METHOD)(APICONST_1.default.VISA_IFRAME_TOKEN.PATH, APICONST_1.default.OFFER.DATA_KEY)
+            .then((visaToken) => visaToken);
+        this.visaValidatorCheck = async (context) => {
+            return this.xhr.req(APICONST_1.default.VISA_VALIDATOR_CHECK.METHOD)(APICONST_1.default.VISA_VALIDATOR_CHECK.PATH, APICONST_1.default.VISA_VALIDATOR_CHECK.DATA_KEY, {
+                context,
+            });
+        };
+        /**
+         * Tour API
+         */
+        this.tourSearch = async (request) => this.xhr.req(APICONST_1.default.TOUR_SEARCH.METHOD)(APICONST_1.default.TOUR_SEARCH.PATH, APICONST_1.default.TOUR_SEARCH.DATA_KEY, request);
+        /**
+         * COMBO
+         */
+        this.combo = {
+            /**
+             *
+             * Business Combo
+             *
+             */
+            businessPayloadData: async () => this.user().then((userData) => {
+                if (userData.businessId && userData.businessId > 0) {
+                    return this.business().then((businessData) => {
+                        return {
+                            user: userData,
+                            business: businessData,
+                        };
+                    });
+                }
+                return {
+                    user: userData,
+                };
+            }),
+            campaignReportPayCombo: async (campaignId, id, query) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.campaignReportPay(campaignId, id).then((updatedPlan) => this.campaignReport(campaignId, query)),
+            payloadDataEx: async () => this.user().then((userData) => this.business().then((businessData) => ({
+                user: userData,
+                business: businessData,
+            }))),
+            /**
+             *
+             *
+             * Trip Combo
+             */
+            tripDelete: async (tripHash, tripRefsLimit) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.tripDelete(tripHash).then(() => this.tripRefs(tripRefsLimit)),
+            /**
+             *
+             *
+             * Step Combo
+             */
+            stepAdd: async (planId, poiId, tripHash, startTime, endTime) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.stepAdd(planId, poiId, startTime, endTime).then(() => this.trip(tripHash, undefined)),
+            customStepAdd: async (planId, customPoi, tripHash, stepType, startTime, endTime) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.customStepAdd(planId, customPoi, stepType, startTime, endTime).then(() => this.trip(tripHash, undefined, true)),
+            stepUpdateTimes: async (stepId, startTime, endTime, tripHash) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.stepUpdateTimes(stepId, startTime, endTime).then((updatedStep) => this.trip(tripHash, undefined)),
+            stepReplace: async (stepId, newPoiId, tripHash) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.stepReplace(stepId, newPoiId).then((replacedStep) => this.trip(tripHash, undefined)),
+            stepDelete: async (stepId, tripHash) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.stepDelete(stepId).then(() => this.trip(tripHash, undefined, true)),
+            /**
+             *
+             *
+             * Plan Combo
+             */
+            planUpdateOrders: async (planId, orders, tripHash) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.planUpdateOrders(planId, orders).then((updatedPlan) => this.trip(tripHash, undefined, true)),
+            planUpdateTime: async (planId, minDayIndex, startTime, endTime, tripHash) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.planUpdateTime(planId, startTime, endTime).then((updatedPlan) => this.trip(tripHash, minDayIndex, true)),
+            /**
+             *
+             *
+             * Favorite Combo
+             */
+            favoriteAdd: async (tripHash, poiId, cityId) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.favoriteAdd(poiId, tripHash).then((addedFavorite) => this.favorites(cityId)),
+            favoriteDelete: async (favoriteId, cityId) => 
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            this.favoriteDelete(favoriteId).then(() => this.favorites(cityId)),
+            /**
+             *
+             *
+             * Companion Combo
+             */
+            companionAdd: async (newCompanion, companionsForce) => this.companionAdd(newCompanion).then(() => this.companions(companionsForce)),
+            companionUpdate: async (companion, companionsForce) => this.companionUpdate(companion).then(() => this.companions(companionsForce)),
+            companionDelete: async (companionId, companionsForce) => this.companionDelete(companionId).then(() => this.companions(companionsForce)),
+            /**
+             *
+             *
+             * Reservation Combo
+             */
+            reservationAdd: async (newReservation, cityId) => this.reservationAdd(newReservation).then(() => this.reservations(cityId)),
+            reservationUpdate: async (reservation, cityId) => this.reservationUpdate(reservation).then(() => this.reservations(cityId)),
+            reservationDelete: async (reservationId, cityId) => this.reservationDelete(reservationId).then(() => this.reservations(cityId)),
+            /**
+             *
+             *
+             * Reaction Combo
+             */
+            reactionAdd: async (newReaction, tripHash) => this.reactionAdd(newReaction).then(() => this.reactions(tripHash)),
+            // reactionUpdate: async (reaction: Model.UserReaction, tripHash: string, startDate: string, endDate: string): Promise<Model.UserReaction[]> =>
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            // this.reactionUpdate(reaction).then((updatedReaction: Model.UserReaction) => this.reactions(startDate, endDate, undefined, tripHash)),
+        };
+        this.xhr = new xhrFetch_1.default(apiSettings, lang);
+        this.forceRequest = !useCache;
+        this.lang = lang;
+    }
+}
+/* const mockCoupons: Model.DataPayload<Model.Coupon[]> = {
+  data: [
+    {
+      id: 1,
+      currency: Model.OFFER_CURRENCY.BBD,
+      balance: 90,
+      campaign: {
+        id: 1,
+        title: 'BTMI Summer Campaign',
+        category: 'Voucher',
+        // currency: 'BBD$',
+        amount: 100,
+        maximumRecipients: 100,
+        limited: false,
+        description: '',
+        maximumOfferAmount: 50,
+        // assignedVouchers: 3,
+        // assignedVoucherValue: 150,
+        startDate: '2023-07-07T00:00:00+03:00',
+        endDate: '2023-07-17T00:00:00+03:00',
+        // status: Model.CAMPAIGN_STATUS.ACTIVE,
+      },
+    },
+  ],
+  pagination: { count: 3, currentPage: 1, perPage: 20, total: 3, totalPages: 1 },
+}; */
+/* const mockCampaigns: Model.DataPayload<Model.Campaign[]> = {
+  data: [
+    {
+      id: 1,
+      title: 'BTMI Summer Campaign',
+      category: 'Voucher',
+      currency: 'BBD$',
+      amount: 100,
+      maximumRecipients: 100,
+      limited: false,
+      description: '',
+      maximumOfferAmount: 50,
+      assignedVouchers: 3,
+      assignedVoucherValue: 150,
+      startDate: '2023-07-07T00:00:00+03:00',
+      endDate: '2023-07-17T00:00:00+03:00',
+      status: Model.CAMPAIGN_STATUS.ACTIVE,
+    },
+    {
+      id: 2,
+      title: 'Crazy Summer Campaign',
+      currency: 'BBD$',
+      category: 'Voucher',
+      amount: 200,
+      maximumRecipients: 50,
+      limited: false,
+      description: '',
+      maximumOfferAmount: 50,
+      assignedVouchers: 6,
+      assignedVoucherValue: 300,
+      startDate: '2023-07-07T00:00:00+03:00',
+      endDate: '2023-07-17T00:00:00+03:00',
+      status: Model.CAMPAIGN_STATUS.EXPIRED,
+    },
+    {
+      id: 3,
+      title: 'Penguin Campaign',
+      category: 'Voucher',
+      currency: 'BBD$',
+      amount: 150,
+      maximumRecipients: 60,
+      limited: false,
+      description: '',
+      maximumOfferAmount: 20,
+      assignedVouchers: 3,
+      assignedVoucherValue: 60,
+      startDate: '2023-07-07T00:00:00+03:00',
+      endDate: '2023-07-17T00:00:00+03:00',
+      status: Model.CAMPAIGN_STATUS.ACTIVE,
+    },
+  ],
+  pagination: { count: 3, currentPage: 1, perPage: 20, total: 3, totalPages: 1 },
+};
+const mockCouponApplications: Model.DataPayload<Model.CouponApplication[]> = {
+  data: [
+    {
+      id: 12,
+      travelInformation: {
+        adults: 3,
+        nameOfProperty: 'Crystal Waters',
+        proofOfHolidayBookingUrl: 'https://poi-pics.s3.eu-west-1.amazonaws.com/Smbt/customer_7/bcoupons/2023-07/upload_bFk3Sn97Hu.jpg',
+      },
+      marketingQuestions: { howDidYouHear: 'Advertisement', howDidYouBookYourTrip: 'Online' },
+      personalInformations: [
+        {
+          id: 0,
+          campaign_id: 0,
+          title: 'Mr',
+          firstName: 'Mustafa',
+          lastName: 'Sandal',
+          arrivalDate: '2023-07-18T00:00:00+03:00',
+          departureDate: '2023-07-24T00:00:00+03:00',
+          departureDestination: 'Turkey',
+          airline: 'Condor (DE)',
+          flightNumber: '23435645',
+          passportNumber: '578786756634',
+          dateOfBirth: '1974-01-24T00:00:00+02:00',
+          emailAddress: 'mustafa@sandal.com',
+          phoneNumber: '+905555555555',
+          status: 0,
+        },
+        {
+          id: 0,
+          campaign_id: 0,
+          title: 'Mr',
+          firstName: 'Kemal',
+          lastName: 'Ku0131lu0131u00e7darou011flu',
+          arrivalDate: '2023-07-18T00:00:00+03:00',
+          departureDate: '2023-07-24T00:00:00+03:00',
+          departureDestination: 'Turkmenistan',
+          airline: 'Virgin Atlantic (VS)',
+          flightNumber: '345457524',
+          passportNumber: '34574685679',
+          dateOfBirth: '1953-01-28T00:00:00+02:00',
+          emailAddress: 'kk@kk.com',
+          phoneNumber: '+905555555555',
+          status: 0,
+        },
+        {
+          id: 0,
+          campaign_id: 0,
+          title: 'Mr',
+          firstName: 'Ulau015f',
+          lastName: 'Ayu00e7iu00e7ek',
+          arrivalDate: '2023-07-11T00:00:00+03:00',
+          departureDate: '2023-07-25T00:00:00+03:00',
+          departureDestination: 'Algeria',
+          airline: 'Caribbean Airlines (BW)',
+          flightNumber: '5464564',
+          passportNumber: '4864568',
+          dateOfBirth: '2001-09-18T00:00:00+03:00',
+          emailAddress: 'aycicek.u@gmail.com',
+          phoneNumber: '+905454839658',
+          status: 0,
+        },
+      ],
+    },
+    {
+      id: 11,
+      travelInformation: {
+        adults: 2,
+        nameOfProperty: 'Cobblers Cove Hotel',
+        proofOfHolidayBookingUrl: 'https://poi-pics.s3.eu-west-1.amazonaws.com/Smbt/customer_7/bcoupons/2023-07/upload_jhDsWIchEf.png',
+      },
+      marketingQuestions: { howDidYouHear: 'Advertisement', howDidYouBookYourTrip: 'Online' },
+      personalInformations: [
+        {
+          id: 0,
+          campaign_id: 0,
+          title: 'Mr',
+          firstName: 'Michael',
+          lastName: 'Jackson',
+          arrivalDate: '2023-07-13T00:00:00+03:00',
+          departureDate: '2023-07-26T00:00:00+03:00',
+          departureDestination: 'Algeria',
+          airline: 'Condor (DE)',
+          flightNumber: 'sdf324234',
+          passportNumber: '234234234234534',
+          dateOfBirth: '1957-01-16T00:00:00+02:00',
+          emailAddress: 'michael@jackson.com',
+          phoneNumber: '+905555555555',
+          status: 0,
+        },
+        {
+          id: 0,
+          campaign_id: 0,
+          title: 'Mr',
+          firstName: 'Samuel L.',
+          lastName: 'Jackson',
+          arrivalDate: '2023-07-20T00:00:00+03:00',
+          departureDate: '2023-07-31T00:00:00+03:00',
+          departureDestination: 'Afghanistan',
+          airline: 'JetBlue (B6)',
+          flightNumber: '234235345',
+          passportNumber: '234235354564',
+          dateOfBirth: '1965-01-27T00:00:00+02:00',
+          emailAddress: 'samule@jackson.com',
+          phoneNumber: '+905555555555',
+          status: 0,
+        },
+      ],
+    },
+    {
+      id: 10,
+      travelInformation: {
+        adults: 1,
+        nameOfProperty: 'Annjenn Apartments',
+        proofOfHolidayBookingUrl: 'https://poi-pics.s3.eu-west-1.amazonaws.com/Smbt/customer_7/bcoupons/2023-07/upload_eONvZiMmmS.png',
+      },
+      marketingQuestions: { howDidYouHear: 'Advertisement', howDidYouBookYourTrip: 'Online' },
+      personalInformations: [
+        {
+          id: 0,
+          campaign_id: 0,
+          title: 'Mrs',
+          firstName: 'Scarlett',
+          lastName: 'Johansson',
+          arrivalDate: '2023-07-11T00:00:00+03:00',
+          departureDate: '2023-07-20T00:00:00+03:00',
+          departureDestination: 'United States of America (the)',
+          airline: 'American Airlines (AA)',
+          flightNumber: '324erew4',
+          passportNumber: '23423454',
+          dateOfBirth: '1992-01-08T00:00:00+02:00',
+          emailAddress: 'scarlett@johansson.com',
+          phoneNumber: '+905555555555',
+          status: 0,
+        },
+      ],
+    },
+  ],
+  pagination: { count: 4, currentPage: 1, perPage: 20, total: 4, totalPages: 1 },
+};
+*/
+exports.default = API;
+//# sourceMappingURL=API.js.map