import React, { FunctionComponent, ReactNode, CSSProperties, HTMLAttributes } from 'react';
import { ImageProps, ButtonProps, IconProps, BadgeProps, InputNumberProps, InfiniteloadingProps, TextAreaProps, PopupProps } from '@nutui/nutui-react';

interface BaseLang {
    save: string;
    confirm: string;
    cancel: string;
    done: string;
    noData: string;
    placeholder: string;
    select: string;
    name: string;
    tel: string;
    default: string;
    addres: string;
    video: {
        errorTip: string;
        clickRetry: string;
    };
    fixednav: {
        activeText: string;
        unActiveText: string;
    };
    infiniteloading: {
        pullRefreshText: string;
        loadText: string;
        loadMoreText: string;
    };
    searchHistory: {
        recentSearchText: string;
        searchDiscoverText: string;
        noDiscoverDataText: string;
        rightOutIcon: string;
        deleteAll: string;
        finish: string;
        hidden: string;
    };
    settleBar: {
        totalText: string;
        settleButtonText: string;
        selectAll: string;
    };
    pagination: {
        prev: string;
        next: string;
    };
    range: {
        rangeText: string;
    };
    calendaritem: {
        weekdays: Array<string>;
        end: string;
        start: string;
        title: string;
        monthTitle: Function;
        today: string;
        loadPreviousMonth: string;
        noEarlierMonth: string;
    };
    shortpassword: {
        title: string;
        desc: string;
        tips: string;
    };
    uploader: {
        ready: string;
        readyUpload: string;
        waitingUpload: string;
        uploading: string;
        success: string;
        error: string;
        deleteWord: string;
    };
    countdown: {
        day: string;
        hour: string;
        minute: string;
        second: string;
    };
    address: {
        selectRegion: string;
        deliveryTo: string;
        chooseAnotherAddress: string;
    };
    signature: {
        reSign: string;
        unSupportTpl: string;
    };
    ecard: {
        chooseText: string;
        otherValueText: string;
        placeholder: string;
    };
    receiveInvoiceEdit: {
        nameText: string;
        namePlaceholder: string;
        nameErrorMsg: string;
        telText: string;
        telPlaceholder: string;
        telErrorMsg: string;
        regionText: string;
        regionPlaceholder: string;
        regionErrorMsg: string;
        addressText: string;
        addressPlaceholder: string;
        addressErrorMsg: string;
        bottomText: string;
    };
    timeselect: {
        pickupTime: string;
    };
    sku: {
        buyNow: string;
        buyNumber: string;
        addToCard: string;
        confirm: string;
    };
    skuheader: {
        skuId: string;
    };
    addresslist: {
        addAddress: string;
    };
    itemContents: {
        default: string;
    };
    swipeShell: {
        delete: string;
    };
    generalShell: {
        copyAddress: string;
        setDefault: string;
        deleteAddress: string;
    };
    comment: {
        complaintsText: string;
        additionalReview: Function;
        additionalImages: Function;
    };
    searchbar: {
        basePlaceholder: string;
        text: string;
        test: string;
        title1: string;
        title2: string;
        title3: string;
        title4: string;
        title5: string;
        title6: string;
    };
    audio: {
        back: string;
        forward: string;
        pause: string;
        start: string;
        mute: string;
        tips: string;
    };
    datepicker: {
        year: string;
        month: string;
        day: string;
        hour: string;
        min: string;
        seconds: string;
    };
    pullToRefresh: {
        pullingText: string;
        canReleaseText: string;
        refreshingText: string;
        completeText: string;
    };
    orderRemark: {
        placeholderText: string;
        title: string;
        tagTitle: string;
        submitText: string;
    };
    horizontalscrolling: {
        more: string;
    };
    orderCancelPanel: {
        otherText: string;
    };
    addressedit: {
        nameText: string;
        namePlaceholder: string;
        nameErrorMsg: string;
        telText: string;
        telPlaceholder: string;
        telErrorMsg: string;
        regionText: string;
        regionPlaceholder: string;
        regionErrorMsg: string;
        addressText: string;
        addressPlaceholder: string;
        addressErrorMsg: string;
        bottomText: string;
        setDefaultText: string;
        errorToastText: string;
    };
    login: {
        accountPlaceholder: string;
        telOrMailPlaceholder: string;
        passwordPlaceholder: string;
        verifyPlaceholder: string;
        verifyButtonText: string;
        getCodeErrorToast: string;
        switchLoginText1: string;
        switchLoginText2: string;
        forgetPwdText: string;
        loginButtonText: string;
    };
    category: {
        pullUpText: string;
    };
}

interface ConfigProviderProps {
    locale: BaseLang;
}
declare const ConfigProvider: FunctionComponent<Partial<ConfigProviderProps> & React.HTMLAttributes<HTMLDivElement>>;

type numericProp = number | string;

interface CardProps {
    title: string;
    price: ReactNode;
    shopName: string;
    className: string;
    showType: string;
    style: CSSProperties;
    titleLine: numericProp;
    prolistTpl: ReactNode;
    productTagsTpl: ReactNode;
    priceAfterTpl: ReactNode;
    bottomTpl: ReactNode;
    infoTpl: ReactNode;
    imgTag: ReactNode;
    titleTag: ReactNode;
    isNeedPrice: boolean;
    imgTagDirection: string;
    imageProps: Partial<ImageProps>;
    onClick: () => void;
    onClickShop: () => void;
}
declare const Card: FunctionComponent<Partial<CardProps> & HTMLAttributes<HTMLDivElement>>;

interface IComponent {
    className?: string;
    style?: CSSProperties;
    iconFontClassName?: string;
    iconClassPrefix?: string;
    children?: ReactNode;
}

interface CartBarProps extends IComponent {
    hasCapsuleButtons: boolean;
    safeAreaInsetBottom: boolean;
    placeholder: boolean;
    top: ReactNode;
}
declare const CartBar: FunctionComponent<Partial<CartBarProps>>;

interface CartBarButtonProps extends IComponent {
    text: ReactNode;
    buttonProps: Partial<ButtonProps>;
    onClick: () => void;
}
declare const CartBarButton: FunctionComponent<Partial<CartBarButtonProps>>;

interface CartBarIconProps extends IComponent {
    text: ReactNode;
    iconProps: Partial<Omit<IconProps, "className">>;
    badgeProps: Partial<BadgeProps>;
    onClick: () => void;
}
declare const CartBarIcon: FunctionComponent<Partial<CartBarIconProps>>;

interface Category$1 {
    catId: string | number;
    catName: string;
    children?: Array<CategoryPane>;
    [props: string]: any;
}
interface CategoryPaneItem {
    backImg?: string;
    catId: string;
    catName: string;
    [props: string]: any;
}
interface CategoryPane {
    catId: string | number;
    catName: string;
    children?: Array<CategoryPaneItem>;
    [props: string]: any;
}

interface CategoryProps extends IComponent {
    className?: string;
    style?: CSSProperties;
    showSkuImg: boolean;
    category: Category$1[];
    showSecondLevelQuickNav: boolean;
    isLeftAutoSlide: boolean;
    isLazy: boolean;
    loadingImg: string;
    errorImg: string;
    showPullUp?: boolean;
    pullUpText?: ReactNode;
    onChange: (index: Category$1) => void;
    onPanelNavClick: (index: number) => void;
    onPanelThirdClick: (sku: CategoryPaneItem) => void;
}
declare const Category: FunctionComponent<Partial<CategoryProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'>>;

interface GoodsClickParams {
    type: string;
    index: string | number;
    value: VideosType | ImagesType;
}
interface VideosType {
    id?: number | string;
    mainUrl?: string;
    videoUrl?: string;
}
interface ImagesType {
    id?: number | string;
    smallImgUrl?: string;
    bigImgUrl?: string;
    imgUrl?: string;
}

interface CommentInfo {
    content: string;
    nickName: string;
    score: number;
    avatar: string;
    time: string;
    size?: string;
    reply?: number;
    like?: number;
}
interface CommentFollow {
    days: number;
    content: string;
    images?: string[];
}
interface CommentProps extends IComponent {
    type: "default" | "complex";
    imagesRows: "one" | "multi";
    ellipsis: string | number;
    videos: Array<VideosType>;
    images: Array<ImagesType>;
    info: CommentInfo;
    follow: CommentFollow;
    operation: Array<string>;
    commentLabels: ReactNode;
    commentShopReply: ReactNode;
    onClickOperate: (type: string) => void;
    onClick: (info: any) => void;
    onClickImages: (imgs: GoodsClickParams) => void;
}
declare const Comment: FunctionComponent<Partial<CommentProps> & HTMLAttributes<HTMLDivElement>>;

interface DataListItem {
    price: number;
}
interface EcardProps {
    className?: string;
    style?: CSSProperties;
    chooseText: ReactNode;
    suffix: string;
    otherValueText: ReactNode;
    dataList: Array<DataListItem>;
    cardAmountMin: number;
    cardAmountMax: number;
    inputNumberProps: Partial<InputNumberProps>;
    placeholder: string;
    rowNum?: number;
    handleMoney?: (money: number) => any;
    onChange?: (item: DataListItem, money: number) => void;
    onChangeInput?: (val: number, money: number) => void;
    onChangeStep?: (num: number, price: number, money: number) => void;
}
declare const Ecard: FunctionComponent<Partial<EcardProps> & Omit<React.HTMLAttributes<HTMLDivElement>, "onChange">>;

interface valueType {
    id?: numericProp;
    name?: string;
    [x: string]: any;
}
interface goodsAttrsResType {
    id?: numericProp;
    value?: string[];
    [x: string]: any;
}
interface resType {
    address: string;
    price: {
        low: numericProp;
        high: numericProp;
    };
    filterAttrs: valueType;
    goodsAttrs: goodsAttrsResType;
}
interface priceRangesType {
    low: string;
    high: string;
    desc: string;
    id?: numericProp;
    extra: any;
}
interface goodsAttrsType {
    title: string;
    id: numericProp;
    values: valueType;
}
interface selectedGoodsAttrType {
    id: numericProp;
    isExpand: boolean | undefined;
    showRow: numericProp;
    title: string;
    [x: string]: any;
}
interface selectDataType {
    filterAttrs: valueType[];
    goodsAttrs: goodsAttrsType[];
    price: {
        low: string;
        high: string;
    };
}
interface GoodsFilterProps extends IComponent {
    visible?: boolean;
    confirmText?: React.ReactNode;
    resetText?: React.ReactNode;
    priceRangeTitle?: string;
    addressTitle?: string;
    selectedAddress: string;
    resetDisable?: boolean;
    priceRanges?: priceRangesType[];
    filterAttrs?: valueType[];
    goodsAttrs?: goodsAttrsType[];
    specStyle?: CSSProperties;
    selectedSpecShow?: boolean;
    maxLine: number;
    icon?: string;
    selectData?: selectDataType;
    onClose?: () => void;
    onReset?: () => void;
    onConfirm?: (res: resType) => void;
    onClickAddress?: () => void;
    onSelectedAttrs?: (attr: valueType, selected: boolean, selectedAttrs: valueType[]) => void;
    onSelectedPrice?: (range: priceRangesType) => void;
    onBeforeSelected?: (done: () => void, selectedValue: goodsAttrsResType) => void;
    onSelectedGoodsAttr?: (attrs: selectedGoodsAttrType, value: valueType) => void;
    bottom?: React.ReactNode;
}
declare const GoodsFilter: FunctionComponent<Partial<GoodsFilterProps> & HTMLAttributes<HTMLDivElement>>;

interface IDataItem {
    displayName: string;
    imageUrl: React.ReactNode;
}
interface QuickEnterProps extends IComponent {
    className: string;
    style: CSSProperties;
    columns: numericProp;
    rows: numericProp;
    data: Array<IDataItem>;
    slideMode: "swiper" | "slide";
    iconSize: Array<numericProp>;
    indicatorVisible: boolean;
    indicatorBgColor: string;
    indicatorActiveColor: string;
    onClickItem: (val: IDataItem) => void;
}
declare const QuickEnter: FunctionComponent<Partial<QuickEnterProps>>;

type IsearchItem = {
    key: ReactNode;
    url: string;
};
interface SearchHistoryProps extends IComponent {
    recentSearchData: Array<IsearchItem>;
    searchDiscoverData: Array<IsearchItem>;
    recentSearchText: string;
    searchDiscoverText: string;
    backIcon: ReactNode;
    deleteIcon: ReactNode;
    keyword: string;
    leftInIcon: ReactNode;
    rightOutIcon: ReactNode;
    rightInIcon: ReactNode;
    searchDiscoverExtra?: ReactNode;
    openEyeIcon: ReactNode;
    closeEyeIcon: ReactNode;
    refreshIcon?: string;
    noDiscoverDataText: string;
    deleteType: string;
    recentSearchCollapse: boolean;
    onClickSearchButton: (value: string) => void;
    onClickBackIcon: () => void;
    onClickSearchItem: (searchItem: IsearchItem) => void;
    onClickRightInIcon: () => void;
    onSearchBarChange: (value: string, event: Event) => void;
    onDelete: () => void;
    onDeleteSingle: (item: IsearchItem) => void;
    onRefresh: () => void;
}
declare const SearchHistory: FunctionComponent<Partial<SearchHistoryProps>>;

interface SettleBarProps extends IComponent {
    total: numericProp;
    totalText: string;
    totalAlign: string;
    settleButtonText: string;
    disabled: boolean;
    loading: boolean;
    safeAreaInsetBottom: boolean;
    placeholder: boolean;
    settleCount: ReactNode;
    showZero: boolean;
    noCount: boolean;
    customWarning: ReactNode;
    customTotal: ReactNode;
    customSelectAll: ReactNode;
    customTotalPrice: ReactNode;
    customTotalExtra: ReactNode;
    customButton: ReactNode;
    isCheckedAll: boolean;
    onClickButton: () => void;
    onSelectAll: (checked: boolean) => void;
}
declare const SettleBar: FunctionComponent<Partial<SettleBarProps>>;

interface SkuProps extends IComponent {
    className: string;
    style: CSSProperties;
    visible: boolean;
    skuHeaderPrice: ReactNode;
    skuHeaderExtra: ReactNode;
    skuHeader: ReactNode;
    skuSelectTop: ReactNode;
    skuSelect: ReactNode;
    skuStepper: ReactNode;
    skuStepperBottom: ReactNode;
    skuOperate: ReactNode;
    operateBtn: ReactNode;
    goods: {
        price: number;
        imagePath: string;
        skuId: string;
    };
    sku: Array<any>;
    stepperMax: string | number;
    stepperMin: string | number;
    stepperExtraText: (() => ReactNode) | boolean;
    stepperTitle: string;
    btnOptions: Array<string>;
    btnExtraText: string;
    buyText: string;
    addCartText: string;
    confirmText: string;
    onClickBtnOperate: (btn: string) => void;
    onClose: () => void;
    onClickCloseIcon: () => void;
    onClickOverlay: () => void;
    onSelectSku: (skus: any) => void;
    onAdd: (value: number) => void;
    onReduce: (value: number) => void;
    onChangeStepper: (value: number) => void;
    onOverLimit: () => void;
}
declare const Sku: FunctionComponent<Partial<SkuProps>>;

type colType = 1 | 2 | '1' | '2';
interface ProductFeedProps extends IComponent {
    data: Array<any>;
    itemKey: string;
    customProduct: (item: any) => ReactNode;
    openInfiniteloading: boolean;
    infiniteloadingProps?: Partial<InfiniteloadingProps>;
    initProductNum: number;
    col: colType;
    padding: numericProp;
    borderRadius: numericProp;
    imgUrl: string;
    imgWidth: string;
    imgHeight: string;
    imgTag?: ReactNode;
    isImageLazy: boolean;
    loadingImg: string;
    errorImg: string;
    onClick: (item: object, number: number) => void;
    onImageClick: (item: object, number: number) => void;
}
declare const ProductFeed: FunctionComponent<Partial<ProductFeedProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onClick'>>;

interface RegionData {
    name?: string;
    [key: string]: any;
}
interface ChangeCallBack {
    next: string;
    value: RegionData;
    custom: string;
}
interface CloseCallBackData extends SelectedRegionObj {
    addressIdStr: string;
    addressStr: string;
}
interface CloseCallBack {
    data: CloseCallBackData | AddressList$1;
    type: string;
}
interface AddressList$1 {
    id?: string | number;
    provinceName: string;
    cityName: string;
    countyName: string;
    townName: string;
    addressDetail: string;
    selectedAddress: boolean;
    name?: string;
    phone?: string;
}
interface NextListObj {
    next: string;
    value: RegionData;
    custom: string;
    selectedRegion?: SelectedRegionObj;
}
interface SelectedRegionObj {
    province: RegionData;
    city: RegionData;
    country: RegionData;
    town: RegionData;
}
interface baseAddressInfo {
    province: RegionData[];
    city: RegionData[];
    country: RegionData[];
    town: RegionData[];
}
type AddressType = 'exist' | 'custom' | 'elevator';
interface AddressProps extends IComponent, baseAddressInfo {
    className?: string;
    style?: CSSProperties;
    modelValue: boolean;
    modelSelect: (string | number)[];
    type: AddressType;
    isShowCustomAddress: boolean;
    existAddress: AddressList$1[];
    loading: boolean;
    customAddressTitle: ReactNode;
    existAddressTitle: ReactNode;
    customAndExistTitle: ReactNode;
    height: string | number;
    defaultIcon: ReactNode;
    selectedIcon: ReactNode;
    closeBtnIcon: string;
    backBtnIcon: string;
    bottom: ReactNode;
    onSelected?: (prevExistAdd: AddressList$1, item: AddressList$1, copyExistAdd: AddressList$1[]) => void;
    onClose?: (cal: CloseCallBack) => void;
    onCloseMask?: (cal: {
        closeWay: string;
    }) => void;
    onSwitchModule?: (cal: {
        type: string;
    }) => void;
    onChange?: (cal: ChangeCallBack) => void;
    onClickItem?: (cal: ChangeCallBack, resolve: (value: boolean | PromiseLike<boolean>) => void) => Promise<void>;
    onTabChecked?: (cal: string) => void;
}

declare const Address: FunctionComponent<Partial<AddressProps>>;

interface AddressInfo {
    name?: string;
    tel?: string;
    region?: string;
    regionIds?: (numericProp)[];
    address?: string;
    default?: boolean;
    [key: string]: any;
}
interface AddressData {
    id?: numericProp;
    nameText: string;
    namePlaceholder: string;
    nameErrorMsg: string;
    telText: string;
    telPlaceholder: string;
    telErrorMsg: string;
    regionText: string;
    regionPlaceholder: string;
    regionErrorMsg: string;
    addressText: string;
    addressPlaceholder: string;
    addressErrorMsg: string;
    isDefualtAddress?: boolean;
    isRequired?: string[];
    bottomText: string;
    errorShowType?: string;
    errorToastText?: string;
    [key: string]: any;
}
interface AddressResult$1 {
    addressSelect?: (numericProp)[];
    addressStr?: string;
    province?: RegionData[];
    city?: RegionData[];
    country?: RegionData[];
    town?: RegionData[];
    addressTitle?: string;
    type?: AddressType;
    height?: string;
}
interface AddressEditProps extends IComponent {
    addressInfo: AddressInfo;
    data: Partial<AddressData>;
    address: AddressResult$1;
    bottomInputTpl?: ReactNode;
    showSave?: Boolean;
    showDefault?: Boolean;
    buttonProps?: Partial<ButtonProps>;
    onChange?: (val: string, tag: string) => void;
    onChangeAddress?: (data: any) => void;
    onCloseAddress?: (data: any) => void;
    onSave?: (data: any) => void;
    onSwitch?: (state: boolean, data: any) => void;
}
declare const AddressEdit: FunctionComponent<Partial<AddressEditProps> & Omit<React.HTMLAttributes<HTMLDivElement>, "onChange">>;

interface IDataInfo {
    id: numericProp;
    addressName: string;
    phone: string;
    defaultAddress: boolean;
    fullAddress: string;
}
type functionType = (event: Event, item: Object) => void;
interface AddressListProps extends IComponent {
    data: Array<IDataInfo>;
    longPress: boolean;
    swipeEdition: boolean;
    showBottomButton: boolean;
    dataMapOptions: Object;
    onAdd?: (event: Event) => void;
    onDelIcon?: functionType;
    onEditIcon?: functionType;
    onItemClick?: functionType;
    onSwipeDel?: functionType;
    onLongCopy?: functionType;
    onLongSet?: functionType;
    onLongDel?: functionType;
}
declare const AddressList: FunctionComponent<Partial<AddressListProps>>;

interface DeliveryBaseType {
    label: string;
    text: ReactNode;
    selected?: boolean;
    disabled?: boolean;
}
type DeliveryDateType = 'date' | 'date-time' | 'date-time-accurate';
interface DateType extends DeliveryBaseType {
}
interface DateTimeType {
    label: string;
    title: ReactNode;
    children: Array<DateType>;
}
interface DateTimeAccurateType {
    label: string;
    title: ReactNode;
    children: DateTimeType[];
}
type DateTimesType = DateType | DateTimeType | DateTimeAccurateType;
interface DeliveryTypes extends DeliveryBaseType {
    disabled?: boolean;
    desc?: ReactNode;
    children?: ReactNode;
}
interface DeliveryData extends DeliveryTypes {
    type: DeliveryDateType;
    times: DateTimesType[];
}

interface DeliveryProps extends IComponent {
    visible: boolean;
    title?: ReactNode;
    deliveryTypes?: Array<DeliveryTypes>;
    deliveryTimeTitle?: ReactNode;
    deliveryDateData?: DeliveryData[];
    popStyle?: CSSProperties;
    popClassName?: string;
    duration: number;
    buttonText?: ReactNode;
    onCloseMask?: () => void;
    onClose?: () => void;
    onSure?: (item: DateTimesType | null, type: string) => void;
    onDeliveryTypeChange?: (label: numericProp | boolean) => void;
}
declare const Delivery: FunctionComponent<Partial<DeliveryProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'title'>>;

interface DeliveryDateProps extends IComponent {
    data: DateType[];
    activeKey?: numericProp;
    onSelect?: (item: DateType) => void;
}
declare const DeliveryDate: FunctionComponent<Partial<DeliveryDateProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'>>;

interface DeliveryDateTimeProps extends IComponent {
    data: DateTimeType[];
    activeKey?: numericProp;
    onSelect?: (item: DateTimeType) => void;
}
declare const DeliveryDateTime: FunctionComponent<Partial<DeliveryDateTimeProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'>>;

interface DeliveryDateTimeAccurateProps extends IComponent {
    data: DateTimeAccurateType[];
    activeKey?: numericProp;
    onSelect?: (item: DateTimeAccurateType) => void;
}
declare const DeliveryDateTimeAccurate: FunctionComponent<Partial<DeliveryDateTimeAccurateProps> & Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect'>>;

type ICheckboxPosition = "front" | "back";
interface IreasonsObject {
    key: string;
    value: string;
    [x: string]: any;
}
interface OrderCancelPanelProps extends IComponent {
    showCancelPanel: boolean;
    warmTips: string[];
    cancelReason: Array<IreasonsObject>;
    canCancelReason: boolean;
    popupTitle: React.ReactNode;
    reasonTitle: React.ReactNode;
    submitText: string;
    tipsTitle: React.ReactNode;
    buttonProps: Partial<ButtonProps>;
    textAreaProps: Partial<Omit<TextAreaProps, "defaultValue">>;
    popupProps: Partial<PopupProps>;
    checkboxType: ICheckboxPosition;
    safeAreaCancelBottom: boolean;
    showBtntips: boolean;
    onClose: () => void;
    onSubmitBtn: (selectedReason: IreasonsObject, textAreaValue: string, switchStatus: boolean) => void;
}
declare const OrderCancelPanel: FunctionComponent<Partial<OrderCancelPanelProps> & React.HTMLAttributes<HTMLDivElement>>;

interface OrderRemarkProps extends IComponent {
    visible: boolean;
    closeOnClickOverlay: boolean;
    maxLength: number;
    placeholderText: string;
    title: ReactNode;
    tagTitle: ReactNode;
    remark: string;
    submitText: string;
    recommendTags: string[];
    onClickOverlay?: (val: string) => void;
    onClose?: (val: string) => void;
    onOpen?: () => void;
    onChange?: (val: string) => void;
    onClickTag?: (tag: string, index: number, remark: string) => void;
    onSubmit?: (val: string) => void;
}
declare const OrderRemark: FunctionComponent<Partial<OrderRemarkProps>>;

interface Idata$1 {
    titleType?: string;
    title: string;
    companyCode: string;
    address: string;
    companyPhone: string;
    bankDeposit: string;
    bankAccount: string;
}
type invoiceType = "special" | "normal";
interface InvoiceTitleEditProps extends IComponent {
    invoiceType: invoiceType;
    bottom: ReactNode;
    buttonProps: Partial<Omit<ButtonProps, "type | block">>;
    submitButtonText: string;
    data: Idata$1;
    onSubmit: (arg: any) => void;
    onInput: (value: numericProp, event?: Event) => void;
}
declare const InvoiceTitleEdit: FunctionComponent<Partial<InvoiceTitleEditProps>>;

interface Idata {
    isSelected: boolean;
    type: string;
    status?: string;
    isShowDefault: boolean;
    title: string;
    companyCode: string;
    address: string;
    companyPhone: string;
    bankDeposit: string;
    bankAccount: string;
    isDelete: boolean;
    isEdit: boolean;
}
interface InvoiceTitleListProps extends IComponent {
    data: Idata;
    className: string;
    style: CSSProperties;
    otherOperate: ReactNode;
    onClick: (data: any) => void;
    onDelete: (data: any) => void;
    onEdit: (data: any) => void;
}
declare const InvoiceTitleList: FunctionComponent<Partial<InvoiceTitleListProps>>;

interface InvoiceInfo {
    name?: string;
    tel?: string;
    region?: string;
    regionIds?: Array<number>;
    address?: string;
    [key: string]: any;
}
interface InvoiceData {
    nameText?: string;
    namePlaceholder?: string;
    nameErrorMsg?: string;
    telText?: string;
    telPlaceholder?: string;
    telErrorMsg?: string;
    regionText?: string;
    regionPlaceholder?: string;
    regionErrorMsg?: string;
    addressText?: string;
    addressPlaceholder?: string;
    addressErrorMsg?: string;
    required?: Array<string>;
    showSaveBtn?: boolean;
    bottomText?: string;
    [key: string]: any;
}
interface AddressResult {
    addressSelect?: (string | number)[];
    province?: Array<RegionData>;
    city?: Array<RegionData>;
    country?: Array<RegionData>;
    town?: Array<RegionData>;
    addressTitle?: string;
    [key: string]: any;
}
interface ReceiveInvoiceEditProps extends IComponent {
    invoiceInfo: InvoiceInfo;
    data: InvoiceData;
    address: AddressResult;
    buttonProps?: Partial<ButtonProps>;
    onChange?: (val: string, tag: string) => void;
    onAddressChange?: (data: NextListObj) => void;
    onAddressClose?: (data: CloseCallBack) => void;
    onSave?: (data: InvoiceInfo) => void;
}
declare const ReceiveInvoiceEdit: FunctionComponent<Partial<ReceiveInvoiceEditProps>>;

interface ReceiveInvoiceItemExt {
    label: string;
    value: string;
    [x: string]: any;
}
interface ReceiveInvoiceItem {
    id: numericProp;
    name: string;
    tel: string;
    addres: string;
    isDefault: boolean;
    extends?: Array<ReceiveInvoiceItemExt>;
    [x: string]: any;
}
interface ReceiveInvoiceListProps extends IComponent {
    defaultValue: numericProp;
    list: Array<ReceiveInvoiceItem>;
    enableDelete: boolean;
    customEdit?: ReactNode;
    onEdit?: (item: ReceiveInvoiceItem, index: number) => void;
    onSelected?: (item: ReceiveInvoiceItem, index: number) => void;
    onDelete?: (item: ReceiveInvoiceItem, index: number) => void;
}
declare const ReceiveInvoiceList: FunctionComponent<Partial<ReceiveInvoiceListProps>>;

interface ICouponType {
    price: numericProp;
    currency: string;
    mainTitle?: string;
    subTitle?: string;
    timeRange?: string;
    label?: ReactNode;
    [key: string]: any;
}
type CouponType = "large" | "small";
type IPricePosition = "front" | "back";
interface CouponProps extends IComponent {
    type: CouponType;
    couponStyle: CSSProperties;
    couponMainStyle: CSSProperties;
    pricePosition: IPricePosition;
    couponData: ICouponType;
    btnText: string;
    isReceived: boolean;
    buttonProps: Partial<ButtonProps>;
    usedIcon: ReactNode;
    onBtnClick?: (item: any) => void;
}
declare const Coupon: FunctionComponent<Partial<CouponProps> & React.HTMLAttributes<HTMLDivElement>>;

type MaskPositionType = "left" | "right";
type MaskShadowTypeType = "triangle" | "shadow" | "transparent" | "none";
interface HorizontalScrollingProps extends IComponent {
    showMask: boolean;
    maskPosition: MaskPositionType;
    maskShadowType: MaskShadowTypeType;
    maskWidth: numericProp;
    maskDistance: numericProp;
    maskContent: ReactNode;
    iconProps: Partial<IconProps>;
    onClickMask: () => void;
    onScrollRight: () => void;
    onScrollChange: (val: number) => void;
}
declare const HorizontalScrolling: FunctionComponent<Partial<HorizontalScrollingProps> & React.HTMLAttributes<HTMLDivElement>>;

type loginType = "verify" | "pwd";
type showErrorType = "toast" | "bottomMsg";
interface LoginParamsProps {
    account?: string;
    accountPlaceholder?: string;
    accountErrorText?: string;
    telOrMail?: string | undefined;
    telOrMailPlaceholder?: string;
    telOrMailErrorText?: string;
    password?: string;
    passwordPlaceholder?: string;
    passwordErrorText?: string;
    isShowPwdInput?: boolean;
    verify?: string;
    verifyPlaceholder?: string;
    verifyButtonText?: string;
    verifyErrorText?: string;
    getCodeErrorToast?: string;
    switchLoginText1?: string;
    switchLoginText2?: string;
    forgetPwdText?: string;
    [key: string]: any;
}
interface LoginFormProps {
    account?: string;
    password?: string;
    telOrMail?: string;
    verify?: string;
    [key: string]: any;
}
interface LoginProps extends IComponent {
    logo?: string;
    title?: string;
    formParams: LoginParamsProps;
    loginType: loginType;
    loginButtonDisable?: boolean;
    loginButtonText?: string;
    hasForgetPassWord?: boolean;
    showErrorType?: showErrorType;
    toastErrorText?: string;
    hasHidePwd?: boolean;
    isGetCode?: boolean;
    countDownTime?: number | undefined;
    isHideSwitchBtn?: boolean;
    slotProtocolText?: ReactNode;
    slotInput?: ReactNode;
    slotBottom?: ReactNode;
    buttonProps?: ButtonProps;
    onInputChange?: (value: string, tag: string) => void;
    onLoginBtnClick?: (formData: LoginFormProps, totalData: LoginParamsProps) => void;
    onVerifyBtnClick?: (formData: LoginFormProps, totalData: LoginParamsProps) => void;
    onForgetBtnClick?: () => void;
    onInputClear?: (tag: string) => void;
    onLoginTypeClick?: () => void;
}
declare const Login: FunctionComponent<Partial<LoginProps>>;

export { Address, AddressEdit, AddressEditProps, AddressList, AddressListProps, AddressProps, Card, CardProps, CartBar, CartBarButton, CartBarButtonProps, CartBarIcon, CartBarIconProps, CartBarProps, Category, CategoryProps, Comment, CommentProps, ConfigProvider, ConfigProviderProps, Coupon, CouponProps, Delivery, DeliveryDate, DeliveryDateProps, DeliveryDateTime, DeliveryDateTimeAccurate, DeliveryDateTimeAccurateProps, DeliveryDateTimeProps, DeliveryProps, Ecard, EcardProps, GoodsFilter, GoodsFilterProps, HorizontalScrolling, HorizontalScrollingProps, InvoiceTitleEdit, InvoiceTitleEditProps, InvoiceTitleList, InvoiceTitleListProps, Login, LoginProps, OrderCancelPanel, OrderCancelPanelProps, OrderRemark, OrderRemarkProps, ProductFeed, ProductFeedProps, QuickEnter, QuickEnterProps, ReceiveInvoiceEdit, ReceiveInvoiceEditProps, ReceiveInvoiceList, ReceiveInvoiceListProps, SearchHistory, SearchHistoryProps, SettleBar, SettleBarProps, Sku, SkuProps };