@alifd/next

const Affix: ConfiguredComponentClass<
    AffixProps & ComponentCommonProps,
    Affix,
    {}
> & { _getAffixMode: typeof Affix._getAffixMode };

const Animate: typeof Animate & {
    Expand: typeof Expand;
    OverlayAnimate: (props: import('./types').OverlayAnimateProps) => any;
};

const Avatar: ConfiguredComponentClass<
    AvatarProps & ComponentCommonProps,
    Avatar,
    {}
>;

const Badge: ConfiguredComponentClass<BadgeProps & ComponentCommonProps, Badge, {}>;

const Balloon: ConfiguredComponentClass<
    BalloonProps & ComponentCommonProps,
    {
        readonly props: import('./types').BalloonV1Props &
            import('./types').BalloonV2Props;
        _onVisibleChange(visible: boolean, trigger: string): void;
        _onClose(e: any): void;
        _onPosition(res: {
            align?: string[] | undefined;
            config: { placement: string; points: string };
            style?: CSSCounterStyleRule | undefined;
        }): void;
        beforePosition: (
            result: {
                config: { placement: import('./types').AlignType };
                style: { left: number; top: number };
            },
            obj: { target: { width: number; height: number } }
        ) => {
            config: { placement: import('./types').AlignType };
            style: { left: number; top: number };
        };
        render(): any;
        context: any;
        setState<K extends keyof BalloonState>(
            state:
                | BalloonState
                | ((
                      prevState: Readonly<import('./types').BalloonState>,
                      props: Readonly<import('./types').BalloonProps>
                  ) => BalloonState | Pick<BalloonState, K>)
                | Pick<BalloonState, K>,
            callback?: (() => void) | undefined
        ): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        state: Readonly<import('./types').BalloonState>;
        refs: { [key: string]: any };
        componentDidMount?(): void;
        shouldComponentUpdate?(
            nextProps: Readonly<import('./types').BalloonProps>,
            nextState: Readonly<import('./types').BalloonState>,
            nextContext: any
        ): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: any): void;
        getSnapshotBeforeUpdate?(
            prevProps: Readonly<import('./types').BalloonProps>,
            prevState: Readonly<import('./types').BalloonState>
        ): any;
        componentDidUpdate?(
            prevProps: Readonly<import('./types').BalloonProps>,
            prevState: Readonly<import('./types').BalloonState>,
            snapshot?: any
        ): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(
            nextProps: Readonly<import('./types').BalloonProps>,
            nextContext: any
        ): void;
        UNSAFE_componentWillReceiveProps?(
            nextProps: Readonly<import('./types').BalloonProps>,
            nextContext: any
        ): void;
        componentWillUpdate?(
            nextProps: Readonly<import('./types').BalloonProps>,
            nextState: Readonly<import('./types').BalloonState>,
            nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
            nextProps: Readonly<import('./types').BalloonProps>,
            nextState: Readonly<import('./types').BalloonState>,
            nextContext: any
        ): void;
    },
    {}
> & {
    Tooltip: import('../config-provider/types').ConfiguredComponentClass<
        import('./types').TooltipProps &
            import('../config-provider/types').ComponentCommonProps,
        Tooltip,
        {}
    >;
    Inner: typeof Inner;
};

const Box: ConfiguredComponentClass<BoxProps & ComponentCommonProps, Box, {}>;

const Breadcrumb: ConfiguredComponentClass<
    BreadcrumbProps & ComponentCommonProps,
    Breadcrumb,
    {}
> & {
    Item: ConfiguredComponentClass<
        ItemProps & ComponentCommonProps,
        {
            render(): React.JSX.Element;
            context: any;
            setState<K extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').ItemProps>
                      ) => {} | Pick<{}, K>)
                    | Pick<{}, K>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').ItemProps> &
                Readonly<{ children?: React.ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: React.ReactInstance };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').ItemProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').ItemProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').ItemProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').ItemProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').ItemProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').ItemProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').ItemProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    > & {
        _typeMark: string;
        Separator: ({
            prefix,
            children,
        }: {
            prefix?: string | undefined;
            children: React.ReactNode;
        }) => React.JSX.Element;
    };
};

const Button: ConfiguredComponentClass<
    ButtonProps & ComponentCommonProps,
    Button,
    {}
> & {
    Group: import('../config-provider/types').ConfiguredComponentClass<
        GroupProps & import('../config-provider/types').ComponentCommonProps,
        import('./view/group').ButtonGroup,
        {}
    >;
};

const Calendar: ConfiguredComponentClass<
    CalendarProps & ComponentCommonProps,
    {
        MODES: import('./types').CalendarMode[];
        today: Moment;
        readonly props: Readonly<
            import('../util').RequiredSome<CalendarProps, keyof CalendarProps>
        > &
            Readonly<Pick<CalendarProps, never>>;
        onSelectCell: (
            date: Moment,
            nextMode:
                | import('react').MouseEvent<HTMLElement, MouseEvent>
                | import('./types').CalendarMode
        ) => void;
        changeMode: (nextMode: import('./types').CalendarMode) => void;
        changeVisibleMonth: (
            date: Moment,
            reason: import('./types').VisibleMonthChangeType
        ) => void;
        changeVisibleMonthByOffset(
            offset: number,
            type: 'months' | 'years' | 'days'
        ): void;
        goPrevDecade: () => void;
        goNextDecade: () => void;
        goPrevYear: () => void;
        goNextYear: () => void;
        goPrevMonth: () => void;
        goNextMonth: () => void;
        render(): any;
        context: any;
        setState<K extends keyof CalendarState>(
            state:
                | CalendarState
                | ((
                      prevState: Readonly<import('./types').CalendarState>,
                      props: Readonly<CalendarProps>
                  ) => CalendarState | Pick<CalendarState, K>)
                | Pick<CalendarState, K>,
            callback?: (() => void) | undefined
        ): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        state: Readonly<import('./types').CalendarState>;
        refs: { [key: string]: any };
        componentDidMount?(): void;
        shouldComponentUpdate?(
            nextProps: Readonly<CalendarProps>,
            nextState: Readonly<import('./types').CalendarState>,
            nextContext: any
        ): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: any): void;
        getSnapshotBeforeUpdate?(
            prevProps: Readonly<CalendarProps>,
            prevState: Readonly<import('./types').CalendarState>
        ): any;
        componentDidUpdate?(
            prevProps: Readonly<CalendarProps>,
            prevState: Readonly<import('./types').CalendarState>,
            snapshot?: any
        ): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(
            nextProps: Readonly<CalendarProps>,
            nextContext: any
        ): void;
        UNSAFE_componentWillReceiveProps?(
            nextProps: Readonly<CalendarProps>,
            nextContext: any
        ): void;
        componentWillUpdate?(
            nextProps: Readonly<CalendarProps>,
            nextState: Readonly<import('./types').CalendarState>,
            nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
            nextProps: Readonly<CalendarProps>,
            nextState: Readonly<import('./types').CalendarState>,
            nextContext: any
        ): void;
    },
    {}
> & {
    RangeCalendar: ConfiguredComponentClass<
        RangeCalendarProps & ComponentCommonProps,
        {
            readonly props: Readonly<
                RequiredSome<
                    RangeCalendarProps,
                    | 'onSelect'
                    | 'locale'
                    | 'prefix'
                    | 'rtl'
                    | 'format'
                    | 'mode'
                    | 'showOtherMonth'
                    | 'onVisibleMonthChange'
                    | 'dateCellRender'
                    | 'disableChangeMode'
                >
            > &
                Readonly<
                    Pick<
                        {
                            prefix: string;
                            rtl: boolean;
                            mode: string;
                            disableChangeMode: boolean;
                            format: string;
                            dateCellRender: (value: Moment) => number;
                            onSelect: () => void;
                            onVisibleMonthChange: () => void;
                            locale: Partial<{
                                today: string;
                                now: string;
                                ok: string;
                                clear: string;
                                month: string;
                                year: string;
                                prevYear: string;
                                nextYear: string;
                                prevMonth: string;
                                nextMonth: string;
                                prevDecade: string;
                                nextDecade: string;
                                yearSelectAriaLabel: string;
                                monthSelectAriaLabel: string;
                                monthBeforeYear?: boolean | undefined;
                                format?:
                                    | {
                                          months?: string[] | undefined;
                                          shortMonths?: string[] | undefined;
                                          firstDayOfWeek?: number | undefined;
                                          weekdays?: string[] | undefined;
                                          shortWeekdays?: string[] | undefined;
                                          veryShortWeekdays?: string[] | undefined;
                                      }
                                    | undefined;
                            }> & { momentLocale?: string | undefined };
                            showOtherMonth: boolean;
                        },
                        never
                    >
                >;
            today: Moment;
            onSelectCell: (
                date: Moment,
                nextMode:
                    | import('react').MouseEvent<HTMLElement, MouseEvent>
                    | import('./types').CalendarMode
            ) => void;
            changeMode: (
                mode: import('./types').CalendarMode,
                activePanel?: 'end' | 'start' | undefined
            ) => void;
            changeVisibleMonth: (
                date: Moment,
                reason: import('./types').VisibleMonthChangeType
            ) => void;
            changeVisibleMonthByOffset: (
                offset: number,
                type: 'months' | 'years' | 'days'
            ) => void;
            goPrevDecade: () => void;
            goNextDecade: () => void;
            goPrevYear: () => void;
            goNextYear: () => void;
            goPrevMonth: () => void;
            goNextMonth: () => void;
            render(): any;
            context: any;
            setState<K_1 extends keyof RangeCalendarState>(
                state:
                    | RangeCalendarState
                    | ((
                          prevState: Readonly<import('./types').RangeCalendarState>,
                          props: Readonly<import('./types').RangeCalendarProps>
                      ) => RangeCalendarState | Pick<RangeCalendarState, K_1>)
                    | Pick<RangeCalendarState, K_1>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            state: Readonly<import('./types').RangeCalendarState>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').RangeCalendarProps>,
                nextState: Readonly<import('./types').RangeCalendarState>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').RangeCalendarProps>,
                prevState: Readonly<import('./types').RangeCalendarState>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').RangeCalendarProps>,
                prevState: Readonly<import('./types').RangeCalendarState>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').RangeCalendarProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').RangeCalendarProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').RangeCalendarProps>,
                nextState: Readonly<import('./types').RangeCalendarState>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').RangeCalendarProps>,
                nextState: Readonly<import('./types').RangeCalendarState>,
                nextContext: any
            ): void;
        },
        {}
    >;
};

const Calendar2: ConfiguredComponentClass<
    CalendarProps & ComponentCommonProps,
    {
        readonly props: Readonly<
            import('../util').RequiredSome<
                import('./types').CalendarProps,
                'rtl' | 'prefix' | 'locale' | 'mode' | 'shape'
            >
        > &
            Readonly<
                Pick<
                    {
                        rtl: boolean;
                        prefix: string;
                        locale: Partial<{
                            today: string;
                            now: string;
                            ok: string;
                            clear: string;
                            month: string;
                            year: string;
                            prevYear: string;
                            nextYear: string;
                            prevMonth: string;
                            nextMonth: string;
                            prevDecade: string;
                            nextDecade: string;
                            yearSelectAriaLabel: string;
                            monthSelectAriaLabel: string;
                            monthBeforeYear?: boolean | undefined;
                            format?:
                                | {
                                      months?: string[] | undefined;
                                      shortMonths?: string[] | undefined;
                                      firstDayOfWeek?: number | undefined;
                                      weekdays?: string[] | undefined;
                                      shortWeekdays?: string[] | undefined;
                                      veryShortWeekdays?: string[] | undefined;
                                  }
                                | undefined;
                        }> & { momentLocale?: string | undefined };
                        shape: string;
                        mode: string;
                    },
                    never
                >
            >;
        switchPanelMode: (
            mode: import('./types').CalendarPanelMode
        ) => import('./types').CalendarPanelMode;
        shouldSwitchPanelMode: () => boolean;
        onDateSelect: (
            value: any,
            _: any,
            { isCurrent }: Pick<import('./types').CellData, 'isCurrent'>
        ) => void;
        onModeChange: (
            mode: import('./types').CalendarMode,
            reason?: string | undefined
        ) => void;
        onPanelValueChange: (panelValue: any, reason?: string | undefined) => void;
        onPanelModeChange: (
            panelMode: import('./types').CalendarPanelMode,
            reason?: string | undefined
        ) => void;
        onPanelChange: (
            value: any,
            mode: import('./types').CalendarPanelMode,
            reason?: string | undefined
        ) => void;
        onChange: (value: any) => void;
        render(): any;
        context: any;
        setState<K extends keyof CalendarState>(
            state:
                | CalendarState
                | ((
                      prevState: Readonly<import('./types').CalendarState>,
                      props: Readonly<import('./types').CalendarProps>
                  ) => CalendarState | Pick<CalendarState, K>)
                | Pick<CalendarState, K>,
            callback?: (() => void) | undefined
        ): void;
        forceUpdate(callback?: (() => void) | undefined): void;
        state: Readonly<import('./types').CalendarState>;
        refs: { [key: string]: any };
        componentDidMount?(): void;
        shouldComponentUpdate?(
            nextProps: Readonly<import('./types').CalendarProps>,
            nextState: Readonly<import('./types').CalendarState>,
            nextContext: any
        ): boolean;
        componentWillUnmount?(): void;
        componentDidCatch?(error: Error, errorInfo: any): void;
        getSnapshotBeforeUpdate?(
            prevProps: Readonly<import('./types').CalendarProps>,
            prevState: Readonly<import('./types').CalendarState>
        ): any;
        componentDidUpdate?(
            prevProps: Readonly<import('./types').CalendarProps>,
            prevState: Readonly<import('./types').CalendarState>,
            snapshot?: any
        ): void;
        componentWillMount?(): void;
        UNSAFE_componentWillMount?(): void;
        componentWillReceiveProps?(
            nextProps: Readonly<import('./types').CalendarProps>,
            nextContext: any
        ): void;
        UNSAFE_componentWillReceiveProps?(
            nextProps: Readonly<import('./types').CalendarProps>,
            nextContext: any
        ): void;
        componentWillUpdate?(
            nextProps: Readonly<import('./types').CalendarProps>,
            nextState: Readonly<import('./types').CalendarState>,
            nextContext: any
        ): void;
        UNSAFE_componentWillUpdate?(
            nextProps: Readonly<import('./types').CalendarProps>,
            nextState: Readonly<import('./types').CalendarState>,
            nextContext: any
        ): void;
    },
    {}
>;

const Card: ConfiguredComponentClass<CardProps & ComponentCommonProps, Card, {}> & {
    Divider: ConfiguredComponentClass<
        CardDividerProps & ComponentCommonProps,
        {
            render(): any;
            context: any;
            setState<K extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').CardDividerProps>
                      ) => {} | Pick<{}, K>)
                    | Pick<{}, K>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardDividerProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardDividerProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardDividerProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').CardDividerProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardDividerProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardDividerProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardDividerProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardDividerProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    >;
    Header: ConfiguredComponentClass<
        CardHeaderProps & ComponentCommonProps,
        {
            render(): any;
            context: any;
            setState<K_1 extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').CardHeaderProps>
                      ) => {} | Pick<{}, K_1>)
                    | Pick<{}, K_1>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardHeaderProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardHeaderProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardHeaderProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').CardHeaderProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardHeaderProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardHeaderProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardHeaderProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardHeaderProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    >;
    Media: ConfiguredComponentClass<
        CardMediaProps & ComponentCommonProps,
        {
            render(): any;
            context: any;
            setState<K_2 extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').CardMediaProps>
                      ) => {} | Pick<{}, K_2>)
                    | Pick<{}, K_2>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardMediaProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardMediaProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardMediaProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').CardMediaProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardMediaProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardMediaProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardMediaProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardMediaProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    >;
    Content: ConfiguredComponentClass<
        CardContentProps & ComponentCommonProps,
        {
            render(): any;
            context: any;
            setState<K_3 extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').CardContentProps>
                      ) => {} | Pick<{}, K_3>)
                    | Pick<{}, K_3>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardContentProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardContentProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardContentProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').CardContentProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardContentProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardContentProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardContentProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardContentProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    >;
    Actions: ConfiguredComponentClass<
        CardActionsProps & ComponentCommonProps,
        {
            render(): any;
            context: any;
            setState<K_4 extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').CardActionsProps>
                      ) => {} | Pick<{}, K_4>)
                    | Pick<{}, K_4>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardActionsProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardActionsProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardActionsProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').CardActionsProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardActionsProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardActionsProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardActionsProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardActionsProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    >;
    BulletHeader: ConfiguredComponentClass<
        CardBulletHeaderProps & ComponentCommonProps,
        {
            render(): import('react').JSX.Element | null;
            context: any;
            setState<K_5 extends never>(
                state:
                    | {}
                    | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('./types').CardBulletHeaderProps>
                      ) => {} | Pick<{}, K_5>)
                    | Pick<{}, K_5>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardBulletHeaderProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<{}>;
            refs: { [key: string]: any };
            componentDidMount?(): void;
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardBulletHeaderProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardBulletHeaderProps>,
                prevState: Readonly<{}>
            ): any;
            componentDidUpdate?(
                prevProps: Readonly<import('./types').CardBulletHeaderProps>,
                prevState: Readonly<{}>,
                snapshot?: any
            ): void;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardBulletHeaderProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardBulletHeaderProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardBulletHeaderProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardBulletHeaderProps>,
                nextState: Readonly<{}>,
                nextContext: any
            ): void;
        },
        {}
    >;
    CollaspeContent: ConfiguredComponentClass<
        CardCollapseContentProps & ComponentCommonProps,
        {
            content: HTMLDivElement;
            footer: HTMLDivElement;
            componentDidMount(): void;
            componentDidUpdate(): void;
            handleToggle: () => void;
            _setNeedMore(): void;
            _setContentHeight(): void;
            _getNodeChildrenHeight(node?: HTMLDivElement | undefined): number;
            _contentRefHandler: (ref: HTMLDivElement) => void;
            saveFooter: (ref: HTMLDivElement) => void;
            render(): any;
            context: any;
            setState<K_6 extends keyof CardCollapseContentState>(
                state:
                    | CardCollapseContentState
                    | ((
                          prevState: Readonly<
                              import('./collapse-content').CardCollapseContentState
                          >,
                          props: Readonly<import('./types').CardCollapseContentProps>
                      ) =>
                          | CardCollapseContentState
                          | Pick<CardCollapseContentState, K_6>)
                    | Pick<CardCollapseContentState, K_6>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardCollapseContentProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<import('./collapse-content').CardCollapseContentState>;
            refs: { [key: string]: any };
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardCollapseContentProps>,
                prevState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >
            ): any;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >,
                nextContext: any
            ): void;
        },
        {}
    >;
    CollapseContent: ConfiguredComponentClass<
        CardCollapseContentProps & ComponentCommonProps,
        {
            content: HTMLDivElement;
            footer: HTMLDivElement;
            componentDidMount(): void;
            componentDidUpdate(): void;
            handleToggle: () => void;
            _setNeedMore(): void;
            _setContentHeight(): void;
            _getNodeChildrenHeight(node?: HTMLDivElement | undefined): number;
            _contentRefHandler: (ref: HTMLDivElement) => void;
            saveFooter: (ref: HTMLDivElement) => void;
            render(): any;
            context: any;
            setState<K_6 extends keyof CardCollapseContentState>(
                state:
                    | CardCollapseContentState
                    | ((
                          prevState: Readonly<
                              import('./collapse-content').CardCollapseContentState
                          >,
                          props: Readonly<import('./types').CardCollapseContentProps>
                      ) =>
                          | CardCollapseContentState
                          | Pick<CardCollapseContentState, K_6>)
                    | Pick<CardCollapseContentState, K_6>,
                callback?: (() => void) | undefined
            ): void;
            forceUpdate(callback?: (() => void) | undefined): void;
            readonly props: Readonly<import('./types').CardCollapseContentProps> &
                Readonly<{ children?: import('react').ReactNode }>;
            state: Readonly<import('./collapse-content').CardCollapseContentState>;
            refs: { [key: string]: any };
            shouldComponentUpdate?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >,
                nextContext: any
            ): boolean;
            componentWillUnmount?(): void;
            componentDidCatch?(error: Error, errorInfo: any): void;
            getSnapshotBeforeUpdate?(
                prevProps: Readonly<import('./types').CardCollapseContentProps>,
                prevState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >
            ): any;
            componentWillMount?(): void;
            UNSAFE_componentWillMount?(): void;
            componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextContext: any
            ): void;
            UNSAFE_componentWillReceiveProps?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextContext: any
            ): void;
            componentWillUpdate?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >,
                nextContext: any
            ): void;
            UNSAFE_componentWillUpdate?(
                nextProps: Readonly<import('./types').CardCollapseContentProps>,
                nextState: Readonly<
                    import('./collapse-content').CardCollapseContentState
                >,
                nextContext: any
            ): void;
        },
        {}
    >;
};