import Model from '@tripian/model';
import IXhrOptions from '../xhr/IXhrOptions';
declare class API {
    private xhr;
    private forceRequest;
    private lang;
    constructor(apiSettings: IXhrOptions, lang: string, useCache: boolean);
    getToken: () => Model.Token | undefined;
    setToken: (token: Model.Token) => void;
    removeToken: () => void;
    setLang: (lang: string) => void;
    configList: () => Promise<Model.ConfigList>;
    /**
     ******************************************************************************
     *
     * Cities
     *
     */
    citiesPage: (page: number, limit?: number) => Promise<Model.DataPayload<Model.City[]>>;
    citiesAll: () => Promise<Model.City[]>;
    city: (cityId: number) => Promise<Model.City>;
    cityInfo: (cityId: number) => Promise<Model.CityInfo>;
    cityEvents: (cityId: number) => Promise<Model.CityEvent[]>;
    citiesSearch: (name: string) => Promise<Model.City[]>;
    /**
     * POI
     */
    suggestCity: (text: string) => Promise<Model.SuggestedCityMatch[]>;
    poiCategories: (limit?: number, version?: number) => Promise<Model.PoiCategoryResponse>;
    poisSearch: (poisRequest: Model.PoisRequest) => Promise<Model.DataPayload<Model.Poi[]>>;
    poisNameSearch: ({ cityId, search, poiCategories, showOffersOnly, showBookingsOnly, limit, page, }: Model.PoisRequestName) => Promise<Model.DataPayload<Model.Poi[]>>;
    poisOpenSearch: ({ cityId, search, poiCategories, showOffersOnly, showBookingsOnly, limit, page, }: Model.PoisRequestName) => Promise<Model.DataPayload<Model.Poi[]>>;
    poisSearchAutoComplete: () => Promise<string[]>;
    poisSearchAutoCompleteTags: (cityId: number, poiCategories?: string) => Promise<{
        id: number;
        name: string;
    }[]>;
    poisCoordinateSearch: ({ poiCategories, coordinate, distance, bounds, showOffersOnly, limit, }: Model.PoisRequestCoordinate) => Promise<Model.Poi[]>;
    poisMustTrySearch: ({ cityId, mustTryIds, limit }: Model.PoisRequestMustTry) => Promise<Model.Poi[]>;
    pois: (poiIds: string[], withOffers: number, cityId?: number, force?: boolean) => Promise<Model.Poi[]>;
    poi: (poiId: string, withOffers?: number) => Promise<Model.Poi>;
    customPois: (name?: string) => Promise<Model.Poi[]>;
    /**
     * Top 10
     */
    topTen: (cityId: number, poiCategories?: string) => Promise<Model.TopTen[]>;
    /**
     * Registers
     */
    register: (registerRequest: Model.RegisterRequest) => Promise<Model.Token>;
    /**
     * Guest
     */
    loginGuest: (uniqueId: string) => Promise<Model.Token>;
    /**
     * Logins
     */
    private login;
    loginEmail: (email: string, password: string, business?: boolean) => Promise<Model.Token>;
    loginCognito: (code: string, redirectUrl: string, device: Model.Device) => Promise<Model.Token>;
    logout: () => void;
    lightRegisterLogin: (uniqueId: string) => Promise<Model.Token>;
    lightLoginHash: (tripHash: string) => Promise<Model.Token>;
    refreshToken: (force?: boolean) => Promise<Model.Token>;
    /**
     * User
     */
    user: (force?: boolean) => Promise<Model.User>;
    userUpdate: (userUpdateRequest: Model.UserUpdateRequest) => Promise<Model.User>;
    userDelete: () => Promise<Model.DeleteUpdateResponse>;
    userResetPassword: (email: string, resetPasswordUrl?: string) => Promise<Model.UserResetPassword>;
    userUpdatePassword: (password: string, hash: string) => Promise<Model.UserResetPassword>;
    /**
     * Notifications
     */
    notifications: () => Promise<Model.Notification[]>;
    notificationsUnseen: () => Promise<Model.NotificationUnseen>;
    notificationsUpdateUnseen: () => Promise<Model.DeleteUpdateResponse>;
    notificationsSettings: () => Promise<Model.NotificationSettings[]>;
    notificationsUpdateSettings: (settingId: number, checked: boolean) => Promise<Model.NotificationSettings[]>;
    /**
     * Companions
     */
    companions: (force?: boolean) => Promise<Model.Companion[]>;
    companionAdd: (newCompanion: Model.CompanionRequest) => Promise<Model.Companion>;
    companionUpdate: (companion: Model.Companion) => Promise<Model.Companion>;
    companionDelete: (companionId: number) => Promise<number>;
    /**
     * Favorites
     */
    favorites: (cityId?: number) => Promise<Model.Favorite[]>;
    favoriteAdd: (poiId: string, tripHash?: string) => Promise<Model.Favorite>;
    favoriteDelete: (favoriteId: number) => Promise<number>;
    /**
     * Reactions
     */
    reactions: (tripHash: string, reaction?: Model.REACTION, page?: number) => Promise<Model.UserReaction[]>;
    reactionAdd: (reactionRequest: Model.UserReactionRequest) => Promise<Model.UserReaction>;
    reactionUpdate: (id: number, comment: string) => Promise<Model.UserReaction>;
    reactionDelete: (reactionId: number) => Promise<number>;
    /**
     * Plan
     */
    plan: (planId: number, generate?: boolean, sleepMs?: number, retryCount?: number) => Promise<Model.Plan>;
    planRouteUrl: (planId: number, tripHash: string) => Promise<{
        url: string;
    }>;
    private planUpdate;
    planUpdateOrders: (planId: number, stepOrders: number[]) => Promise<Model.Plan>;
    planUpdateTime: (planId: number, startTime: string, endTime: string) => Promise<Model.Plan>;
    /**
     * Step
     */
    stepAdd: (planId: number, poiId: string, startTime?: string, endTime?: string) => Promise<Model.Step>;
    customStepAdd: (planId: number, customPoi: Model.CustomPoi, stepType: string, startTime?: string, endTime?: string) => Promise<Model.Step>;
    stepUpdateTimes: (stepId: number, startTime: string, endTime: string) => Promise<Model.Step>;
    stepReplace: (stepId: number, newPoiId: string) => Promise<Model.Step>;
    stepDelete: (stepId: number) => Promise<number>;
    /**
     * Questions
     */
    private questions;
    questionsTrip: (cityId?: number) => Promise<Model.Question[]>;
    questionsProfile: (cityId?: number) => Promise<Model.Question[]>;
    questionsCompanion: (cityId?: number) => Promise<Model.Question[]>;
    questionsAll: (cityId?: number) => Promise<Model.Question[]>;
    /**
     * Trips
     */
    tripRefs: (limit?: number) => Promise<Model.TripReference[]>;
    tripRef: (hash: string) => Promise<Model.TripReference>;
    trip: (tripHash: string, minDayIndex?: number, force?: boolean, sleepMs?: number, retryCount?: number) => Promise<Model.Trip>;
    tripAdd: (tripProfile: Model.TripProfile, minDayIndex?: number) => Promise<Model.Trip>;
    tripClone: (tripHash: string) => Promise<Model.Trip>;
    tripCloneCombo: (tripHash: string) => Promise<{
        trip: Model.Trip;
        tripReferences: Model.TripReference[];
    }>;
    tripUpdate: (tripHash: string, tripProfile: Model.TripProfile, minDayIndex?: number) => Promise<Model.Trip>;
    tripNameUpdate: (tripHash: string, tripProfile: Model.TripProfile) => Promise<Model.Trip>;
    tripDelete: (tripHash: string) => Promise<number>;
    tripDownloadIcs: (tripHash: string) => Promise<void>;
    tripGetShared: (tripHash: string, delay?: boolean) => Promise<Model.Trip>;
    tripShare: (tripHash: string, share: boolean) => Promise<boolean>;
    /**
     * Reservations
     */
    reservations: (cityId?: number, tripHash?: string, poiId?: string, provider?: string, dateFrom?: string, dateTo?: string, limit?: number) => Promise<Model.UserReservation[]>;
    reservationAdd: (reservationRequest: Model.UserReservationRequest) => Promise<Model.UserReservation>;
    reservationUpdate: (reservation: Model.UserReservation) => Promise<Model.UserReservation>;
    reservationDelete: (reservationId: number) => Promise<number>;
    /**
     * Feedbacks
     */
    feedbacks: () => Promise<Model.Feedbacks>;
    userFeedbacks: (forceOnce?: boolean) => Promise<Model.UserFeedback[]>;
    feedbackSend: (feedbackRequest: Model.FeedbackRequest) => Promise<Model.UserFeedback[]>;
    feedbackReply: (feedbackRequest: Model.FeedbackReplyRequest) => Promise<Model.UserFeedback[]>;
    feedbackUpdate: (feedbackId: string, isRead: boolean) => Promise<Model.UserFeedback[]>;
    /**
     * Offers
     */
    productTypes: () => Promise<Model.OfferProductType[]>;
    offerSearch: (dateFrom: string, dateTo: string, boundary: string, showOffersOnly: boolean) => Promise<Model.Poi[]>;
    offersOptIn: (dateFrom?: string, dateTo?: string) => Promise<Model.Poi[]>;
    myCampaignOffers: (campaignId: number) => Promise<Model.Poi[]>;
    offerSearchCampaign: (campaignId: number, showOffersOnly: boolean) => Promise<Model.Poi[]>;
    offerSearchNew: (dateFrom: string, dateTo: string, boundary: string) => Promise<Model.DataPayload<Model.Poi[]>>;
    offer: (offerId: number) => Promise<Model.Offer>;
    offerUpdateOptIn: (offerId: number, optInDate: string) => Promise<Model.DeleteUpdateResponse>;
    offerDelete: (offerId: number) => Promise<Model.DeleteUpdateResponse>;
    offerRedeemStatusUpdate: (offerId: number, status: 'waiting' | 'pending' | 'completed') => Promise<'waiting' | 'pending' | 'completed'>;
    offerRedeemStatus: (offerId: number) => Promise<'waiting' | 'pending' | 'completed'>;
    /**
     * Small Business Tools
     */
    businessSearch: (q: string, cityId: number, bounds?: string) => Promise<Model.BusinessSearch[]>;
    businessAssign: (tripianPoiId: string) => Promise<Model.User>;
    startVerify: (to_: string, channel: Model.VERIFY_CHANNEL) => Promise<Model.BusinessVerify>;
    checkVerify: (to_: string, channel: Model.VERIFY_CHANNEL, code: string) => Promise<Model.BusinessVerify>;
    business: () => Promise<Model.Business>;
    businessOffers: (statuses: Model.OFFER_STATUS[], page?: number, limit?: number) => Promise<Model.DataPayload<Model.Offer[]>>;
    businessOfferAdd: (offerAddRequest: Model.OfferAddRequest) => Promise<Model.Offer>;
    businessVoucherOfferAdd: (voucherOfferAddRequest: Model.VoucherOfferAddRequest) => Promise<Model.VoucherOffer>;
    businessOffer: (offerId: number) => Promise<Model.Offer>;
    businessOfferStatusUpdate: (offerId: number, status: Model.OFFER_STATUS) => Promise<Model.Offer>;
    businessOfferImageUpdate: (offerId: number, imageUrl: string) => Promise<Model.Offer>;
    businessOfferDelete: (offerId: number) => Promise<number>;
    businessOfferCustomers: (offerId: number) => Promise<Model.OfferCustomer[]>;
    businessOfferFileUpload: (file: string) => Promise<{
        url: string;
    }>;
    businessOfferRedeemStatusUpdate: (offerId: number, userId: number, status: 'waiting' | 'pending' | 'completed') => Promise<'waiting' | 'pending' | 'completed'>;
    businessOfferRedeemStatus: (offerId: number, userId: number) => Promise<'waiting' | 'pending' | 'completed'>;
    /**
     * Business Pre Registers
     */
    businessPreRegister: (preRegister: Model.PreRegister) => Promise<boolean>;
    /**
     * Campaign
     */
    businessCampaigns: (page: number, limit?: number) => Promise<Model.DataPayload<Model.Campaign[]>>;
    businessCampaign: (campaignId: number) => Promise<Model.Campaign | undefined>;
    businessCampaignUpdate: (campaignId: number, campaignRequest: Model.CampaignUpdateRequest) => Promise<boolean>;
    businessCampaignAdd: (campaignRequest: Model.CampaignAddRequest) => Promise<number>;
    /**
     * Coupon
     */
    businessCouponApplications: (page: number, status: 'waiting' | 'reviewed', limit?: number) => Promise<Model.DataPayload<Model.CouponApplication[]>>;
    businessCouponApplication: (applicationId: number) => Promise<Model.CouponApplication | undefined>;
    businessCouponApplicationAdd: (couponApplicationRequest: Model.CouponApplicationRequest) => Promise<number>;
    private businessCouponApplicationUserUpdate;
    businessCouponApplicationUserApprove: (applicationId: number, travelerId: number, campaignId: number, bookingDate: string, amount?: number) => Promise<Model.CouponApplication | undefined>;
    businessCouponApplicationUserReject: (applicationId: number, travelerId: number, campaignId: number, bookingDate: string, notes: string) => Promise<Model.CouponApplication | undefined>;
    businessCouponApplicationFileUpload: (file: string) => Promise<{
        url: string;
    }>;
    /**
     * Wallet
     */
    coupons: (page: number, limit?: number) => Promise<Model.DataPayload<Model.Coupon[]>>;
    payment: (voucherOfferId: number) => Promise<Model.Coupon>;
    /**
     * Wallet
     */
    campaignReport: (campaignId: number, query: Partial<Model.CampaignReportRequest>) => Promise<Model.DataPayload<Model.CampaignReport>>;
    campaignReportPay: (campaignId: number, id: number) => Promise<boolean>;
    campaignCustomerReport: (campaignId: number, query: Partial<Model.CampaignCustomerReportRequest>) => Promise<Model.DataPayload<Model.CampaignCustomerReport>>;
    businessReport: (query: Partial<Model.BusinessReportRequest>) => Promise<Model.DataPayload<Model.BusinessReport>>;
    businessPreRegisterReport: (query: Partial<Model.BusinessPreRegisterReportRequest>) => Promise<Model.DataPayload<Model.BusinessReport>>;
    businessOfferReport: (page?: number, limit?: number) => Promise<Model.DataPayload<Model.BusinessOfferReport>>;
    businessExport: (reportType: 'campaign-customer-report' | 'campaign-report' | 'business-report' | 'pre-register-report', campaignId?: number) => Promise<{
        url: string;
    }>;
    /**
     * Translations
     */
    translationList: () => Promise<Model.TranslationList>;
    /**
     * Logs
     */
    log: (message: string, dataPayload?: any, type?: 'ERROR' | 'WARNING' | 'INFO') => Promise<any>;
    visaIframeToken: () => Promise<{
        token: string;
    }>;
    visaValidatorCheck: (context: string) => Promise<Model.User>;
    /**
     * COMBO
     */
    combo: {
        /**
         *
         * Business Combo
         *
         */
        businessPayloadData: () => Promise<{
            user: Model.User;
            business?: Model.Business;
        }>;
        campaignReportPayCombo: (campaignId: number, id: number, query: Partial<Model.CampaignReportRequest>) => Promise<Model.DataPayload<Model.CampaignReport>>;
        payloadDataEx: () => Promise<{
            user: Model.User;
            business: Model.Business;
        }>;
        /**
         *
         *
         * Trip Combo
         */
        tripDelete: (tripHash: string, tripRefsLimit?: number) => Promise<Model.TripReference[]>;
        /**
         *
         *
         * Step Combo
         */
        stepAdd: (planId: number, poiId: string, tripHash: string, startTime?: string, endTime?: string) => Promise<Model.Trip>;
        customStepAdd: (planId: number, customPoi: Model.CustomPoi, tripHash: string, stepType: string, startTime?: string, endTime?: string) => Promise<Model.Trip>;
        stepUpdateTimes: (stepId: number, startTime: string, endTime: string, tripHash: string) => Promise<Model.Trip>;
        stepReplace: (stepId: number, newPoiId: string, tripHash: string) => Promise<Model.Trip>;
        stepDelete: (stepId: number, tripHash: string) => Promise<Model.Trip>;
        /**
         *
         *
         * Plan Combo
         */
        planUpdateOrders: (planId: number, orders: number[], tripHash: string) => Promise<Model.Trip>;
        planUpdateTime: (planId: number, minDayIndex: number, startTime: string, endTime: string, tripHash: string) => Promise<Model.Trip>;
        /**
         *
         *
         * Favorite Combo
         */
        favoriteAdd: (tripHash: string, poiId: string, cityId: number) => Promise<Model.Favorite[]>;
        favoriteDelete: (favoriteId: number, cityId: number) => Promise<Model.Favorite[]>;
        /**
         *
         *
         * Companion Combo
         */
        companionAdd: (newCompanion: Model.CompanionRequest, companionsForce?: boolean) => Promise<Model.Companion[]>;
        companionUpdate: (companion: Model.Companion, companionsForce?: boolean) => Promise<Model.Companion[]>;
        companionDelete: (companionId: number, companionsForce?: boolean) => Promise<Model.Companion[]>;
        /**
         *
         *
         * Reservation Combo
         */
        reservationAdd: (newReservation: Model.UserReservationRequest, cityId: number) => Promise<Model.UserReservation[]>;
        reservationUpdate: (reservation: Model.UserReservation, cityId: number) => Promise<Model.UserReservation[]>;
        reservationDelete: (reservationId: number, cityId: number) => Promise<Model.UserReservation[]>;
        /**
         *
         *
         * Reaction Combo
         */
        reactionAdd: (newReaction: Model.UserReactionRequest, tripHash: string) => Promise<Model.UserReaction[]>;
    };
}
export default API;
