import * as zustand from 'zustand';
import { UseBoundStore, StoreApi } from 'zustand';
import { Address, ServiceResponse, Version, LoginResponse, ResumeResponse, ErrorResponse, ForgetPasswordResponse, StatusResponse, OtpResponse, ValidateOtpResponse, ConfirmOtpResponse, BzbsService, CampaignDetail, Style, RedeemResponse, UseCampaignResponse, CartCountResponse, Campaign, Category, Consent, CouponResponse, Dashboard, Maintenance, Notification, PointLog, Purchase, RegistrationResponse, ProfileResponse, UpdatedPoints, Badge, Trace, ExpiringPoints, ZipCode } from '@bzbs/react-api-client';
export { c as AnalyticsActions, A as AnalyticsEventParams, a as AnalyticsPageViewParams, b as AnalyticsState, d as AnalyticsStore, P as PurchaseItemInfo, D as PurchaseItemStatus, h as addBlake2OtpSignatureInterceptor, i as addDefaultHeaderInterceptor, B as analytics, j as avatarUrl, g as campaignInterfaceType, f as campaignPointType, e as campaignType, k as createCartUrl, l as createInterfaceToken, m as eventEmitter, n as fetchImage, G as findBestLocaleFromString, o as generateBlake2bSignatureHex, p as generateShortLivedId, q as getOtpSignatureHeaders, E as getPurchaseItemStatus, z as initializeAnalytics, r as interfaceWebsite, C as isValidEmail, s as largeImage, F as localeToLCIDMap, x as trackCommonEvents, v as useAnalytics, w as useAnalyticsState, u as useAnalyticsStore, t as usePageTracking, y as withPageTracking } from './locale-CuC8Xae4.js';
import 'emittery';
import 'axios';
import 'react';
import 'matomo-tracker-react-native';

type AddressState = {
    data: Address[];
    selectedAddress: Address | null;
    isLoading: boolean;
    error: ServiceResponse<unknown> | null;
};
type AddressActions = {
    setSelectedAddress: (address: Address | null) => void;
    fetchData: () => Promise<ServiceResponse<Address[]>>;
    createAddress: (address: AddressUpdateParams) => Promise<ServiceResponse<Address>>;
    updateAddress: (address: AddressUpdateParams) => Promise<ServiceResponse<Address>>;
    deleteAddress: (rowKey: string) => Promise<ServiceResponse<unknown>>;
    clear: () => void;
};
type AddressStore = AddressState & AddressActions;
type AddressUpdateParams = {
    name?: string;
    addressName?: string;
    firstName?: string;
    lastName?: string;
    address?: string;
    zipcode?: string;
    provinceCode?: string;
    provinceName?: string;
    districtCode?: string;
    districtName?: string;
    subDistrictCode?: string;
    subDistrictName?: string;
    contactNumber?: string;
    countryCode?: string;
    countryName?: string;
    isDefault?: boolean;
    rowKey?: string;
};
declare const useAddressStore: zustand.UseBoundStore<zustand.StoreApi<AddressStore>>;

type AlertRequest = {
    title: string;
    content: string;
    closeText?: string;
    onClose: () => void;
};
type AlertState = {
    isOpen: boolean;
    alertRequest: AlertRequest;
};
type AlertActions = {
    openAlert: (request: AlertRequest) => void;
    closeAlert: () => void;
};
type AlertStore = AlertState & AlertActions;
declare const useAlertStore: zustand.UseBoundStore<zustand.StoreApi<AlertStore>>;

type AuthState = {
    isInitialized: boolean;
    versionData: Version | null;
    rawVersionData: unknown | null;
    data: LoginResponse | ResumeResponse | null;
    isLoading: boolean;
    isLoadingToken: boolean;
    error: ErrorResponse | null;
    token: string | null;
    isLoggedIn: boolean;
};
type AuthActions = {
    setIsLoading: (isLoading: boolean) => void;
    setIsLoadingToken: (isLoadingToken: boolean) => void;
    setError: (error: ErrorResponse | null) => void;
    checkLoggedIn: () => Promise<void>;
    loginWithUsernamePassword: (username: string, password: string) => Promise<ServiceResponse<LoginResponse>>;
    loginWithGoogle: (token: string) => Promise<ServiceResponse<LoginResponse>>;
    loginWithFacebook: (token: string) => Promise<ServiceResponse<LoginResponse>>;
    loginWithApple: (token: string, refreshToken: string) => Promise<ServiceResponse<LoginResponse>>;
    loginWithUUID: () => Promise<ServiceResponse<LoginResponse>>;
    logout: () => Promise<ServiceResponse<unknown>>;
    forgetPassword: (contact: string, type: 'email' | 'contact_number') => Promise<ServiceResponse<ForgetPasswordResponse>>;
    resetPassword: (contact: string, otp: string, refCode: string, password: string) => Promise<ServiceResponse<StatusResponse>>;
    sendOtp: (contact: string, channel: string) => Promise<ServiceResponse<OtpResponse>>;
    validateOtp: (otp: string, refCode: string, contact: string, channel: string) => Promise<ServiceResponse<ValidateOtpResponse>>;
    confirmOtp: (otp: string, refCode: string, contact: string) => Promise<ServiceResponse<ConfirmOtpResponse>>;
    resume: (clientVersion: string) => Promise<ServiceResponse<ResumeResponse>>;
    version: (clientVersion: string) => Promise<ServiceResponse<Version>>;
    clear: () => void;
};
type AuthStore = AuthState & AuthActions;
declare const useAuthStore: zustand.UseBoundStore<zustand.StoreApi<AuthStore>>;

type AuthTokenType = 'jwt' | 'auth_token';
type getTokenFunction = () => Promise<string | null>;
type setTokenFunction = (token: string) => void;
type removeTokenFunction = () => void;
type TokenFunctions = {
    getToken: getTokenFunction;
    setToken: setTokenFunction;
    removeToken: removeTokenFunction;
};
type BuzzebeesAppState = {
    appId: string;
    appName: string;
    bzbsService: BzbsService | null;
    uuid: string;
    macAddress: string;
    clientVersion: string;
    os: string;
    platform: string;
    fcmToken: string;
    deviceNotificationEnabled: boolean;
    urls: {
        webCallback: string;
        cart: string;
    };
    tokenFunctions: TokenFunctions | null;
    tokenType: AuthTokenType;
    config: {
        defaultDashboardConfig: string;
        defaultDashboardMode: 'main' | 'sub';
        defaultMenuConfig: string;
        defaultCampaignConfig: string;
    };
};
type BuzzebeesAppActions = {
    setAppId: (appId: string) => void;
    setAppName: (appName: string) => void;
    setBzbsService: (service: BzbsService) => void;
    setUuid: (uuid: string) => void;
    setMacAddress: (macAddress: string) => void;
    setClientVersion: (clientVersion: string) => void;
    setOs: (os: string) => void;
    setPlatform: (platform: string) => void;
    setFcmToken: (fcmToken: string) => void;
    setDeviceNotificationEnabled: (deviceNotificationEnabled: boolean) => void;
    setUrls: (urls: {
        webCallback: string;
        cart: string;
    }) => void;
    setTokenType: (tokenType: AuthTokenType) => void;
    setTokenFunctions: (tokenFunctions: TokenFunctions) => void;
    configure: (config: {
        appId: string;
        appName: string;
        bzbsService: BzbsService;
        uuid: string;
        clientVersion: string;
        os: string;
        platform: string;
        fcmToken: string;
        deviceNotificationEnabled: boolean;
        urls: {
            webCallback: string;
            cart: string;
        };
        tokenFunctions: TokenFunctions;
        tokenType: AuthTokenType;
        defaultDashboardConfig: string;
        defaultDashboardMode: 'main' | 'sub';
        defaultMenuConfig: string;
        defaultCampaignConfig: string;
    }) => void;
};
type BuzzebeesAppStore = BuzzebeesAppState & BuzzebeesAppActions;
declare const useBuzzebeesAppStore: zustand.UseBoundStore<zustand.StoreApi<BuzzebeesAppStore>>;

type CampaignButtonType = 'redeem' | 'get_points' | 'add_to_cart' | 'survey' | 'website' | 'draw' | 'donate' | 'delivery';
type CampaignDetailButtonState = {
    enabled: boolean;
    type: CampaignButtonType;
    display: boolean;
};
type CampaignState = 'redeemable' | 'point_not_enough' | 'expired' | 'cool_down' | 'fail_in_condition' | 'sold_out' | 'redeemed';
type AfterRedeemDestination = 'delivery' | 'draw' | 'code' | 'get_points';
type AfterRedeem = {
    destination: AfterRedeemDestination;
    redeemData: RedeemResponse;
    clear: () => void;
};
type AfterUse = {
    useData: UseCampaignResponse;
    clear: () => void;
};
type CampaignDetailState = {
    data: CampaignDetail | null;
    style: Style | null;
    subStyle: Style | null;
    quantity: number;
    totalPrice: number;
    deliveryAddress: Address | null;
    afterRedeem: AfterRedeem | null;
    afterUse: AfterUse | null;
    buttonState: CampaignDetailButtonState;
    campaignState: CampaignState;
    interfaceWebsite: string | null;
    isLoading: boolean;
    error: ErrorResponse | null;
    campaignId: string | null;
    pictures: string[];
    customCaption?: string;
};
type CampaignDetailActions = {
    setError: (error: ErrorResponse) => void;
    fetchData: (id: string) => Promise<ServiceResponse<CampaignDetail>>;
    redeem: (addressOverride?: Address, options?: {
        [key: string]: unknown;
    }) => Promise<ServiceResponse<RedeemResponse>>;
    use: () => Promise<ServiceResponse<UseCampaignResponse>>;
    addToFavorite: () => Promise<ServiceResponse<unknown>>;
    removeFromFavorite: () => Promise<ServiceResponse<unknown>>;
    setStyle: (style: Style) => void;
    setSubStyle: (style: Style) => void;
    setQuantity: (quantity: number) => void;
    setDeliveryAddress: (address: Address) => void;
    addToCart: () => Promise<ServiceResponse<CartCountResponse>>;
    clear: () => void;
    updateButtonState: () => void;
    checkCondition: () => void;
    calculatePrice: () => void;
};
type CampaignDetailStore = CampaignDetailState & CampaignDetailActions;
declare const createCampaignDetailStore: () => UseBoundStore<StoreApi<CampaignDetailStore>>;

interface CampaignsConfig {
    itemsPerPage?: number;
    defaultCampaignConfig?: string;
}
type CampaignsState = {
    data: Campaign[];
    isLoading: boolean;
    hasMore: boolean;
    error: ErrorResponse | null;
    currentPage: number;
    categoryId: string | null;
    config: CampaignsConfig;
    options: {
        [key: string]: unknown;
    };
};
type CampaignsActions = {
    fetchData: (categoryId?: string, options?: {
        [key: string]: unknown;
    }) => Promise<ServiceResponse<Campaign[]>>;
    loadMore: () => Promise<ServiceResponse<Campaign[]>>;
    clear: () => void;
    updateConfig: (config: Partial<CampaignsConfig>) => void;
};
type CampaignsStore = CampaignsState & CampaignsActions;
declare const createCampaignsStore: (initialConfig: CampaignsConfig) => zustand.UseBoundStore<zustand.StoreApi<CampaignsStore>>;

type CartState = {
    count: number;
    isLoading: boolean;
    error: ErrorResponse | null;
};
type CartActions = {
    fetchCount: () => Promise<ServiceResponse<CartCountResponse>>;
    clear: () => void;
};
type CartStore = CartState & CartActions;
declare const useCartStore: zustand.UseBoundStore<zustand.StoreApi<CartStore>>;

interface CategoriesConfig {
    defaultMenuConfig?: string;
}
type CategoriesState = {
    data: Category[];
    isLoading: boolean;
    error: ErrorResponse | null;
    config: CategoriesConfig;
};
type CategoriesActions = {
    fetchData: () => Promise<ServiceResponse<Category[]>>;
    clear: () => void;
    updateConfig: (config: Partial<CategoriesConfig>) => void;
};
type CategoriesStore = CategoriesState & CategoriesActions;
declare const createCategoriesStore: (initialConfig: CategoriesConfig) => zustand.UseBoundStore<zustand.StoreApi<CategoriesStore>>;

type ConfirmRequest = {
    title: string;
    content: string;
    confirmText?: string;
    cancelText?: string;
    onConfirm?: () => void;
    onCancel?: () => void;
};
type ConfirmState = {
    isOpen: boolean;
    confirmRequest: ConfirmRequest;
};
type ConfirmActions = {
    openConfirm: (request: ConfirmRequest) => void;
    closeConfirm: () => void;
};
type ConfirmStore = ConfirmState & ConfirmActions;
declare const useConfirmStore: zustand.UseBoundStore<zustand.StoreApi<ConfirmStore>>;

type ConsentState = {
    data: Consent | null;
    isLoading: boolean;
    error: ErrorResponse | null;
};
type UpdateConsentParams = {
    termsAndConditions?: string;
    dataPrivacy?: string;
    marketingOption?: string;
    email?: string;
    sms?: string;
    notification?: string;
    line?: string;
    analyticsBuzzebeesCookies?: string;
    analyticsFirebaseCookies?: string;
    analyticsGoogleCookies?: string;
    analyticsMetaCookies?: string;
    analyticsOtherCookies?: string;
    functionalCookies?: string;
    marketingCookies?: string;
    necessaryCookies?: string;
    options?: {
        [key: string]: unknown;
    };
};
type ConsentActions = {
    fetchData: () => Promise<ServiceResponse<Consent>>;
    updateConsent: (consent: UpdateConsentParams) => Promise<ServiceResponse<Consent>>;
    clear: () => void;
};
type ConsentStore = ConsentState & ConsentActions;
declare const useConsentStore: zustand.UseBoundStore<zustand.StoreApi<ConsentStore>>;

type CouponState = {
    data: CouponResponse | null;
    isLoading: boolean;
    error: ServiceResponse<unknown> | null;
};
type CouponActions = {
    processCodes: (codes: string[]) => Promise<ServiceResponse<CouponResponse>>;
    clear: () => void;
};
type CouponStore = CouponState & CouponActions;
declare const useCouponStore: zustand.UseBoundStore<zustand.StoreApi<CouponStore>>;

interface DashboardConfig {
    defaultDashboardMode?: 'main' | 'sub';
    defaultDashboardConfig?: string;
    appId?: string;
}
type DashboardState = {
    data: Dashboard[];
    isLoading: boolean;
    error: ErrorResponse | null;
    config: DashboardConfig;
    options?: {
        [key: string]: unknown;
    };
};
type DashboardActions = {
    setIsLoading: (isLoading: boolean) => void;
    setError: (error: ErrorResponse) => void;
    fetchData: (options?: {
        [key: string]: unknown;
    }) => Promise<ServiceResponse<Dashboard[]>>;
    clear: () => void;
    updateConfig: (config: Partial<DashboardConfig>) => void;
};
type DashboardStore = DashboardState & DashboardActions;
declare const createDashboardStore: (initialConfig: DashboardConfig) => zustand.UseBoundStore<zustand.StoreApi<DashboardStore>>;

type LoadingIndicatorState = {
    loading: boolean;
};
type LoadingIndicatorActions = {
    show: () => void;
    hide: () => void;
};
type LoadingIndicatorStore = LoadingIndicatorState & LoadingIndicatorActions;
declare const useLoadingIndicatorStore: zustand.UseBoundStore<zustand.StoreApi<LoadingIndicatorStore>>;
declare const useLoading: (isLoading: boolean) => void;

type AppLocale = {
    locale: string;
    localeId: number;
};
declare const EN: {
    locale: string;
    localeId: number;
};
declare const TH: {
    locale: string;
    localeId: number;
};
type LocaleState = {
    appLocale: AppLocale;
    locale: string;
    localeId: number;
};
type LocaleActions = {
    setAppLocale: (locale: AppLocale | string) => void;
};
type LocaleStore = LocaleState & LocaleActions;
declare const useLocaleStore: zustand.UseBoundStore<zustand.StoreApi<LocaleStore>>;

type MaintenanceState = {
    isMaintenance: boolean | null;
    maintenanceData: Maintenance | null;
};
type MaintenanceActions = {
    checkMaintenance: () => Promise<void>;
};
type MaintenanceStore = MaintenanceState & MaintenanceActions;
declare const useMaintenanceStore: zustand.UseBoundStore<zustand.StoreApi<MaintenanceStore>>;

type NotificationState = {
    data: Notification[];
    isLoading: boolean;
    error: ErrorResponse | null;
    unreadCount: number;
    hasMore: boolean;
    currentPage: number;
    pageSize: number;
};
type NotificationActions = {
    fetchData: () => Promise<ServiceResponse<Notification[]>>;
    loadMore: () => Promise<ServiceResponse<Notification[]>>;
    markAsRead: (ids: string[]) => Promise<ServiceResponse<unknown>>;
    setUnreadCount: (count: number) => void;
    setPageSize: (size: number) => void;
    clear: () => void;
};
type NotificationStore = NotificationState & NotificationActions;
declare const useNotificationStore: zustand.UseBoundStore<zustand.StoreApi<NotificationStore>>;

interface PointLogConfig {
    defaultPageSize?: number;
    type: 'earn' | 'burn';
}
type PointLogState = {
    data: PointLog[];
    isLoading: boolean;
    hasMore: boolean;
    error: ErrorResponse | null;
    config: PointLogConfig;
    lastRowKey?: string;
    currentMonth?: string;
};
type PointLogActions = {
    fetchData: (month?: string) => Promise<ServiceResponse<PointLog[]>>;
    loadMore: () => Promise<ServiceResponse<PointLog[]>>;
    clear: () => void;
    updateConfig: (config: Partial<PointLogConfig>) => void;
};
type PointLogStore = PointLogState & PointLogActions;
declare const createPointLogStore: (initialConfig: PointLogConfig) => zustand.UseBoundStore<zustand.StoreApi<PointLogStore>>;

type PopupRequest = {
    title?: string;
    content: string;
    closeText?: string;
    onClose?: () => void;
    closable?: boolean;
};
type PopupState = {
    isOpen: boolean;
    popupRequest: PopupRequest;
};
type PopupActions = {
    openPopup: (request: PopupRequest) => void;
    closePopup: () => void;
};
type PopupStore = PopupState & PopupActions;
declare const usePopupStore: zustand.UseBoundStore<zustand.StoreApi<PopupStore>>;

interface PurchaseConfig {
    defaultPageSize?: number;
    defaultConfig?: string;
}
type PurchaseState = {
    data: Purchase[];
    isLoading: boolean;
    error: ErrorResponse | null;
    config: PurchaseConfig & {
        defaultPageSize: number;
    };
    currentPage: number;
    hasMore: boolean;
    startDate?: string;
    endDate?: string;
};
type PurchaseActions = {
    fetchData: (startDate?: string, endDate?: string) => Promise<ServiceResponse<Purchase[]>>;
    loadMore: () => Promise<ServiceResponse<Purchase[]>>;
    clear: () => void;
    updateConfig: (config: Partial<PurchaseConfig>) => void;
};
type PurchaseStore = PurchaseState & PurchaseActions;
declare const createPurchaseStore: (initialConfig: PurchaseConfig) => zustand.UseBoundStore<zustand.StoreApi<PurchaseStore>>;

type RegistrationState = {
    username: string;
    password: string;
    confirmPassword: string;
    contactNumber: string;
    firstName: string;
    lastName: string;
    otp: string;
    refCode: string;
    address?: string;
    gender?: string;
    birthDate?: number;
    email?: string;
    refUserCode?: string;
    consentVersion: {
        termAndCondition: string;
        dataPrivacy: string;
        marketingOptions: string;
    } | null;
    termAndConditionAccepted: boolean;
    dataPrivacyAccepted: boolean;
    marketingAccepted: boolean;
    emailMarketingAccepted: boolean;
    smsMarketingAccepted: boolean;
    notificationMarketingAccepted: boolean;
    lineMarketingAccepted: boolean;
    phoneMarketingAccepted: boolean;
    isLoading: boolean;
    error: ErrorResponse | null;
};
type RegistrationActions = {
    setUsername: (value: string) => void;
    setPassword: (value: string) => void;
    setConfirmPassword: (value: string) => void;
    setContactNumber: (value: string) => void;
    setFirstName: (value: string) => void;
    setLastName: (value: string) => void;
    setOtp: (value: string) => void;
    setRefCode: (value: string) => void;
    setAddress: (value: string) => void;
    setGender: (value: string) => void;
    setBirthDate: (value: number) => void;
    setEmail: (value: string) => void;
    setRefUserCode: (value: string) => void;
    setTermAndConditionAccepted: (value: boolean) => void;
    setDataPrivacyAccepted: (value: boolean) => void;
    setMarketingAccepted: (value: boolean) => void;
    setEmailMarketingAccepted: (value: boolean) => void;
    setSmsMarketingAccepted: (value: boolean) => void;
    setNotificationMarketingAccepted: (value: boolean) => void;
    setLineMarketingAccepted: (value: boolean) => void;
    setPhoneMarketingAccepted: (value: boolean) => void;
    setError: (value: ErrorResponse | null) => void;
    setConsentVersion: (termAndCondition: string, dataPrivacy: string, marketingOptions: string) => void;
    clearData: () => void;
    sendOtp: () => Promise<ServiceResponse<OtpResponse>>;
    validateOtp: () => Promise<ServiceResponse<ValidateOtpResponse>>;
    register: () => Promise<ServiceResponse<RegistrationResponse>>;
    requestOTP: () => Promise<ServiceResponse<unknown>>;
    verifyOTP: () => Promise<ServiceResponse<unknown>>;
    clear: () => void;
};
type RegistrationStore = RegistrationState & RegistrationActions;
declare const useRegistrationStore: zustand.UseBoundStore<zustand.StoreApi<RegistrationStore>>;

type UpdateProfileParams = {
    profileImage?: File | {
        uri: string;
        name: string;
        type: string;
    };
    firstName?: string;
    lastName?: string;
    contactNumber?: string;
    email?: string;
    notification?: boolean;
    locale?: number;
    title?: string;
    gender?: string;
    birthDate?: number;
    address?: string;
    subdistrictCode?: number;
    subdistrictName?: string;
    districtCode?: number;
    districtName?: string;
    provinceCode?: number;
    provinceName?: string;
    countryCode?: string;
    countryName?: string;
    zipCode?: string;
    idCard?: string;
    passport?: string;
    maritalStatus?: string;
    village?: string;
    building?: string;
    number?: string;
    moo?: string;
    room?: string;
    floor?: string;
    soi?: string;
    city?: string;
    road?: string;
    landmark?: string;
    alternateContactNumber?: string;
    homeContactNumber?: string;
    nationality?: string;
    religion?: string;
    location?: string;
    latitude?: number;
    longitude?: number;
    income?: string;
    interests?: string;
    region?: string;
    phonepurchase?: number;
    highestEducation?: string;
    occupation?: string;
    remark?: string;
    displayName?: string;
    options?: {
        [key: string]: any;
    };
};
type UserState = {
    user: ProfileResponse | null;
    points: number;
    recentPoints: number;
    expiringPoints: UpdatedPoints[];
    recentBadge: Badge | null;
    recentTrace: Trace | null;
    cartCount: number;
    isLoading: boolean;
    error: ErrorResponse | null;
    badgeList: Badge[];
    traceList: Trace[];
};
type UserActions = {
    fetchUser: () => Promise<ServiceResponse<ProfileResponse>>;
    fetchPoint: () => Promise<ServiceResponse<UpdatedPoints>>;
    fetchExpiringPoints: () => Promise<ServiceResponse<ExpiringPoints>>;
    fetchCartCount: () => Promise<ServiceResponse<CartCountResponse>>;
    editUser: (data: UpdateProfileParams) => Promise<ServiceResponse<ProfileResponse>>;
    changePassword: (oldPassword: string, newPassword: string) => Promise<ServiceResponse<StatusResponse>>;
    changeContactNumber: (contactNumber: string, otp: string, refCode: string) => Promise<ServiceResponse<ConfirmOtpResponse>>;
    changeAvatar: (avatar: File) => Promise<ServiceResponse<ProfileResponse>>;
    consumeRecentPoints: () => void;
    consumeRecentBadge: () => void;
    consumeRecentTrace: () => void;
    deleteUser: () => Promise<ServiceResponse<any>>;
    setError: (error: ErrorResponse | null) => void;
    clear: () => void;
    setupEventListeners: () => void;
    cleanupEventListeners: () => void;
};
type UserStore = UserState & UserActions;
declare const useUserStore: zustand.UseBoundStore<zustand.StoreApi<UserStore>>;

type ZipcodeState = {
    data: ZipCode[];
    isLoading: boolean;
    error: ErrorResponse | null;
};
type ZipcodeActions = {
    fetchData: (zipcode: string) => Promise<ServiceResponse<ZipCode>>;
    clear: () => void;
};
type ZipcodeStore = ZipcodeState & ZipcodeActions;
declare const useZipcodeStore: zustand.UseBoundStore<zustand.StoreApi<ZipcodeStore>>;

export { type AddressActions, type AddressState, type AddressStore, type AddressUpdateParams, type AfterRedeem, type AfterRedeemDestination, type AfterUse, type AlertActions, type AlertRequest, type AlertState, type AlertStore, type AppLocale, type AuthActions, type AuthState, type AuthStore, type AuthTokenType, type BuzzebeesAppActions, type BuzzebeesAppState, type BuzzebeesAppStore, type CampaignButtonType, type CampaignDetailActions, type CampaignDetailButtonState, type CampaignDetailState, type CampaignDetailStore, type CampaignState, type CampaignsActions, type CampaignsConfig, type CampaignsState, type CampaignsStore, type CartActions, type CartState, type CartStore, type CategoriesActions, type CategoriesConfig, type CategoriesState, type CategoriesStore, type ConfirmActions, type ConfirmRequest, type ConfirmState, type ConfirmStore, type ConsentActions, type ConsentState, type ConsentStore, type CouponActions, type CouponState, type CouponStore, type DashboardActions, type DashboardConfig, type DashboardState, type DashboardStore, EN, type LoadingIndicatorActions, type LoadingIndicatorState, type LoadingIndicatorStore, type LocaleActions, type LocaleState, type LocaleStore, type MaintenanceActions, type MaintenanceState, type MaintenanceStore, type NotificationActions, type NotificationState, type NotificationStore, type PointLogActions, type PointLogConfig, type PointLogState, type PointLogStore, type PopupActions, type PopupRequest, type PopupState, type PopupStore, type PurchaseActions, type PurchaseConfig, type PurchaseState, type PurchaseStore, type RegistrationActions, type RegistrationState, type RegistrationStore, TH, type TokenFunctions, type UpdateProfileParams, type UserActions, type UserState, type UserStore, type ZipcodeActions, type ZipcodeState, type ZipcodeStore, createCampaignDetailStore, createCampaignsStore, createCategoriesStore, createDashboardStore, createPointLogStore, createPurchaseStore, useAddressStore, useAlertStore, useAuthStore, useBuzzebeesAppStore, useCartStore, useConfirmStore, useConsentStore, useCouponStore, useLoading, useLoadingIndicatorStore, useLocaleStore, useMaintenanceStore, useNotificationStore, usePopupStore, useRegistrationStore, useUserStore, useZipcodeStore };