@alifd/next

  • Version 1.27.32
  • Published
  • 38.4 MB
  • 16 dependencies
  • MIT license

Install

npm i @alifd/next
yarn add @alifd/next
pnpm add @alifd/next

Overview

A configurable component library for web built on React.

Index

Variables

variable Affix

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

    variable Animate

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

      variable Avatar

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

        variable Badge

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

          variable Balloon

          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;
          };

            variable Box

            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;
              };
              };

                variable Button

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

                  variable Calendar

                  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;
                  },
                  {}
                  >;
                  };

                    variable Calendar2

                    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;
                    },
                    {}
                    >;

                      variable Card

                      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;
                      },
                      {}
                      >;
                      };

                        variable Cascader

                        const Cascader: ConfiguredComponentClass<
                        CascaderProps & ComponentCommonProps,
                        {
                        lastExpandedValue: string[];
                        cascader: HTMLDivElement;
                        cascaderInner: HTMLDivElement;
                        indeterminate: string[];
                        componentDidMount(): void;
                        componentDidUpdate(): void;
                        getCascaderNode(ref: HTMLDivElement): void;
                        getCascaderInnerNode(ref: HTMLDivElement): void;
                        setCascaderInnerWidth(): void;
                        flatValue(value: string[]): string[];
                        getValue(pos: string): string | null;
                        getPos(value: string): string | null;
                        getData(value: string[]): import('./types').CascaderDataItemWithPosInfo[];
                        processValue(value: string[], v: string, checked: boolean): void;
                        handleSelect(v: string, canExpand: boolean): void;
                        handleCheck(v: string, checked: boolean): void;
                        handleExpand(
                        value: string,
                        level: number,
                        canExpand: boolean,
                        focusedFirstChild: boolean
                        ): void | Promise<void>;
                        handleMouseLeave(): void;
                        setExpandValue(
                        expandedValue: string[],
                        isExpandedValueSetByAction?: boolean
                        ): void;
                        getFirstFocusKeyByDataSource(
                        dataSource: import('./types').CascaderDataItem[]
                        ): string;
                        getFirstFocusKeyByFilteredPaths(
                        filteredPaths:
                        | import('./types').CascaderDataItemWithPosInfo[][]
                        | undefined
                        ): string;
                        getFirstFocusKey(): string;
                        setFocusValue(): void;
                        handleFocus(focusedValue: string): void;
                        handleFold(): void;
                        getIndeterminate(value: string[]): string[];
                        onBlur(e: any): void;
                        renderMenu(
                        data: import('./types').CascaderDataItem[] | undefined,
                        level: number
                        ): any;
                        renderMenus(): import('react').JSX.Element[];
                        renderFilteredItem(
                        path: import('./types').CascaderDataItemWithPosInfo[]
                        ): any;
                        renderFilteredList(): any;
                        render(): any;
                        context: any;
                        setState<K extends keyof CascaderState>(
                        state:
                        | CascaderState
                        | ((
                        prevState: Readonly<import('./types').CascaderState>,
                        props: Readonly<import('./types').CascaderProps>
                        ) => CascaderState | Pick<CascaderState, K>)
                        | Pick<CascaderState, K>,
                        callback?: (() => void) | undefined
                        ): void;
                        forceUpdate(callback?: (() => void) | undefined): void;
                        readonly props: Readonly<import('./types').CascaderProps> &
                        Readonly<{ children?: import('react').ReactNode }>;
                        state: Readonly<import('./types').CascaderState>;
                        refs: { [key: string]: any };
                        shouldComponentUpdate?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextState: Readonly<import('./types').CascaderState>,
                        nextContext: any
                        ): boolean;
                        componentWillUnmount?(): void;
                        componentDidCatch?(error: Error, errorInfo: any): void;
                        getSnapshotBeforeUpdate?(
                        prevProps: Readonly<import('./types').CascaderProps>,
                        prevState: Readonly<import('./types').CascaderState>
                        ): any;
                        componentWillMount?(): void;
                        UNSAFE_componentWillMount?(): void;
                        componentWillReceiveProps?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillReceiveProps?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextContext: any
                        ): void;
                        componentWillUpdate?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextState: Readonly<import('./types').CascaderState>,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillUpdate?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextState: Readonly<import('./types').CascaderState>,
                        nextContext: any
                        ): void;
                        },
                        Pick<
                        {
                        lastExpandedValue: string[];
                        cascader: HTMLDivElement;
                        cascaderInner: HTMLDivElement;
                        indeterminate: string[];
                        componentDidMount(): void;
                        componentDidUpdate(): void;
                        getCascaderNode(ref: HTMLDivElement): void;
                        getCascaderInnerNode(ref: HTMLDivElement): void;
                        setCascaderInnerWidth(): void;
                        flatValue(value: string[]): string[];
                        getValue(pos: string): string | null;
                        getPos(value: string): string | null;
                        getData(
                        value: string[]
                        ): import('./types').CascaderDataItemWithPosInfo[];
                        processValue(value: string[], v: string, checked: boolean): void;
                        handleSelect(v: string, canExpand: boolean): void;
                        handleCheck(v: string, checked: boolean): void;
                        handleExpand(
                        value: string,
                        level: number,
                        canExpand: boolean,
                        focusedFirstChild: boolean
                        ): void | Promise<void>;
                        handleMouseLeave(): void;
                        setExpandValue(
                        expandedValue: string[],
                        isExpandedValueSetByAction?: boolean
                        ): void;
                        getFirstFocusKeyByDataSource(
                        dataSource: import('./types').CascaderDataItem[]
                        ): string;
                        getFirstFocusKeyByFilteredPaths(
                        filteredPaths:
                        | import('./types').CascaderDataItemWithPosInfo[][]
                        | undefined
                        ): string;
                        getFirstFocusKey(): string;
                        setFocusValue(): void;
                        handleFocus(focusedValue: string): void;
                        handleFold(): void;
                        getIndeterminate(value: string[]): string[];
                        onBlur(e: any): void;
                        renderMenu(
                        data: import('./types').CascaderDataItem[] | undefined,
                        level: number
                        ): any;
                        renderMenus(): import('react').JSX.Element[];
                        renderFilteredItem(
                        path: import('./types').CascaderDataItemWithPosInfo[]
                        ): any;
                        renderFilteredList(): any;
                        render(): any;
                        context: any;
                        setState<K extends keyof CascaderState>(
                        state:
                        | CascaderState
                        | ((
                        prevState: Readonly<import('./types').CascaderState>,
                        props: Readonly<import('./types').CascaderProps>
                        ) => CascaderState | Pick<CascaderState, K>)
                        | Pick<CascaderState, K>,
                        callback?: (() => void) | undefined
                        ): void;
                        forceUpdate(callback?: (() => void) | undefined): void;
                        readonly props: Readonly<import('./types').CascaderProps> &
                        Readonly<{ children?: import('react').ReactNode }>;
                        state: Readonly<import('./types').CascaderState>;
                        refs: { [key: string]: any };
                        shouldComponentUpdate?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextState: Readonly<import('./types').CascaderState>,
                        nextContext: any
                        ): boolean;
                        componentWillUnmount?(): void;
                        componentDidCatch?(error: Error, errorInfo: any): void;
                        getSnapshotBeforeUpdate?(
                        prevProps: Readonly<import('./types').CascaderProps>,
                        prevState: Readonly<import('./types').CascaderState>
                        ): any;
                        componentWillMount?(): void;
                        UNSAFE_componentWillMount?(): void;
                        componentWillReceiveProps?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillReceiveProps?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextContext: any
                        ): void;
                        componentWillUpdate?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextState: Readonly<import('./types').CascaderState>,
                        nextContext: any
                        ): void;
                        UNSAFE_componentWillUpdate?(
                        nextProps: Readonly<import('./types').CascaderProps>,
                        nextState: Readonly<import('./types').CascaderState>,
                        nextContext: any
                        ): void;
                        },
                        'setFocusValue'
                        >
                        >;

                          variable CascaderSelect

                          const CascaderSelect: ConfiguredComponentClass<
                          CascaderSelectProps & ComponentCommonProps,
                          {
                          readonly props: import('./cascader-select').CascaderSelectPropsWithDefault;
                          _valueDataCache: Record<string, import('./types').CascaderSelectDataItem>;
                          _v2n: Record<string, import('./types').CascaderSelectDataItem>;
                          _p2n: Record<string, import('./types').CascaderSelectDataItem>;
                          select: ConfiguredComponent<
                          SelectProps & ComponentCommonProps,
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(proxy: unknown, e: any): false | undefined;
                          handleTagClose(item: import('../select').ObjectItem): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<import('../select').SelectProps>
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<import('../select/select').SelectState>
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(proxy: unknown, e: any): false | undefined;
                          handleTagClose(item: import('../select').ObjectItem): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<import('../select').SelectProps>
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<import('../select/select').SelectState>
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          },
                          'focusInput' | 'handleSearchClear'
                          >;
                          cascader: ConfiguredComponent<
                          CascaderProps & ComponentCommonProps,
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(value: string[], v: string, checked: boolean): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data: import('../cascader').CascaderDataItem[] | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<import('../cascader').CascaderProps>
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../cascader').CascaderProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<import('../cascader/types').CascaderState>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<import('../cascader/types').CascaderState>
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<import('../cascader/types').CascaderState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<import('../cascader/types').CascaderState>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(value: string[], v: string, checked: boolean): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data: import('../cascader').CascaderDataItem[] | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../cascader').CascaderProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'setFocusValue'
                          >;
                          popup: ConfiguredComponent<
                          PopupProps & ComponentCommonProps,
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').GatewayProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').GatewayProps>,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(node: Element | Text, e: Event): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').GatewayProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').GatewayProps>,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').GatewayProps>,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<import('../overlay/types').OverlayState>,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<import('../overlay/types').OverlayState>
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<import('../overlay/types').OverlayState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<import('../overlay/types').OverlayState>,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(node: Element | Text, e: Event): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(type: string | object, e: MouseEvent): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<import('../overlay').PopupProps>
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<import('../overlay/types').PopupState>,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<import('../overlay/types').PopupState>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<import('../overlay/types').PopupState>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<import('../overlay/types').PopupState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<import('../overlay/types').PopupState>,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('../overlay').PopupProps>
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(node: Element | Text, e: Event): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('../overlay').PopupProps>
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          },
                          'overlay'
                          >;
                          cascaderHeight: string | number;
                          focus(): void;
                          updateCache(dataSource: import('../cascader').CascaderDataItem[]): void;
                          flatValue(value: string[]): string[];
                          isDescendantOrSelf(
                          currentPos: string | null | undefined,
                          targetPos: string | null | undefined
                          ): boolean;
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(value: string[]): import('./types').CascaderSelectDataItem[];
                          getLabelPath(
                          data: import('./types').CascaderSelectDataItem
                          ): import('react').ReactNode[];
                          getSingleData(
                          value: string | string[]
                          ): import('./types').CascaderSelectDataItem | null;
                          getMultipleData(
                          value: string[]
                          ): import('./types').CascaderSelectDataItem[] | null;
                          getIndeterminate(value: string[]): string[];
                          saveSelectRef(
                          ref: ConfiguredComponent<
                          SelectProps & ComponentCommonProps,
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(proxy: unknown, e: any): false | undefined;
                          handleTagClose(item: import('../select').ObjectItem): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<import('../select').SelectProps>
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<import('../select/select').SelectState>
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(
                          proxy: unknown,
                          e: any
                          ): false | undefined;
                          handleTagClose(
                          item: import('../select').ObjectItem
                          ): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<
                          import('../select').SelectProps
                          >
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'focusInput' | 'handleSearchClear'
                          >
                          ): void;
                          saveCascaderRef(
                          ref: ConfiguredComponent<
                          CascaderProps & ComponentCommonProps,
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(value: string[], v: string, checked: boolean): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data: import('../cascader').CascaderDataItem[] | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../cascader').CascaderProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(
                          value: string[],
                          v: string,
                          checked: boolean
                          ): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data:
                          | import('../cascader').CascaderDataItem[]
                          | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../cascader').CascaderProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'setFocusValue'
                          >
                          ): void;
                          completeValue(value: string[]): string[];
                          isLeaf(data: import('./types').CascaderSelectDataItem): boolean;
                          handleVisibleChange(
                          visible: boolean,
                          type?: import('./types').CascaderSelectVisibleChangeType | undefined
                          ): void;
                          handleKeyDown(e: any): void;
                          getPopup(
                          ref: ConfiguredComponent<
                          PopupProps & ComponentCommonProps,
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(node: Element | Text, e: Event): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('../overlay').PopupProps>
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) =>
                          | OverlayState
                          | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').OverlayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          | string
                          | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').PopupProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          },
                          'overlay'
                          >
                          ): void;
                          handleAfterOpen(): void;
                          handleSelect(
                          value: unknown,
                          data: import('./types').CascaderSelectDataItem
                          ): void;
                          refreshValueDataCache: (curValue: string | string[]) => void;
                          handleChange(
                          value: string[],
                          data: import('./types').CascaderSelectDataItem[],
                          extra: import('../cascader').Extra
                          ): void;
                          handleClear(): void;
                          handleRemove(currentData: import('./types').CascaderSelectDataItem): void;
                          handleSearch(searchValue: string): void;
                          getPath(pos: string): import('./types').CascaderSelectDataItem[];
                          filterItems(): import('./types').CascaderSelectDataItem[][];
                          renderNotFound(): any;
                          renderCascader(): any;
                          renderPopupContent(): any;
                          renderPreview(others: any): any;
                          render(): any;
                          context: any;
                          setState<K_6 extends keyof CascaderSelectState>(
                          state:
                          | CascaderSelectState
                          | ((
                          prevState: Readonly<import('./types').CascaderSelectState>,
                          props: Readonly<import('./types').CascaderSelectProps>
                          ) => CascaderSelectState | Pick<CascaderSelectState, K_6>)
                          | Pick<CascaderSelectState, K_6>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          state: Readonly<import('./types').CascaderSelectState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextState: Readonly<import('./types').CascaderSelectState>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('./types').CascaderSelectProps>,
                          prevState: Readonly<import('./types').CascaderSelectState>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('./types').CascaderSelectProps>,
                          prevState: Readonly<import('./types').CascaderSelectState>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextState: Readonly<import('./types').CascaderSelectState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextState: Readonly<import('./types').CascaderSelectState>,
                          nextContext: any
                          ): void;
                          },
                          Pick<
                          {
                          readonly props: import('./cascader-select').CascaderSelectPropsWithDefault;
                          _valueDataCache: Record<
                          string,
                          import('./types').CascaderSelectDataItem
                          >;
                          _v2n: Record<string, import('./types').CascaderSelectDataItem>;
                          _p2n: Record<string, import('./types').CascaderSelectDataItem>;
                          select: ConfiguredComponent<
                          SelectProps & ComponentCommonProps,
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(proxy: unknown, e: any): false | undefined;
                          handleTagClose(item: import('../select').ObjectItem): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<import('../select').SelectProps>
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<import('../select/select').SelectState>
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<import('../select/select').SelectState>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(
                          proxy: unknown,
                          e: any
                          ): false | undefined;
                          handleTagClose(
                          item: import('../select').ObjectItem
                          ): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<
                          import('../select').SelectProps
                          >
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'focusInput' | 'handleSearchClear'
                          >;
                          cascader: ConfiguredComponent<
                          CascaderProps & ComponentCommonProps,
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(value: string[], v: string, checked: boolean): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data: import('../cascader').CascaderDataItem[] | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../cascader').CascaderProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(
                          value: string[],
                          v: string,
                          checked: boolean
                          ): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data:
                          | import('../cascader').CascaderDataItem[]
                          | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../cascader').CascaderProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'setFocusValue'
                          >;
                          popup: ConfiguredComponent<
                          PopupProps & ComponentCommonProps,
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(node: Element | Text, e: Event): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) => GatewayState | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').GatewayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<import('../overlay').PopupProps>
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) =>
                          | OverlayState
                          | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').OverlayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          | string
                          | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').PopupProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          },
                          'overlay'
                          >;
                          cascaderHeight: string | number;
                          focus(): void;
                          updateCache(dataSource: import('../cascader').CascaderDataItem[]): void;
                          flatValue(value: string[]): string[];
                          isDescendantOrSelf(
                          currentPos: string | null | undefined,
                          targetPos: string | null | undefined
                          ): boolean;
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(value: string[]): import('./types').CascaderSelectDataItem[];
                          getLabelPath(
                          data: import('./types').CascaderSelectDataItem
                          ): import('react').ReactNode[];
                          getSingleData(
                          value: string | string[]
                          ): import('./types').CascaderSelectDataItem | null;
                          getMultipleData(
                          value: string[]
                          ): import('./types').CascaderSelectDataItem[] | null;
                          getIndeterminate(value: string[]): string[];
                          saveSelectRef(
                          ref: ConfiguredComponent<
                          SelectProps & ComponentCommonProps,
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys: import('../select').DataSourceItem[] | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(triggerType?: string | undefined): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(
                          proxy: unknown,
                          e: any
                          ): false | undefined;
                          handleTagClose(
                          item: import('../select').ObjectItem
                          ): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (string | number | boolean | null | undefined)[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?: import('../select').VisibleChangeType | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<
                          import('../select').SelectProps
                          >
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../select').SelectProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          selectAllYet: boolean;
                          componentDidUpdate(
                          prevProps: import('../select').SelectProps,
                          prevState: import('../select/base').BaseState
                          ): void;
                          componentDidMount(): void;
                          ie9Hack(): void;
                          useDetailValue(): boolean;
                          hasSearch(): boolean;
                          getTagSize(): 'small' | 'medium' | 'large' | undefined;
                          handleMenuSelect(
                          keys: string[],
                          item: { props: { _key: string } }
                          ): false | void;
                          handleItemClick(key: string): void;
                          handleSingleSelect(
                          key: string,
                          triggerType: import('../select').VisibleChangeType
                          ): void;
                          handleMultipleSelect(
                          keys:
                          | import('../select').DataSourceItem[]
                          | undefined,
                          triggerType: import('../select').VisibleChangeType,
                          key?: string | null | undefined,
                          keepSearchValue?: boolean | undefined
                          ): void;
                          updateSelectAllYet(value?: unknown): void;
                          handleSearchValue(value: string): void;
                          handleSearch(value: string, e: any): void;
                          handleSearchClear(
                          triggerType?: string | undefined
                          ): void;
                          handleSearchKeyDown(e: any): void;
                          chooseMultipleItem(key: string): void;
                          chooseHighlightItem(
                          proxy: unknown,
                          e: any
                          ): false | undefined;
                          handleTagClose(
                          item: import('../select').ObjectItem
                          ): boolean;
                          handleDeleteTag(e: any): false | undefined;
                          handleSelectAll(e: any): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: import('../select').VisibleChangeType
                          ): void;
                          afterClose(): void;
                          maxTagPlaceholder(
                          selectedValues: import('../select').ObjectItem[],
                          totalValues: import('../select').ObjectItem[]
                          ): string;
                          renderValues(): any;
                          handleWrapClick: (e: any) => void;
                          handleArrowClick: (e: any) => void;
                          handleClear: (e: any) => void;
                          hasClear(): boolean | undefined;
                          renderExtraNode(): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          renderSelect(): any;
                          renderSearchInput(
                          valueNodes: any,
                          placeholder: string | undefined,
                          inputEl: any
                          ): any;
                          renderMenuHeader(): any;
                          render(): any;
                          dataStore: import('../select/data-store').default;
                          selectDOM: HTMLElement;
                          width: string | number;
                          popupRef: HTMLDivElement;
                          resizeTimeout: number;
                          highlightTimer: number | undefined;
                          menuRef:
                          | import('../config-provider/types').ConfiguredComponent<
                          import('../menu').MenuProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../menu/view/menu').Menu
                          >
                          | null;
                          isAutoComplete: boolean;
                          inputRef: import('../input/input').default<
                          import('../input').InputProps
                          >;
                          valueDataSource: {
                          value?:
                          | string
                          | number
                          | boolean
                          | (
                          | string
                          | number
                          | boolean
                          | null
                          | undefined
                          )[]
                          | null
                          | undefined;
                          valueDS?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined;
                          mapValueDS?:
                          | Record<string, import('../select').ObjectItem>
                          | undefined;
                          };
                          componentWillUnmount(): void;
                          syncWidth(): void;
                          handleResize(): void;
                          setDataSource(
                          props: import('../select').SelectProps
                          ): import('../select/types').NormalizedObjectItem[];
                          setVisible(
                          visible: boolean,
                          type?:
                          | import('../select').VisibleChangeType
                          | undefined
                          ): void;
                          setFirstHightLightKeyForMenu(
                          searchValue?: unknown
                          ): void;
                          handleChange(
                          value:
                          | import('../select').DataSourceItem
                          | import('../select').DataSourceItem[],
                          args_0: unknown,
                          args_1?:
                          | import('../select').ObjectItem
                          | import('../select').ObjectItem[]
                          | undefined
                          ): void;
                          handleMenuBodyClick(): void;
                          toggleHighlightItem(
                          dir: number
                          ):
                          | false
                          | import('../select/types').NormalizedObjectItem
                          | undefined;
                          scrollMenuIntoView(): void;
                          handleSelect(): void;
                          handleMouseDown: (e: any) => void;
                          renderMenu(): any;
                          renderMenuItem(
                          dataSource: import('../select/types').NormalizedObjectItem[]
                          ): import('react').ReactElement<
                          any,
                          string | import('react').JSXElementConstructor<any>
                          >[];
                          saveSelectRef: (ref: HTMLElement | null) => void;
                          saveInputRef: (
                          ref: import('../config-provider/types').ConfiguredComponent<
                          import('../input').InputProps &
                          import('../config-provider/types').ComponentCommonProps,
                          import('../input/input').default<
                          import('../input').InputProps
                          >
                          > &
                          Pick<
                          import('../input/input').default<
                          import('../input').InputProps
                          >,
                          'focus' | 'getInputNode'
                          >
                          ) => void;
                          focusInput(): void;
                          focus(
                          start?: number | undefined,
                          end?: number | undefined,
                          preventScroll?: boolean
                          ): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          savePopupRef: (ref: HTMLDivElement) => void;
                          shouldAutoWidth(): boolean | undefined;
                          context: any;
                          setState<K extends keyof SelectState>(
                          state:
                          | SelectState
                          | ((
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >,
                          props: Readonly<
                          import('../select').SelectProps
                          >
                          ) => SelectState | Pick<SelectState, K>)
                          | Pick<SelectState, K>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../select').SelectProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../select/select').SelectState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../select').SelectProps>,
                          prevState: Readonly<
                          import('../select/select').SelectState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../select').SelectProps>,
                          nextState: Readonly<
                          import('../select/select').SelectState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'focusInput' | 'handleSearchClear'
                          >
                          ): void;
                          saveCascaderRef(
                          ref: ConfiguredComponent<
                          CascaderProps & ComponentCommonProps,
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(
                          value: string[],
                          v: string,
                          checked: boolean
                          ): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data:
                          | import('../cascader').CascaderDataItem[]
                          | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../cascader').CascaderProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../cascader/types').CascaderState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../cascader').CascaderProps>,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../cascader').CascaderProps>,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          lastExpandedValue: string[];
                          cascader: HTMLDivElement;
                          cascaderInner: HTMLDivElement;
                          indeterminate: string[];
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          getCascaderNode(ref: HTMLDivElement): void;
                          getCascaderInnerNode(ref: HTMLDivElement): void;
                          setCascaderInnerWidth(): void;
                          flatValue(value: string[]): string[];
                          getValue(pos: string): string | null;
                          getPos(value: string): string | null;
                          getData(
                          value: string[]
                          ): import('../cascader').CascaderDataItemWithPosInfo[];
                          processValue(
                          value: string[],
                          v: string,
                          checked: boolean
                          ): void;
                          handleSelect(v: string, canExpand: boolean): void;
                          handleCheck(v: string, checked: boolean): void;
                          handleExpand(
                          value: string,
                          level: number,
                          canExpand: boolean,
                          focusedFirstChild: boolean
                          ): void | Promise<void>;
                          handleMouseLeave(): void;
                          setExpandValue(
                          expandedValue: string[],
                          isExpandedValueSetByAction?: boolean
                          ): void;
                          getFirstFocusKeyByDataSource(
                          dataSource: import('../cascader').CascaderDataItem[]
                          ): string;
                          getFirstFocusKeyByFilteredPaths(
                          filteredPaths:
                          | import('../cascader').CascaderDataItemWithPosInfo[][]
                          | undefined
                          ): string;
                          getFirstFocusKey(): string;
                          setFocusValue(): void;
                          handleFocus(focusedValue: string): void;
                          handleFold(): void;
                          getIndeterminate(value: string[]): string[];
                          onBlur(e: any): void;
                          renderMenu(
                          data:
                          | import('../cascader').CascaderDataItem[]
                          | undefined,
                          level: number
                          ): any;
                          renderMenus(): import('react').JSX.Element[];
                          renderFilteredItem(
                          path: import('../cascader').CascaderDataItemWithPosInfo[]
                          ): any;
                          renderFilteredList(): any;
                          render(): any;
                          context: any;
                          setState<K_1 extends keyof CascaderState>(
                          state:
                          | CascaderState
                          | ((
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          props: Readonly<
                          import('../cascader').CascaderProps
                          >
                          ) => CascaderState | Pick<CascaderState, K_1>)
                          | Pick<CascaderState, K_1>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../cascader').CascaderProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<
                          import('../cascader/types').CascaderState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../cascader').CascaderProps
                          >,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../cascader').CascaderProps
                          >,
                          prevState: Readonly<
                          import('../cascader/types').CascaderState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../cascader').CascaderProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../cascader').CascaderProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../cascader').CascaderProps
                          >,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../cascader').CascaderProps
                          >,
                          nextState: Readonly<
                          import('../cascader/types').CascaderState
                          >,
                          nextContext: any
                          ): void;
                          },
                          'setFocusValue'
                          >
                          ): void;
                          completeValue(value: string[]): string[];
                          isLeaf(data: import('./types').CascaderSelectDataItem): boolean;
                          handleVisibleChange(
                          visible: boolean,
                          type?: import('./types').CascaderSelectVisibleChangeType | undefined
                          ): void;
                          handleKeyDown(e: any): void;
                          getPopup(
                          ref: ConfiguredComponent<
                          PopupProps & ComponentCommonProps,
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) => OverlayState | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').OverlayState>;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) =>
                          | OverlayState
                          | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').OverlayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(e: KeyboardEvent | MouseEvent): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          | string
                          | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (import('react').JSX.Element | undefined)[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').PopupProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<import('../overlay/types').PopupState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<import('../overlay').PopupProps> &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          }
                          > &
                          Pick<
                          {
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align: string | boolean | string[] | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: { align: string[] }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ): (Document | Window | HTMLElement)[] | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) =>
                          | OverlayState
                          | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').OverlayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          saveRef(ref: {
                          _mouseNotFirstOnMask: boolean;
                          _isForwardContent: boolean | null;
                          overlay: {
                          lastAlign: string | boolean | undefined;
                          timeoutMap: { [key: string]: number };
                          _isMounted: boolean;
                          _isDestroyed: boolean;
                          focusTimeout: number;
                          _animation: { off: () => void } | null;
                          _containerNode: HTMLElement | undefined;
                          _hasFocused: boolean;
                          contentRef: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          gatewayRef: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _keydownEvents: { off: () => void } | null;
                          _clickEvents: { off: () => void } | null;
                          _touchEvents: { off: () => void } | null;
                          overlay: any | null;
                          componentDidMount(): void;
                          componentDidUpdate(
                          prevProps: import('../overlay/types').OverlayV1Props
                          ): void;
                          componentWillUnmount(): void;
                          doAnimation(open: boolean, close: boolean): void;
                          getAnimation(
                          props: import('../overlay/types').OverlayV1Props
                          ):
                          | string
                          | boolean
                          | import('../overlay/types').AnimationObjectType;
                          getAnimationByAlign(
                          align:
                          | string
                          | boolean
                          | string[]
                          | undefined
                          ): { in: string; out: string };
                          addAnimationEvents(): void;
                          handlePosition(config: {
                          align: string[];
                          }): void;
                          handleAnimateEnd(id: string): void;
                          onEntering(): void;
                          onLeaving(): void;
                          onEntered(): void;
                          onLeaved(): void;
                          beforeOpen(): void;
                          beforeClose(): void;
                          setFocusNode(): void;
                          getContent(): import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          };
                          getContentNode(): HTMLElement | null;
                          getWrapperNode(): Element | null;
                          addDocumentEvents(): void;
                          removeDocumentEvents(): void;
                          handleDocumentKeyDown(e: KeyboardEvent): void;
                          isInShadowDOM(node: Element | Text): boolean;
                          getEventPath(
                          event: Event | { path: string }
                          ): string | EventTarget[] | undefined;
                          composedPath(
                          el: HTMLElement | null
                          ):
                          | (Document | Window | HTMLElement)[]
                          | undefined;
                          matchInShadowDOM(
                          node: Element | Text,
                          e: Event
                          ): boolean;
                          handleDocumentClick(e: Event): void;
                          handleMaskClick(e: any): void;
                          saveContentRef: (
                          ref: import('react').ReactInstance & {
                          headerNode: HTMLElement;
                          bodyNode: HTMLElement;
                          footerNode: HTMLDivElement;
                          }
                          ) => void;
                          saveGatewayRef: (ref: {
                          child: Element | null | undefined;
                          componentDidMount(): void;
                          componentDidUpdate(): void;
                          updateContainer: () => void;
                          getChildNode(): Element | Text | null;
                          saveChildRef: (ref: HTMLDivElement) => void;
                          render(): import('react').ReactPortal | null;
                          context: any;
                          setState<K_2 extends 'containerNode'>(
                          state:
                          | GatewayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          props: Readonly<
                          import('../overlay').GatewayProps
                          >
                          ) =>
                          | GatewayState
                          | Pick<GatewayState, K_2>)
                          | Pick<GatewayState, K_2>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').GatewayProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').GatewayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').GatewayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').GatewayProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').GatewayState
                          >,
                          nextContext: any
                          ): void;
                          }) => void;
                          getInstance(): any;
                          render(): any;
                          context: any;
                          setState<K_3 extends keyof OverlayState>(
                          state:
                          | OverlayState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >
                          ) =>
                          | OverlayState
                          | Pick<OverlayState, K_3>)
                          | Pick<OverlayState, K_3>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay/types').OverlayV1Props
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').OverlayState
                          >;
                          refs: { [key: string]: any };
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          prevState: Readonly<
                          import('../overlay/types').OverlayState
                          >
                          ): any;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay/types').OverlayV1Props
                          >,
                          nextState: Readonly<
                          import('../overlay/types').OverlayState
                          >,
                          nextContext: any
                          ): void;
                          };
                          _timer: number | null;
                          _hideTimer: number | null;
                          _showTimer: number | null;
                          componentWillUnmount(): void;
                          handleVisibleChange(
                          visible: boolean,
                          type: string | object,
                          e?: KeyboardEvent | MouseEvent | undefined
                          ): void;
                          handleTriggerClick(
                          e: KeyboardEvent | MouseEvent
                          ): void;
                          handleTriggerKeyDown(e: KeyboardEvent): void;
                          handleTriggerMouseEnter(e: MouseEvent): void;
                          handleTriggerMouseLeave(
                          e: MouseEvent,
                          type: string | object
                          ): void;
                          handleTriggerFocus(e: MouseEvent): void;
                          handleTriggerBlur(e: MouseEvent): void;
                          handleContentMouseDown(): void;
                          handleContentMouseEnter(): void;
                          handleContentMouseLeave(e: MouseEvent): void;
                          handleMaskMouseEnter(): void;
                          handleMaskMouseLeave(): void;
                          handleRequestClose(
                          type: string | object,
                          e: MouseEvent
                          ): void;
                          renderTrigger():
                          | import('react').ReactElement<
                          any,
                          | string
                          | import('react').JSXElementConstructor<any>
                          >
                          | undefined;
                          renderContent(): any;
                          renderPortal(): any;
                          render(): (
                          | import('react').JSX.Element
                          | undefined
                          )[];
                          context: any;
                          setState<K_4 extends 'visible'>(
                          state:
                          | PopupState
                          | ((
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => PopupState | Pick<PopupState, K_4>)
                          | Pick<PopupState, K_4>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(
                          callback?: (() => void) | undefined
                          ): void;
                          readonly props: Readonly<
                          import('../overlay').PopupProps
                          > &
                          Readonly<{
                          children?: import('react').ReactNode;
                          }>;
                          state: Readonly<
                          import('../overlay/types').PopupState
                          >;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): boolean;
                          componentDidCatch?(
                          error: Error,
                          errorInfo: any
                          ): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          prevState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<
                          import('../overlay').PopupProps
                          >,
                          nextState: Readonly<
                          import('../overlay/types').PopupState
                          >,
                          nextContext: any
                          ): void;
                          }): void;
                          render(): any;
                          context: any;
                          setState<K_5 extends never>(
                          state:
                          | {}
                          | ((
                          prevState: Readonly<{}>,
                          props: Readonly<
                          import('../overlay').PopupProps
                          >
                          ) => {} | Pick<{}, K_5>)
                          | Pick<{}, K_5>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          readonly props: Readonly<
                          import('../overlay').PopupProps
                          > &
                          Readonly<{ children?: import('react').ReactNode }>;
                          state: Readonly<{}>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('../overlay').PopupProps>,
                          prevState: Readonly<{}>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('../overlay').PopupProps>,
                          nextState: Readonly<{}>,
                          nextContext: any
                          ): void;
                          },
                          'overlay'
                          >
                          ): void;
                          handleAfterOpen(): void;
                          handleSelect(
                          value: unknown,
                          data: import('./types').CascaderSelectDataItem
                          ): void;
                          refreshValueDataCache: (curValue: string | string[]) => void;
                          handleChange(
                          value: string[],
                          data: import('./types').CascaderSelectDataItem[],
                          extra: import('../cascader').Extra
                          ): void;
                          handleClear(): void;
                          handleRemove(
                          currentData: import('./types').CascaderSelectDataItem
                          ): void;
                          handleSearch(searchValue: string): void;
                          getPath(pos: string): import('./types').CascaderSelectDataItem[];
                          filterItems(): import('./types').CascaderSelectDataItem[][];
                          renderNotFound(): any;
                          renderCascader(): any;
                          renderPopupContent(): any;
                          renderPreview(others: any): any;
                          render(): any;
                          context: any;
                          setState<K_6 extends keyof CascaderSelectState>(
                          state:
                          | CascaderSelectState
                          | ((
                          prevState: Readonly<import('./types').CascaderSelectState>,
                          props: Readonly<import('./types').CascaderSelectProps>
                          ) => CascaderSelectState | Pick<CascaderSelectState, K_6>)
                          | Pick<CascaderSelectState, K_6>,
                          callback?: (() => void) | undefined
                          ): void;
                          forceUpdate(callback?: (() => void) | undefined): void;
                          state: Readonly<import('./types').CascaderSelectState>;
                          refs: { [key: string]: any };
                          componentDidMount?(): void;
                          shouldComponentUpdate?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextState: Readonly<import('./types').CascaderSelectState>,
                          nextContext: any
                          ): boolean;
                          componentWillUnmount?(): void;
                          componentDidCatch?(error: Error, errorInfo: any): void;
                          getSnapshotBeforeUpdate?(
                          prevProps: Readonly<import('./types').CascaderSelectProps>,
                          prevState: Readonly<import('./types').CascaderSelectState>
                          ): any;
                          componentDidUpdate?(
                          prevProps: Readonly<import('./types').CascaderSelectProps>,
                          prevState: Readonly<import('./types').CascaderSelectState>,
                          snapshot?: any
                          ): void;
                          componentWillMount?(): void;
                          UNSAFE_componentWillMount?(): void;
                          componentWillReceiveProps?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillReceiveProps?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextContext: any
                          ): void;
                          componentWillUpdate?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextState: Readonly<import('./types').CascaderSelectState>,
                          nextContext: any
                          ): void;
                          UNSAFE_componentWillUpdate?(
                          nextProps: Readonly<import('./types').CascaderSelectProps>,
                          nextState: Readonly<import('./types').CascaderSelectState>,
                          nextContext: any
                          ): void;
                          },
                          'focus'
                          >
                          >;

                            variable Checkbox

                            const Checkbox: ConfiguredComponentClass<
                            (CheckboxProps | (CheckboxProps & { children?: any })) & ComponentCommonProps,
                            any,
                            {}
                            > & {
                            Group: ConfiguredComponentClass<
                            GroupProps & ComponentCommonProps,
                            {
                            getChildContext(): {
                            __group__: boolean;
                            onChange: (
                            currentValue: import('./types').ValueItem,
                            event: any
                            ) => void;
                            selectedValue: import('./types').ValueItem[];
                            disabled: boolean | undefined;
                            };
                            onChange(currentValue: import('./types').ValueItem, event: any): void;
                            render(): any;
                            context: any;
                            setState<K extends 'value'>(
                            state:
                            | GroupState
                            | ((
                            prevState: Readonly<import('./types').GroupState>,
                            props: Readonly<import('./types').GroupProps>
                            ) => GroupState | Pick<GroupState, K>)
                            | Pick<GroupState, K>,
                            callback?: (() => void) | undefined
                            ): void;
                            forceUpdate(callback?: (() => void) | undefined): void;
                            readonly props: Readonly<import('./types').GroupProps> &
                            Readonly<{ children?: import('react').ReactNode }>;
                            state: Readonly<import('./types').GroupState>;
                            refs: { [key: string]: any };
                            componentDidMount?(): void;
                            shouldComponentUpdate?(
                            nextProps: Readonly<import('./types').GroupProps>,
                            nextState: Readonly<import('./types').GroupState>,
                            nextContext: any
                            ): boolean;
                            componentWillUnmount?(): void;
                            componentDidCatch?(error: Error, errorInfo: any): void;
                            getSnapshotBeforeUpdate?(
                            prevProps: Readonly<import('./types').GroupProps>,
                            prevState: Readonly<import('./types').GroupState>
                            ): any;
                            componentDidUpdate?(
                            prevProps: Readonly<import('./types').GroupProps>,
                            prevState: Readonly<import('./types').GroupState>,
                            snapshot?: any
                            ): void;
                            componentWillMount?(): void;
                            UNSAFE_componentWillMount?(): void;
                            componentWillReceiveProps?(
                            nextProps: Readonly<import('./types').GroupProps>,
                            nextContext: any
                            ): void;
                            UNSAFE_componentWillReceiveProps?(
                            nextProps: Readonly<import('./types').GroupProps>,
                            nextContext: any
                            ): void;
                            componentWillUpdate?(
                            nextProps: Readonly<import('./types').GroupProps>,
                            nextState: Readonly<import('./types').GroupState>,
                            nextContext: any
                            ): void;
                            UNSAFE_componentWillUpdate?(
                            nextProps: Readonly<import('./types').GroupProps>,
                            nextState: Readonly<import('./types').GroupState>,
                            nextContext: any
                            ): void;
                            },
                            {}
                            >;
                            };

                              variable Collapse

                              const Collapse: ConfiguredComponentClass<
                              CollapseProps & ComponentCommonProps,
                              {
                              onItemClick(key: import('./types').KeyType): void;
                              genratePanelId(
                              itemId: string | undefined,
                              index: number
                              ): string | undefined;
                              getProps(
                              item: import('./types').DataItem,
                              index: number,
                              key: import('./types').KeyType
                              ): {
                              key: import('./types').KeyType;
                              title: any;
                              isExpanded: boolean;
                              disabled: boolean | undefined;
                              id: string | undefined;
                              onClick: (() => void) | null;
                              };
                              getItemsByDataSource(): import('react').JSX.Element[];
                              getItemsByChildren():
                              | import('react').ReactElement<
                              any,
                              string | import('react').JSXElementConstructor<any>
                              >[]
                              | null
                              | undefined;
                              setExpandedKey(expandedKeys: import('./types').KeyType[]): void;
                              render(): any;
                              context: any;
                              setState<K extends 'expandedKeys'>(
                              state:
                              | { expandedKeys: import('./types').KeyType[] }
                              | ((
                              prevState: Readonly<{
                              expandedKeys: import('./types').KeyType[];
                              }>,
                              props: Readonly<CollapseProps>
                              ) =>
                              | { expandedKeys: import('./types').KeyType[] }
                              | Pick<{ expandedKeys: import('./types').KeyType[] }, K>)
                              | Pick<{ expandedKeys: import('./types').KeyType[] }, K>,
                              callback?: (() => void) | undefined
                              ): void;
                              forceUpdate(callback?: (() => void) | undefined): void;
                              readonly props: Readonly<CollapseProps> &
                              Readonly<{ children?: import('react').ReactNode }>;
                              state: Readonly<{ expandedKeys: import('./types').KeyType[] }>;
                              refs: { [key: string]: any };
                              componentDidMount?(): void;
                              shouldComponentUpdate?(
                              nextProps: Readonly<CollapseProps>,
                              nextState: Readonly<{ expandedKeys: import('./types').KeyType[] }>,
                              nextContext: any
                              ): boolean;
                              componentWillUnmount?(): void;
                              componentDidCatch?(error: Error, errorInfo: any): void;
                              getSnapshotBeforeUpdate?(
                              prevProps: Readonly<CollapseProps>,
                              prevState: Readonly<{ expandedKeys: import('./types').KeyType[] }>
                              ): any;
                              componentDidUpdate?(
                              prevProps: Readonly<CollapseProps>,
                              prevState: Readonly<{ expandedKeys: import('./types').KeyType[] }>,
                              snapshot?: any
                              ): void;
                              componentWillMount?(): void;
                              UNSAFE_componentWillMount?(): void;
                              componentWillReceiveProps?(
                              nextProps: Readonly<CollapseProps>,
                              nextContext: any
                              ): void;
                              UNSAFE_componentWillReceiveProps?(
                              nextProps: Readonly<CollapseProps>,
                              nextContext: any
                              ): void;
                              componentWillUpdate?(
                              nextProps: Readonly<CollapseProps>,
                              nextState: Readonly<{ expandedKeys: import('./types').KeyType[] }>,
                              nextContext: any
                              ): void;
                              UNSAFE_componentWillUpdate?(
                              nextProps: Readonly<CollapseProps>,
                              nextState: Readonly<{ expandedKeys: import('./types').KeyType[] }>,
                              nextContext: any
                              ): void;
                              },
                              {}
                              > & {
                              Panel: ConfiguredComponentClass<
                              PanelProps & ComponentCommonProps,
                              {
                              onKeyDown: (e: any) => void;
                              render(): any;
                              context: any;
                              setState<K_1 extends never>(
                              state:
                              | {}
                              | ((
                              prevState: Readonly<{}>,
                              props: Readonly<PanelProps>
                              ) => {} | Pick<{}, K_1>)
                              | Pick<{}, K_1>,
                              callback?: (() => void) | undefined
                              ): void;
                              forceUpdate(callback?: (() => void) | undefined): void;
                              readonly props: Readonly<PanelProps> &
                              Readonly<{ children?: import('react').ReactNode }>;
                              state: Readonly<{}>;
                              refs: { [key: string]: any };
                              componentDidMount?(): void;
                              shouldComponentUpdate?(
                              nextProps: Readonly<PanelProps>,
                              nextState: Readonly<{}>,
                              nextContext: any
                              ): boolean;
                              componentWillUnmount?(): void;
                              componentDidCatch?(error: Error, errorInfo: any): void;
                              getSnapshotBeforeUpdate?(
                              prevProps: Readonly<PanelProps>,
                              prevState: Readonly<{}>
                              ): any;
                              componentDidUpdate?(
                              prevProps: Readonly<PanelProps>,
                              prevState: Readonly<{}>,
                              snapshot?: any
                              ): void;
                              componentWillMount?(): void;
                              UNSAFE_componentWillMount?(): void;
                              componentWillReceiveProps?(
                              nextProps: Readonly<PanelProps>,
                              nextContext: any
                              ): void;
                              UNSAFE_componentWillReceiveProps?(
                              nextProps: Readonly<PanelProps>,
                              nextContext: any
                              ): void;
                              componentWillUpdate?(
                              nextProps: Readonly<PanelProps>,
                              nextState: Readonly<{}>,
                              nextContext: any
                              ): void;
                              UNSAFE_componentWillUpdate?(
                              nextProps: Readonly<PanelProps>,
                              nextState: Readonly<{}>,
                              nextContext: any
                              ): void;
                              },
                              {}
                              > & { isNextPanel: boolean };
                              };

                                variable ConfigProvider

                                const ConfigProvider: typeof ConfigProvider;

                                  variable DatePicker

                                  const DatePicker: ConfiguredComponentClass<
                                  DatePickerProps & ComponentCommonProps,
                                  {
                                  readonly props: Readonly<
                                  import('../util').RequiredSome<
                                  import('./types').DatePickerProps,
                                  | 'size'
                                  | 'rtl'
                                  | 'format'
                                  | 'prefix'
                                  | 'locale'
                                  | 'onChange'
                                  | 'defaultVisible'
                                  | 'onVisibleChange'
                                  | 'popupAlign'
                                  | 'disabledDate'
                                  | 'hasClear'
                                  | 'popupTriggerType'
                                  | 'showTime'
                                  | 'resetTime'
                                  | 'footerRender'
                                  | 'onOk'
                                  >
                                  > &
                                  Readonly<
                                  Pick<
                                  {
                                  prefix: string;
                                  rtl: boolean;
                                  format: string;
                                  size: string;
                                  showTime: boolean;
                                  resetTime: boolean;
                                  disabledDate: () => boolean;
                                  footerRender: () => null;
                                  hasClear: boolean;
                                  popupTriggerType: string;
                                  popupAlign: string;
                                  locale: Partial<{
                                  placeholder: string;
                                  datetimePlaceholder: string;
                                  monthPlaceholder: string;
                                  weekPlaceholder: string;
                                  yearPlaceholder: string;
                                  now: string;
                                  selectTime: string;
                                  selectDate: string;
                                  ok: string;
                                  clear: string;
                                  startPlaceholder: string;
                                  endPlaceholder: string;
                                  hour: string;
                                  minute: string;
                                  second: string;
                                  monthBeforeYear?: boolean | undefined;
                                  }> & { momentLocale?: string | undefined };
                                  defaultVisible: boolean;
                                  onChange: () => void;
                                  onVisibleChange: () => void;
                                  onOk: () => void;
                                  },
                                  never
                                  >
                                  >;
                                  onValueChange: (
                                  newValue: import('moment').Moment | null,
                                  handler?: 'onChange' | 'onOk'
                                  ) => void;
                                  onSelectCalendarPanel: (value: any) => void;
                                  onSelectTimePanel: (value: any) => void;
                                  clearValue: () => void;
                                  onDateInputChange: (
                                  inputStr: string | null | undefined,
                                  e: any,
                                  eventType?: string | undefined
                                  ) => void;
                                  onTimeInputChange: (inputStr: string) => void;
                                  onDateInputBlur: () => void;
                                  onTimeInputBlur: () => void;
                                  onKeyDown: (e: any) => void;
                                  onTimeKeyDown: (e: any) => void;
                                  handleChange: (
                                  newValue: import('moment').Moment | null,
                                  prevValue: import('moment').Moment | null,
                                  others?: {}
                                  ) => void;
                                  onFoucsDateInput: () => void;
                                  onFoucsTimeInput: () => void;
                                  onVisibleChange: (visible: boolean, type: string) => void;
                                  changePanel: (panel: import('./types').PanelType) => void;
                                  onOk: (value?: import('moment').Moment | null | undefined) => void;
                                  renderPreview(others: any): any;
                                  render(): any;
                                  context: any;
                                  setState<K extends keyof DatePickerState>(
                                  state:
                                  | DatePickerState
                                  | ((
                                  prevState: Readonly<import('./types').DatePickerState>,
                                  props: Readonly<import('./types').DatePickerProps>
                                  ) => DatePickerState | Pick<DatePickerState, K>)
                                  | Pick<DatePickerState, K>,
                                  callback?: (() => void) | undefined
                                  ): void;
                                  forceUpdate(callback?: (() => void) | undefined): void;
                                  state: Readonly<import('./types').DatePickerState>;
                                  refs: { [key: string]: any };
                                  componentDidMount?(): void;
                                  shouldComponentUpdate?(
                                  nextProps: Readonly<import('./types').DatePickerProps>,
                                  nextState: Readonly<import('./types').DatePickerState>,
                                  nextContext: any
                                  ): boolean;
                                  componentWillUnmount?(): void;
                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                  getSnapshotBeforeUpdate?(
                                  prevProps: Readonly<import('./types').DatePickerProps>,
                                  prevState: Readonly<import('./types').DatePickerState>
                                  ): any;
                                  componentDidUpdate?(
                                  prevProps: Readonly<import('./types').DatePickerProps>,
                                  prevState: Readonly<import('./types').DatePickerState>,
                                  snapshot?: any
                                  ): void;
                                  componentWillMount?(): void;
                                  UNSAFE_componentWillMount?(): void;
                                  componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').DatePickerProps>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').DatePickerProps>,
                                  nextContext: any
                                  ): void;
                                  componentWillUpdate?(
                                  nextProps: Readonly<import('./types').DatePickerProps>,
                                  nextState: Readonly<import('./types').DatePickerState>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillUpdate?(
                                  nextProps: Readonly<import('./types').DatePickerProps>,
                                  nextState: Readonly<import('./types').DatePickerState>,
                                  nextContext: any
                                  ): void;
                                  },
                                  {}
                                  > & {
                                  RangePicker: ConfiguredComponentClass<
                                  RangePickerProps & ComponentCommonProps,
                                  {
                                  readonly props: Readonly<
                                  import('../util').RequiredSome<
                                  import('./types').RangePickerProps,
                                  | 'size'
                                  | 'rtl'
                                  | 'type'
                                  | 'prefix'
                                  | 'locale'
                                  | 'onChange'
                                  | 'defaultVisible'
                                  | 'onVisibleChange'
                                  | 'popupAlign'
                                  | 'disabledDate'
                                  | 'disableChangeMode'
                                  | 'hasClear'
                                  | 'popupTriggerType'
                                  | 'showTime'
                                  | 'resetTime'
                                  | 'footerRender'
                                  | 'onOk'
                                  >
                                  > &
                                  Readonly<
                                  Pick<
                                  {
                                  prefix: string;
                                  rtl: boolean;
                                  type: string;
                                  size: string;
                                  showTime: boolean;
                                  resetTime: boolean;
                                  disabledDate: () => boolean;
                                  footerRender: () => null;
                                  hasClear: boolean;
                                  defaultVisible: boolean;
                                  popupTriggerType: string;
                                  popupAlign: string;
                                  locale: Partial<{
                                  placeholder: string;
                                  datetimePlaceholder: string;
                                  monthPlaceholder: string;
                                  weekPlaceholder: string;
                                  yearPlaceholder: string;
                                  now: string;
                                  selectTime: string;
                                  selectDate: string;
                                  ok: string;
                                  clear: string;
                                  startPlaceholder: string;
                                  endPlaceholder: string;
                                  hour: string;
                                  minute: string;
                                  second: string;
                                  monthBeforeYear?: boolean | undefined;
                                  }> & { momentLocale?: string | undefined };
                                  disableChangeMode: boolean;
                                  onChange: () => void;
                                  onOk: () => void;
                                  onVisibleChange: () => void;
                                  },
                                  never
                                  >
                                  >;
                                  startDateInputRef: any;
                                  endDateInputRef: any;
                                  autoSwitchDateInput: boolean;
                                  onValueChange: (
                                  values: (import('moment').Moment | null | undefined)[],
                                  handler?: 'onChange' | 'onOk'
                                  ) => void;
                                  onSelectCalendarPanel: (
                                  value: any,
                                  active?:
                                  | 'startValue'
                                  | 'endValue'
                                  | 'startTime'
                                  | 'endTime'
                                  | undefined
                                  ) => void;
                                  clearRange: () => void;
                                  onDateInputChange: (
                                  inputStr: string,
                                  e: any,
                                  eventType?: string | undefined
                                  ) => void;
                                  onDateInputBlur: () => void;
                                  onDateInputKeyDown: (e: any) => void;
                                  onFocusDateInput: (
                                  type: 'startValue' | 'endValue' | 'startTime' | 'endTime' | undefined
                                  ) => void;
                                  onFocusTimeInput: (
                                  type: 'startValue' | 'endValue' | 'startTime' | 'endTime' | undefined
                                  ) => void;
                                  onSelectStartTime: (value: any) => void;
                                  onSelectEndTime: (value: any) => void;
                                  onTimeInputChange: (inputStr: string) => void;
                                  onTimeInputBlur: () => void;
                                  onTimeInputKeyDown: (e: any) => void;
                                  handleChange: (
                                  valueName: 'startValue' | 'endValue',
                                  newValue?: import('moment').Moment | null | undefined
                                  ) => void;
                                  onVisibleChange: (visible: boolean, type: string) => void;
                                  changePanel: (panel: import('./types').PanelType) => void;
                                  onOk: (
                                  value?: (import('moment').Moment | null | undefined)[] | undefined
                                  ) => void;
                                  getDisabledTime: ({
                                  startValue,
                                  endValue,
                                  }: {
                                  startValue?: import('moment').Moment | null | undefined;
                                  endValue?: import('moment').Moment | null | undefined;
                                  } & Record<string, unknown>) => {};
                                  enableAutoSwitchDateInput: () => void;
                                  afterOpen: () => void;
                                  renderPreview(
                                  [startValue, endValue]: [
                                  import('moment').Moment | null,
                                  import('moment').Moment | null
                                  ],
                                  others: any
                                  ): any;
                                  render(): any;
                                  context: any;
                                  setState<K_1 extends keyof RangePickerState>(
                                  state:
                                  | RangePickerState
                                  | ((
                                  prevState: Readonly<import('./types').RangePickerState>,
                                  props: Readonly<import('./types').RangePickerProps>
                                  ) => RangePickerState | Pick<RangePickerState, K_1>)
                                  | Pick<RangePickerState, K_1>,
                                  callback?: (() => void) | undefined
                                  ): void;
                                  forceUpdate(callback?: (() => void) | undefined): void;
                                  state: Readonly<import('./types').RangePickerState>;
                                  refs: { [key: string]: any };
                                  componentDidMount?(): void;
                                  shouldComponentUpdate?(
                                  nextProps: Readonly<import('./types').RangePickerProps>,
                                  nextState: Readonly<import('./types').RangePickerState>,
                                  nextContext: any
                                  ): boolean;
                                  componentWillUnmount?(): void;
                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                  getSnapshotBeforeUpdate?(
                                  prevProps: Readonly<import('./types').RangePickerProps>,
                                  prevState: Readonly<import('./types').RangePickerState>
                                  ): any;
                                  componentDidUpdate?(
                                  prevProps: Readonly<import('./types').RangePickerProps>,
                                  prevState: Readonly<import('./types').RangePickerState>,
                                  snapshot?: any
                                  ): void;
                                  componentWillMount?(): void;
                                  UNSAFE_componentWillMount?(): void;
                                  componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').RangePickerProps>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').RangePickerProps>,
                                  nextContext: any
                                  ): void;
                                  componentWillUpdate?(
                                  nextProps: Readonly<import('./types').RangePickerProps>,
                                  nextState: Readonly<import('./types').RangePickerState>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillUpdate?(
                                  nextProps: Readonly<import('./types').RangePickerProps>,
                                  nextState: Readonly<import('./types').RangePickerState>,
                                  nextContext: any
                                  ): void;
                                  },
                                  {}
                                  >;
                                  MonthPicker: ConfiguredComponentClass<
                                  MonthPickerProps & ComponentCommonProps,
                                  {
                                  readonly props: Readonly<
                                  import('../util').RequiredSome<
                                  import('./types').MonthPickerProps,
                                  | 'size'
                                  | 'rtl'
                                  | 'format'
                                  | 'prefix'
                                  | 'locale'
                                  | 'onChange'
                                  | 'onVisibleChange'
                                  | 'popupAlign'
                                  | 'disabledDate'
                                  | 'hasClear'
                                  | 'popupTriggerType'
                                  | 'footerRender'
                                  >
                                  > &
                                  Readonly<
                                  Pick<
                                  {
                                  prefix: string;
                                  rtl: boolean;
                                  format: string;
                                  size: string;
                                  disabledDate: () => boolean;
                                  footerRender: () => null;
                                  hasClear: boolean;
                                  popupTriggerType: string;
                                  popupAlign: string;
                                  locale: Partial<{
                                  placeholder: string;
                                  datetimePlaceholder: string;
                                  monthPlaceholder: string;
                                  weekPlaceholder: string;
                                  yearPlaceholder: string;
                                  now: string;
                                  selectTime: string;
                                  selectDate: string;
                                  ok: string;
                                  clear: string;
                                  startPlaceholder: string;
                                  endPlaceholder: string;
                                  hour: string;
                                  minute: string;
                                  second: string;
                                  monthBeforeYear?: boolean | undefined;
                                  }> & { momentLocale?: string | undefined };
                                  onChange: () => void;
                                  onVisibleChange: () => void;
                                  },
                                  never
                                  >
                                  >;
                                  onValueChange: (newValue: import('moment').Moment | null) => void;
                                  onSelectCalendarPanel: (value: any) => void;
                                  clearValue: () => void;
                                  onDateInputChange: (
                                  inputStr: string,
                                  e: any,
                                  eventType?: string | undefined
                                  ) => void;
                                  onDateInputBlur: () => void;
                                  onKeyDown: (e: any) => void;
                                  handleChange: (
                                  newValue: import('moment').Moment | null,
                                  prevValue: import('moment').Moment | null,
                                  others?: {},
                                  callback?: (() => void) | undefined
                                  ) => void;
                                  onVisibleChange: (visible: boolean, type: string) => void;
                                  renderPreview(others: any): any;
                                  render(): any;
                                  context: any;
                                  setState<K_2 extends keyof MonthPickerState>(
                                  state:
                                  | MonthPickerState
                                  | ((
                                  prevState: Readonly<import('./types').MonthPickerState>,
                                  props: Readonly<import('./types').MonthPickerProps>
                                  ) => MonthPickerState | Pick<MonthPickerState, K_2>)
                                  | Pick<MonthPickerState, K_2>,
                                  callback?: (() => void) | undefined
                                  ): void;
                                  forceUpdate(callback?: (() => void) | undefined): void;
                                  state: Readonly<import('./types').MonthPickerState>;
                                  refs: { [key: string]: any };
                                  componentDidMount?(): void;
                                  shouldComponentUpdate?(
                                  nextProps: Readonly<import('./types').MonthPickerProps>,
                                  nextState: Readonly<import('./types').MonthPickerState>,
                                  nextContext: any
                                  ): boolean;
                                  componentWillUnmount?(): void;
                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                  getSnapshotBeforeUpdate?(
                                  prevProps: Readonly<import('./types').MonthPickerProps>,
                                  prevState: Readonly<import('./types').MonthPickerState>
                                  ): any;
                                  componentDidUpdate?(
                                  prevProps: Readonly<import('./types').MonthPickerProps>,
                                  prevState: Readonly<import('./types').MonthPickerState>,
                                  snapshot?: any
                                  ): void;
                                  componentWillMount?(): void;
                                  UNSAFE_componentWillMount?(): void;
                                  componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').MonthPickerProps>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').MonthPickerProps>,
                                  nextContext: any
                                  ): void;
                                  componentWillUpdate?(
                                  nextProps: Readonly<import('./types').MonthPickerProps>,
                                  nextState: Readonly<import('./types').MonthPickerState>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillUpdate?(
                                  nextProps: Readonly<import('./types').MonthPickerProps>,
                                  nextState: Readonly<import('./types').MonthPickerState>,
                                  nextContext: any
                                  ): void;
                                  },
                                  {}
                                  >;
                                  YearPicker: ConfiguredComponentClass<
                                  YearPickerProps & ComponentCommonProps,
                                  {
                                  readonly props: Readonly<
                                  import('../util').RequiredSome<
                                  import('./types').YearPickerProps,
                                  | 'size'
                                  | 'rtl'
                                  | 'format'
                                  | 'prefix'
                                  | 'locale'
                                  | 'onChange'
                                  | 'onVisibleChange'
                                  | 'popupAlign'
                                  | 'disabledDate'
                                  | 'hasClear'
                                  | 'popupTriggerType'
                                  | 'footerRender'
                                  >
                                  > &
                                  Readonly<
                                  Pick<
                                  {
                                  prefix: string;
                                  rtl: boolean;
                                  format: string;
                                  size: string;
                                  disabledDate: () => boolean;
                                  footerRender: () => null;
                                  hasClear: boolean;
                                  popupTriggerType: string;
                                  popupAlign: string;
                                  locale: Partial<{
                                  placeholder: string;
                                  datetimePlaceholder: string;
                                  monthPlaceholder: string;
                                  weekPlaceholder: string;
                                  yearPlaceholder: string;
                                  now: string;
                                  selectTime: string;
                                  selectDate: string;
                                  ok: string;
                                  clear: string;
                                  startPlaceholder: string;
                                  endPlaceholder: string;
                                  hour: string;
                                  minute: string;
                                  second: string;
                                  monthBeforeYear?: boolean | undefined;
                                  }> & { momentLocale?: string | undefined };
                                  onChange: () => void;
                                  onVisibleChange: () => void;
                                  },
                                  never
                                  >
                                  >;
                                  onValueChange: (newValue: import('moment').Moment | null) => void;
                                  onSelectCalendarPanel: (value: any) => void;
                                  clearValue: () => void;
                                  onDateInputChange: (
                                  inputStr: string,
                                  e: any,
                                  eventType?: string | undefined
                                  ) => void;
                                  onDateInputBlur: () => void;
                                  onKeyDown: (e: any) => void;
                                  handleChange: (
                                  newValue: import('moment').Moment | null,
                                  prevValue: import('moment').Moment | null,
                                  others?: {},
                                  callback?: (() => void) | undefined
                                  ) => void;
                                  onVisibleChange: (visible: boolean, reason: string) => void;
                                  renderPreview(others: any): any;
                                  render(): any;
                                  context: any;
                                  setState<K_3 extends keyof YearPickerState>(
                                  state:
                                  | YearPickerState
                                  | ((
                                  prevState: Readonly<import('./types').YearPickerState>,
                                  props: Readonly<import('./types').YearPickerProps>
                                  ) => YearPickerState | Pick<YearPickerState, K_3>)
                                  | Pick<YearPickerState, K_3>,
                                  callback?: (() => void) | undefined
                                  ): void;
                                  forceUpdate(callback?: (() => void) | undefined): void;
                                  state: Readonly<import('./types').YearPickerState>;
                                  refs: { [key: string]: any };
                                  componentDidMount?(): void;
                                  shouldComponentUpdate?(
                                  nextProps: Readonly<import('./types').YearPickerProps>,
                                  nextState: Readonly<import('./types').YearPickerState>,
                                  nextContext: any
                                  ): boolean;
                                  componentWillUnmount?(): void;
                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                  getSnapshotBeforeUpdate?(
                                  prevProps: Readonly<import('./types').YearPickerProps>,
                                  prevState: Readonly<import('./types').YearPickerState>
                                  ): any;
                                  componentDidUpdate?(
                                  prevProps: Readonly<import('./types').YearPickerProps>,
                                  prevState: Readonly<import('./types').YearPickerState>,
                                  snapshot?: any
                                  ): void;
                                  componentWillMount?(): void;
                                  UNSAFE_componentWillMount?(): void;
                                  componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').YearPickerProps>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').YearPickerProps>,
                                  nextContext: any
                                  ): void;
                                  componentWillUpdate?(
                                  nextProps: Readonly<import('./types').YearPickerProps>,
                                  nextState: Readonly<import('./types').YearPickerState>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillUpdate?(
                                  nextProps: Readonly<import('./types').YearPickerProps>,
                                  nextState: Readonly<import('./types').YearPickerState>,
                                  nextContext: any
                                  ): void;
                                  },
                                  {}
                                  >;
                                  WeekPicker: ConfiguredComponentClass<
                                  WeekPickerProps & ComponentCommonProps,
                                  {
                                  readonly props: Readonly<
                                  import('../util').RequiredSome<
                                  import('./types').WeekPickerProps,
                                  | 'size'
                                  | 'rtl'
                                  | 'format'
                                  | 'prefix'
                                  | 'locale'
                                  | 'onChange'
                                  | 'defaultVisible'
                                  | 'onVisibleChange'
                                  | 'popupAlign'
                                  | 'disabledDate'
                                  | 'hasClear'
                                  | 'popupTriggerType'
                                  | 'footerRender'
                                  >
                                  > &
                                  Readonly<
                                  Pick<
                                  {
                                  prefix: string;
                                  rtl: boolean;
                                  format: string;
                                  size: string;
                                  disabledDate: () => boolean;
                                  footerRender: () => null;
                                  hasClear: boolean;
                                  popupTriggerType: string;
                                  popupAlign: string;
                                  locale: Partial<{
                                  placeholder: string;
                                  datetimePlaceholder: string;
                                  monthPlaceholder: string;
                                  weekPlaceholder: string;
                                  yearPlaceholder: string;
                                  now: string;
                                  selectTime: string;
                                  selectDate: string;
                                  ok: string;
                                  clear: string;
                                  startPlaceholder: string;
                                  endPlaceholder: string;
                                  hour: string;
                                  minute: string;
                                  second: string;
                                  monthBeforeYear?: boolean | undefined;
                                  }> & { momentLocale?: string | undefined };
                                  defaultVisible: boolean;
                                  onChange: () => void;
                                  onVisibleChange: () => void;
                                  },
                                  never
                                  >
                                  >;
                                  handleChange: (
                                  newValue: import('moment').Moment | null,
                                  prevValue: import('moment').Moment | null
                                  ) => void;
                                  onDateInputChange: (
                                  value: import('moment').Moment | null,
                                  e: any,
                                  eventType: string
                                  ) => void;
                                  onKeyDown: (e: any) => void;
                                  onVisibleChange: (visible: boolean, type: string) => void;
                                  onSelectCalendarPanel: (value: import('moment').Moment | null) => void;
                                  renderPreview(others: any): any;
                                  dateRender: (value: any) => any;
                                  render(): any;
                                  context: any;
                                  setState<K_4 extends keyof WeekPickerState>(
                                  state:
                                  | WeekPickerState
                                  | ((
                                  prevState: Readonly<import('./types').WeekPickerState>,
                                  props: Readonly<import('./types').WeekPickerProps>
                                  ) => WeekPickerState | Pick<WeekPickerState, K_4>)
                                  | Pick<WeekPickerState, K_4>,
                                  callback?: (() => void) | undefined
                                  ): void;
                                  forceUpdate(callback?: (() => void) | undefined): void;
                                  state: Readonly<import('./types').WeekPickerState>;
                                  refs: { [key: string]: any };
                                  componentDidMount?(): void;
                                  shouldComponentUpdate?(
                                  nextProps: Readonly<import('./types').WeekPickerProps>,
                                  nextState: Readonly<import('./types').WeekPickerState>,
                                  nextContext: any
                                  ): boolean;
                                  componentWillUnmount?(): void;
                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                  getSnapshotBeforeUpdate?(
                                  prevProps: Readonly<import('./types').WeekPickerProps>,
                                  prevState: Readonly<import('./types').WeekPickerState>
                                  ): any;
                                  componentDidUpdate?(
                                  prevProps: Readonly<import('./types').WeekPickerProps>,
                                  prevState: Readonly<import('./types').WeekPickerState>,
                                  snapshot?: any
                                  ): void;
                                  componentWillMount?(): void;
                                  UNSAFE_componentWillMount?(): void;
                                  componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').WeekPickerProps>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillReceiveProps?(
                                  nextProps: Readonly<import('./types').WeekPickerProps>,
                                  nextContext: any
                                  ): void;
                                  componentWillUpdate?(
                                  nextProps: Readonly<import('./types').WeekPickerProps>,
                                  nextState: Readonly<import('./types').WeekPickerState>,
                                  nextContext: any
                                  ): void;
                                  UNSAFE_componentWillUpdate?(
                                  nextProps: Readonly<import('./types').WeekPickerProps>,
                                  nextState: Readonly<import('./types').WeekPickerState>,
                                  nextContext: any
                                  ): void;
                                  },
                                  {}
                                  >;
                                  };

                                    variable Dialog

                                    const Dialog: ConfiguredComponentClass<
                                    DialogProps & ComponentCommonProps,
                                    Dialog,
                                    {}
                                    > & {
                                    help: (config: ShowConfig) => { hide: () => void };
                                    show: (config: ShowConfig) => { hide: () => void };
                                    warning: (config: ShowConfig) => { hide: () => void };
                                    error: (config: ShowConfig) => { hide: () => void };
                                    alert: (config: ShowConfig) => { hide: () => void };
                                    confirm: (config: ShowConfig) => { hide: () => void };
                                    Inner: typeof Inner;
                                    success: (config: ShowConfig) => { hide: () => void };
                                    notice: (config: ShowConfig) => { hide: () => void };
                                    withContext: <P extends WithContextDialogProps, C>(
                                    WrappedComponent: any
                                    ) => (
                                    props: JSX.LibraryManagedAttributes<C, Omit<P, 'contextDialog'>>
                                    ) => React.JSX.Element;
                                    };

                                      variable Divider

                                      const Divider: ConfiguredComponentClass<
                                      DividerProps & ComponentCommonProps,
                                      Divider,
                                      {}
                                      >;

                                        variable Drawer

                                        const Drawer: ConfiguredComponentClass<
                                        DrawerProps & ComponentCommonProps,
                                        Drawer,
                                        {}
                                        > & {
                                        show: (config?: DrawerProps | undefined) => QuickShowRet;
                                        Inner: typeof Inner;
                                        withContext: <P extends object>(
                                        WrappedComponent: React.ComponentType<P>
                                        ) => React.ComponentType<P>;
                                        };
                                          const Dropdown: ConfiguredComponentClass<
                                          DropdownProps & ComponentCommonProps,
                                          Dropdown,
                                          {}
                                          >;

                                            variable Form

                                            const Form: ConfiguredComponentClass<FormProps & ComponentCommonProps, Form, {}> & {
                                            Item: import('../config-provider/types').ConfiguredComponentClass<
                                            ItemProps & import('../config-provider/types').ComponentCommonProps,
                                            Item,
                                            {}
                                            > & { _typeMark: string };
                                            Error: ConfiguredComponentClass<
                                            ErrorProps & ComponentCommonProps,
                                            {
                                            itemRender: (errors: unknown[]) => unknown[] | null;
                                            render(): import('react').JSX.Element | null;
                                            context: any;
                                            setState<K extends never>(
                                            state:
                                            | {}
                                            | ((
                                            prevState: Readonly<{}>,
                                            props: Readonly<ErrorProps>
                                            ) => {} | Pick<{}, K>)
                                            | Pick<{}, K>,
                                            callback?: (() => void) | undefined
                                            ): void;
                                            forceUpdate(callback?: (() => void) | undefined): void;
                                            readonly props: Readonly<ErrorProps> &
                                            Readonly<{ children?: import('react').ReactNode }>;
                                            state: Readonly<{}>;
                                            refs: { [key: string]: any };
                                            componentDidMount?(): void;
                                            shouldComponentUpdate?(
                                            nextProps: Readonly<ErrorProps>,
                                            nextState: Readonly<{}>,
                                            nextContext: any
                                            ): boolean;
                                            componentWillUnmount?(): void;
                                            componentDidCatch?(error: Error, errorInfo: any): void;
                                            getSnapshotBeforeUpdate?(
                                            prevProps: Readonly<ErrorProps>,
                                            prevState: Readonly<{}>
                                            ): any;
                                            componentDidUpdate?(
                                            prevProps: Readonly<ErrorProps>,
                                            prevState: Readonly<{}>,
                                            snapshot?: any
                                            ): void;
                                            componentWillMount?(): void;
                                            UNSAFE_componentWillMount?(): void;
                                            componentWillReceiveProps?(
                                            nextProps: Readonly<ErrorProps>,
                                            nextContext: any
                                            ): void;
                                            UNSAFE_componentWillReceiveProps?(
                                            nextProps: Readonly<ErrorProps>,
                                            nextContext: any
                                            ): void;
                                            componentWillUpdate?(
                                            nextProps: Readonly<ErrorProps>,
                                            nextState: Readonly<{}>,
                                            nextContext: any
                                            ): void;
                                            UNSAFE_componentWillUpdate?(
                                            nextProps: Readonly<ErrorProps>,
                                            nextState: Readonly<{}>,
                                            nextContext: any
                                            ): void;
                                            },
                                            {}
                                            > & { _typeMark: string };
                                            Submit: typeof Submit;
                                            Reset: typeof Reset;
                                            };

                                              variable Grid

                                              const Grid: {
                                              Row: import('../config-provider/types').ConfiguredComponentClass<
                                              RowProps & import('../config-provider/types').ComponentCommonProps,
                                              Row,
                                              {}
                                              >;
                                              Col: import('../config-provider/types').ConfiguredComponentClass<
                                              ColProps & import('../config-provider/types').ComponentCommonProps,
                                              Col,
                                              {}
                                              > & { isNextCol: boolean };
                                              };

                                                variable Icon

                                                const Icon: ConfiguredComponentClass<IconProps & ComponentCommonProps, Icon, {}> & {
                                                _typeMark: string;
                                                createFromIconfontCN: typeof createFromIconfontCN;
                                                };

                                                  variable Input

                                                  const Input: ConfiguredComponentClass<
                                                  InputProps & ComponentCommonProps,
                                                  Input<InputProps>,
                                                  Pick<Input<InputProps>, 'focus' | 'getInputNode'>
                                                  > & {
                                                  TextArea: import('../config-provider/types').ConfiguredComponentClass<
                                                  import('./types').TextAreaProps &
                                                  import('../config-provider/types').ComponentCommonProps,
                                                  TextArea,
                                                  Pick<TextArea, 'focus' | 'getInputNode'>
                                                  >;
                                                  Group: ConfiguredComponentClass<
                                                  GroupProps & ComponentCommonProps,
                                                  {
                                                  render(): any;
                                                  context: any;
                                                  setState<K extends never>(
                                                  state:
                                                  | {}
                                                  | ((
                                                  prevState: Readonly<{}>,
                                                  props: Readonly<import('./types').GroupProps>
                                                  ) => {} | Pick<{}, K>)
                                                  | Pick<{}, K>,
                                                  callback?: (() => void) | undefined
                                                  ): void;
                                                  forceUpdate(callback?: (() => void) | undefined): void;
                                                  readonly props: Readonly<import('./types').GroupProps> &
                                                  Readonly<{ children?: import('react').ReactNode }>;
                                                  state: Readonly<{}>;
                                                  refs: { [key: string]: any };
                                                  componentDidMount?(): void;
                                                  shouldComponentUpdate?(
                                                  nextProps: Readonly<import('./types').GroupProps>,
                                                  nextState: Readonly<{}>,
                                                  nextContext: any
                                                  ): boolean;
                                                  componentWillUnmount?(): void;
                                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                                  getSnapshotBeforeUpdate?(
                                                  prevProps: Readonly<import('./types').GroupProps>,
                                                  prevState: Readonly<{}>
                                                  ): any;
                                                  componentDidUpdate?(
                                                  prevProps: Readonly<import('./types').GroupProps>,
                                                  prevState: Readonly<{}>,
                                                  snapshot?: any
                                                  ): void;
                                                  componentWillMount?(): void;
                                                  UNSAFE_componentWillMount?(): void;
                                                  componentWillReceiveProps?(
                                                  nextProps: Readonly<import('./types').GroupProps>,
                                                  nextContext: any
                                                  ): void;
                                                  UNSAFE_componentWillReceiveProps?(
                                                  nextProps: Readonly<import('./types').GroupProps>,
                                                  nextContext: any
                                                  ): void;
                                                  componentWillUpdate?(
                                                  nextProps: Readonly<import('./types').GroupProps>,
                                                  nextState: Readonly<{}>,
                                                  nextContext: any
                                                  ): void;
                                                  UNSAFE_componentWillUpdate?(
                                                  nextProps: Readonly<import('./types').GroupProps>,
                                                  nextState: Readonly<{}>,
                                                  nextContext: any
                                                  ): void;
                                                  },
                                                  {}
                                                  >;
                                                  Password: import('../config-provider/types').ConfiguredComponentClass<
                                                  import('./types').PasswordProps &
                                                  import('../config-provider/types').ComponentCommonProps,
                                                  Password,
                                                  Pick<Password, 'focus' | 'getInputNode'>
                                                  >;
                                                  };

                                                    variable List

                                                    const List: ConfiguredComponentClass<
                                                    ListProps & ComponentCommonProps,
                                                    {
                                                    render(): any;
                                                    context: any;
                                                    setState<K extends never>(
                                                    state:
                                                    | {}
                                                    | ((
                                                    prevState: Readonly<{}>,
                                                    props: Readonly<import('./types').ListProps>
                                                    ) => {} | Pick<{}, K>)
                                                    | Pick<{}, K>,
                                                    callback?: (() => void) | undefined
                                                    ): void;
                                                    forceUpdate(callback?: (() => void) | undefined): void;
                                                    readonly props: Readonly<import('./types').ListProps> &
                                                    Readonly<{ children?: import('react').ReactNode }>;
                                                    state: Readonly<{}>;
                                                    refs: { [key: string]: any };
                                                    componentDidMount?(): void;
                                                    shouldComponentUpdate?(
                                                    nextProps: Readonly<import('./types').ListProps>,
                                                    nextState: Readonly<{}>,
                                                    nextContext: any
                                                    ): boolean;
                                                    componentWillUnmount?(): void;
                                                    componentDidCatch?(error: Error, errorInfo: any): void;
                                                    getSnapshotBeforeUpdate?(
                                                    prevProps: Readonly<import('./types').ListProps>,
                                                    prevState: Readonly<{}>
                                                    ): any;
                                                    componentDidUpdate?(
                                                    prevProps: Readonly<import('./types').ListProps>,
                                                    prevState: Readonly<{}>,
                                                    snapshot?: any
                                                    ): void;
                                                    componentWillMount?(): void;
                                                    UNSAFE_componentWillMount?(): void;
                                                    componentWillReceiveProps?(
                                                    nextProps: Readonly<import('./types').ListProps>,
                                                    nextContext: any
                                                    ): void;
                                                    UNSAFE_componentWillReceiveProps?(
                                                    nextProps: Readonly<import('./types').ListProps>,
                                                    nextContext: any
                                                    ): void;
                                                    componentWillUpdate?(
                                                    nextProps: Readonly<import('./types').ListProps>,
                                                    nextState: Readonly<{}>,
                                                    nextContext: any
                                                    ): void;
                                                    UNSAFE_componentWillUpdate?(
                                                    nextProps: Readonly<import('./types').ListProps>,
                                                    nextState: Readonly<{}>,
                                                    nextContext: any
                                                    ): void;
                                                    },
                                                    {}
                                                    > & {
                                                    Item: import('../config-provider/types').ConfiguredComponentClass<
                                                    import('./types').ListItemProps &
                                                    import('../config-provider/types').ComponentCommonProps,
                                                    import('./item').ListItem,
                                                    {}
                                                    >;
                                                    };

                                                      variable Loading

                                                      const Loading: ConfiguredComponentClass<
                                                      LoadingProps & ComponentCommonProps,
                                                      Loading,
                                                      {}
                                                      >;
                                                        const Menu: ConfiguredComponentClass<MenuProps & ComponentCommonProps, Menu, {}> & {
                                                        Group: typeof Group;
                                                        isNextMenu: boolean;
                                                        SubMenu: typeof SubMenu;
                                                        Item: typeof SelectableItem;
                                                        CheckboxItem: typeof CheckboxItem;
                                                        RadioItem: typeof RadioItem;
                                                        PopupItem: typeof PopupItem;
                                                        Divider: typeof Divider;
                                                        create: typeof create;
                                                        };
                                                          const MenuButton: ConfiguredComponentClass<
                                                          MenuButtonProps & ComponentCommonProps,
                                                          MenuButton,
                                                          {}
                                                          > & {
                                                          Group: typeof import('../menu/view/group').default;
                                                          Item: typeof import('../menu/view/selectable-item').default;
                                                          Divider: typeof import('../menu/view/divider').default;
                                                          };

                                                            variable Message

                                                            const Message: ConfiguredComponentClass<
                                                            MessageProps & ComponentCommonProps,
                                                            ConfiguredComponent<
                                                            MessageProps & ComponentCommonProps,
                                                            {
                                                            state: { visible: boolean | undefined };
                                                            onClose: () => void;
                                                            render(): import('react').JSX.Element | null;
                                                            context: any;
                                                            setState<K extends never>(
                                                            state:
                                                            | {}
                                                            | ((
                                                            prevState: Readonly<{}>,
                                                            props: Readonly<import('./types').MessageProps>
                                                            ) => {} | Pick<{}, K>)
                                                            | Pick<{}, K>,
                                                            callback?: (() => void) | undefined
                                                            ): void;
                                                            forceUpdate(callback?: (() => void) | undefined): void;
                                                            readonly props: Readonly<import('./types').MessageProps> &
                                                            Readonly<{ children?: import('react').ReactNode }>;
                                                            refs: { [key: string]: any };
                                                            componentDidMount?(): void;
                                                            shouldComponentUpdate?(
                                                            nextProps: Readonly<import('./types').MessageProps>,
                                                            nextState: Readonly<{}>,
                                                            nextContext: any
                                                            ): boolean;
                                                            componentWillUnmount?(): void;
                                                            componentDidCatch?(error: Error, errorInfo: any): void;
                                                            getSnapshotBeforeUpdate?(
                                                            prevProps: Readonly<import('./types').MessageProps>,
                                                            prevState: Readonly<{}>
                                                            ): any;
                                                            componentDidUpdate?(
                                                            prevProps: Readonly<import('./types').MessageProps>,
                                                            prevState: Readonly<{}>,
                                                            snapshot?: any
                                                            ): void;
                                                            componentWillMount?(): void;
                                                            UNSAFE_componentWillMount?(): void;
                                                            componentWillReceiveProps?(
                                                            nextProps: Readonly<import('./types').MessageProps>,
                                                            nextContext: any
                                                            ): void;
                                                            UNSAFE_componentWillReceiveProps?(
                                                            nextProps: Readonly<import('./types').MessageProps>,
                                                            nextContext: any
                                                            ): void;
                                                            componentWillUpdate?(
                                                            nextProps: Readonly<import('./types').MessageProps>,
                                                            nextState: Readonly<{}>,
                                                            nextContext: any
                                                            ): void;
                                                            UNSAFE_componentWillUpdate?(
                                                            nextProps: Readonly<import('./types').MessageProps>,
                                                            nextState: Readonly<{}>,
                                                            nextContext: any
                                                            ): void;
                                                            }
                                                            >,
                                                            {}
                                                            > & {
                                                            help: (config: import('./types').OpenProps) => void;
                                                            hide: () => void;
                                                            show: (config: import('./types').OpenProps) => void;
                                                            open: (config: import('./types').OpenProps) => {
                                                            key: string;
                                                            close: () => void;
                                                            };
                                                            close: (key?: string | undefined) => void;
                                                            warning: (config: import('./types').OpenProps) => void;
                                                            error: (config: import('./types').OpenProps) => void;
                                                            config: (
                                                            config: Partial<{ top: number; maxCount: number; duration: number }>
                                                            ) => void;
                                                            loading: (config: import('./types').OpenProps) => void;
                                                            success: (config: import('./types').OpenProps) => void;
                                                            notice: (config: import('./types').OpenProps) => void;
                                                            destory: () => void;
                                                            withContext: <P extends WithContextMessageProps, C>(
                                                            WrappedComponent: any
                                                            ) => (props: JSX.LibraryManagedAttributes<C, Omit<P, 'contextMessage'>>) => any;
                                                            };
                                                              const Nav: ConfiguredComponentClass<
                                                              NavProps & ComponentCommonProps,
                                                              {
                                                              menu:
                                                              | import('../config-provider/types').ConfiguredComponent<
                                                              import('../menu').MenuProps &
                                                              import('../config-provider/types').ComponentCommonProps,
                                                              import('../menu/view/menu').Menu
                                                              >
                                                              | null;
                                                              getChildContext(): {
                                                              prefix: string | undefined;
                                                              mode: 'inline' | 'popup' | undefined;
                                                              iconOnly: any;
                                                              iconOnlyWidth: string | number | undefined;
                                                              iconTextOnly: boolean | undefined;
                                                              hasTooltip: boolean | undefined;
                                                              hasArrow: boolean | undefined;
                                                              };
                                                              getMenuRef: any;
                                                              render(): any;
                                                              context: any;
                                                              setState<K extends never>(
                                                              state:
                                                              | {}
                                                              | ((
                                                              prevState: Readonly<{}>,
                                                              props: Readonly<NavProps>
                                                              ) => {} | Pick<{}, K>)
                                                              | Pick<{}, K>,
                                                              callback?: (() => void) | undefined
                                                              ): void;
                                                              forceUpdate(callback?: (() => void) | undefined): void;
                                                              readonly props: Readonly<NavProps> &
                                                              Readonly<{ children?: import('react').ReactNode }>;
                                                              state: Readonly<{}>;
                                                              refs: { [key: string]: any };
                                                              componentDidMount?(): void;
                                                              shouldComponentUpdate?(
                                                              nextProps: Readonly<NavProps>,
                                                              nextState: Readonly<{}>,
                                                              nextContext: any
                                                              ): boolean;
                                                              componentWillUnmount?(): void;
                                                              componentDidCatch?(error: Error, errorInfo: any): void;
                                                              getSnapshotBeforeUpdate?(
                                                              prevProps: Readonly<NavProps>,
                                                              prevState: Readonly<{}>
                                                              ): any;
                                                              componentDidUpdate?(
                                                              prevProps: Readonly<NavProps>,
                                                              prevState: Readonly<{}>,
                                                              snapshot?: any
                                                              ): void;
                                                              componentWillMount?(): void;
                                                              UNSAFE_componentWillMount?(): void;
                                                              componentWillReceiveProps?(
                                                              nextProps: Readonly<NavProps>,
                                                              nextContext: any
                                                              ): void;
                                                              UNSAFE_componentWillReceiveProps?(
                                                              nextProps: Readonly<NavProps>,
                                                              nextContext: any
                                                              ): void;
                                                              componentWillUpdate?(
                                                              nextProps: Readonly<NavProps>,
                                                              nextState: Readonly<{}>,
                                                              nextContext: any
                                                              ): void;
                                                              UNSAFE_componentWillUpdate?(
                                                              nextProps: Readonly<NavProps>,
                                                              nextState: Readonly<{}>,
                                                              nextContext: any
                                                              ): void;
                                                              },
                                                              {}
                                                              > & {
                                                              Item: typeof Item;
                                                              Group: typeof Group;
                                                              SubNav: typeof SubNav;
                                                              PopupItem: typeof PopupItem;
                                                              Divider: typeof import('../menu/view/divider').default;
                                                              };

                                                                variable Notification

                                                                const Notification: INotification;

                                                                  variable NumberPicker

                                                                  const NumberPicker: ConfiguredComponentClass<
                                                                  NumberPickerProps & ComponentCommonProps,
                                                                  {
                                                                  inputRef:
                                                                  | (import('../config-provider/types').ConfiguredComponent<
                                                                  import('../input').InputProps &
                                                                  import('../config-provider/types').ComponentCommonProps,
                                                                  import('../input/input').default<import('../input').InputProps>
                                                                  > &
                                                                  Pick<
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >,
                                                                  'focus' | 'getInputNode'
                                                                  >)
                                                                  | null;
                                                                  isGreaterThan(v1: string | number, v2: string | number): boolean;
                                                                  correctBoundary(value: string | number): string | number;
                                                                  setFocus(status: boolean): void;
                                                                  onFocus: (e: any) => void;
                                                                  onBlur: (e: any) => void;
                                                                  withinMinMax(value: string | number): boolean;
                                                                  withinMin(value: string | number): boolean;
                                                                  setDisplayValue({
                                                                  displayValue,
                                                                  onlyDisplay,
                                                                  }: {
                                                                  displayValue: string | number;
                                                                  onlyDisplay?: boolean | undefined;
                                                                  }): void;
                                                                  getDisplayValue(): string | number;
                                                                  shouldFireOnChange(value: string): boolean;
                                                                  onChange(
                                                                  value: string,
                                                                  e:
                                                                  | import('react').CompositionEvent<HTMLInputElement>
                                                                  | import('react').ChangeEvent<HTMLInputElement>
                                                                  | import('react').KeyboardEvent<HTMLInputElement>
                                                                  ): void;
                                                                  correctValue(value: string): string | number;
                                                                  setValue({
                                                                  value,
                                                                  e,
                                                                  triggerType,
                                                                  }: {
                                                                  value: string | number;
                                                                  e:
                                                                  | import('react').CompositionEvent<HTMLInputElement>
                                                                  | import('react').ChangeEvent<HTMLInputElement>
                                                                  | import('react').KeyboardEvent<HTMLInputElement>;
                                                                  triggerType?: 'down' | 'up' | undefined;
                                                                  }): void;
                                                                  getPrecision(): number;
                                                                  getPrecisionFactor(): number;
                                                                  onKeyDown: (e: any, opts: import('../input').OnKeyDownOpts) => void;
                                                                  up(disabled: boolean, e: any): void;
                                                                  down(disabled: boolean, e: any): void;
                                                                  step(type: 'down' | 'up', disabled: boolean, e: any): void;
                                                                  upStep(val: string | number): string | number;
                                                                  downStep(val: string | number): string | number;
                                                                  hackChrome(value: number): number;
                                                                  focus(): void;
                                                                  saveInputRef(
                                                                  ref:
                                                                  | (import('../config-provider/types').ConfiguredComponent<
                                                                  import('../input').InputProps &
                                                                  import('../config-provider/types').ComponentCommonProps,
                                                                  import('../input/input').default<import('../input').InputProps>
                                                                  > &
                                                                  Pick<
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >,
                                                                  'focus' | 'getInputNode'
                                                                  >)
                                                                  | null
                                                                  ): void;
                                                                  getInputNode():
                                                                  | (import('../config-provider/types').ConfiguredComponent<
                                                                  import('../input').InputProps &
                                                                  import('../config-provider/types').ComponentCommonProps,
                                                                  import('../input/input').default<import('../input').InputProps>
                                                                  > &
                                                                  Pick<
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >,
                                                                  'focus' | 'getInputNode'
                                                                  >)
                                                                  | null;
                                                                  handleMouseDown(e: any): void;
                                                                  render(): any;
                                                                  context: any;
                                                                  setState<K extends keyof NumberPickerState>(
                                                                  state:
                                                                  | NumberPickerState
                                                                  | ((
                                                                  prevState: Readonly<import('./types').NumberPickerState>,
                                                                  props: Readonly<import('./types').NumberPickerProps>
                                                                  ) => NumberPickerState | Pick<NumberPickerState, K>)
                                                                  | Pick<NumberPickerState, K>,
                                                                  callback?: (() => void) | undefined
                                                                  ): void;
                                                                  forceUpdate(callback?: (() => void) | undefined): void;
                                                                  readonly props: Readonly<import('./types').NumberPickerProps> &
                                                                  Readonly<{ children?: import('react').ReactNode }>;
                                                                  state: Readonly<import('./types').NumberPickerState>;
                                                                  refs: { [key: string]: any };
                                                                  componentDidMount?(): void;
                                                                  shouldComponentUpdate?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextState: Readonly<import('./types').NumberPickerState>,
                                                                  nextContext: any
                                                                  ): boolean;
                                                                  componentWillUnmount?(): void;
                                                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                                                  getSnapshotBeforeUpdate?(
                                                                  prevProps: Readonly<import('./types').NumberPickerProps>,
                                                                  prevState: Readonly<import('./types').NumberPickerState>
                                                                  ): any;
                                                                  componentDidUpdate?(
                                                                  prevProps: Readonly<import('./types').NumberPickerProps>,
                                                                  prevState: Readonly<import('./types').NumberPickerState>,
                                                                  snapshot?: any
                                                                  ): void;
                                                                  componentWillMount?(): void;
                                                                  UNSAFE_componentWillMount?(): void;
                                                                  componentWillReceiveProps?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  UNSAFE_componentWillReceiveProps?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  componentWillUpdate?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextState: Readonly<import('./types').NumberPickerState>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  UNSAFE_componentWillUpdate?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextState: Readonly<import('./types').NumberPickerState>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  },
                                                                  Pick<
                                                                  {
                                                                  inputRef:
                                                                  | (import('../config-provider/types').ConfiguredComponent<
                                                                  import('../input').InputProps &
                                                                  import('../config-provider/types').ComponentCommonProps,
                                                                  import('../input/input').default<import('../input').InputProps>
                                                                  > &
                                                                  Pick<
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >,
                                                                  'focus' | 'getInputNode'
                                                                  >)
                                                                  | null;
                                                                  isGreaterThan(v1: string | number, v2: string | number): boolean;
                                                                  correctBoundary(value: string | number): string | number;
                                                                  setFocus(status: boolean): void;
                                                                  onFocus: (e: any) => void;
                                                                  onBlur: (e: any) => void;
                                                                  withinMinMax(value: string | number): boolean;
                                                                  withinMin(value: string | number): boolean;
                                                                  setDisplayValue({
                                                                  displayValue,
                                                                  onlyDisplay,
                                                                  }: {
                                                                  displayValue: string | number;
                                                                  onlyDisplay?: boolean | undefined;
                                                                  }): void;
                                                                  getDisplayValue(): string | number;
                                                                  shouldFireOnChange(value: string): boolean;
                                                                  onChange(
                                                                  value: string,
                                                                  e:
                                                                  | import('react').CompositionEvent<HTMLInputElement>
                                                                  | import('react').ChangeEvent<HTMLInputElement>
                                                                  | import('react').KeyboardEvent<HTMLInputElement>
                                                                  ): void;
                                                                  correctValue(value: string): string | number;
                                                                  setValue({
                                                                  value,
                                                                  e,
                                                                  triggerType,
                                                                  }: {
                                                                  value: string | number;
                                                                  e:
                                                                  | import('react').CompositionEvent<HTMLInputElement>
                                                                  | import('react').ChangeEvent<HTMLInputElement>
                                                                  | import('react').KeyboardEvent<HTMLInputElement>;
                                                                  triggerType?: 'down' | 'up' | undefined;
                                                                  }): void;
                                                                  getPrecision(): number;
                                                                  getPrecisionFactor(): number;
                                                                  onKeyDown: (e: any, opts: import('../input').OnKeyDownOpts) => void;
                                                                  up(disabled: boolean, e: any): void;
                                                                  down(disabled: boolean, e: any): void;
                                                                  step(type: 'down' | 'up', disabled: boolean, e: any): void;
                                                                  upStep(val: string | number): string | number;
                                                                  downStep(val: string | number): string | number;
                                                                  hackChrome(value: number): number;
                                                                  focus(): void;
                                                                  saveInputRef(
                                                                  ref:
                                                                  | (import('../config-provider/types').ConfiguredComponent<
                                                                  import('../input').InputProps &
                                                                  import('../config-provider/types').ComponentCommonProps,
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >
                                                                  > &
                                                                  Pick<
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >,
                                                                  'focus' | 'getInputNode'
                                                                  >)
                                                                  | null
                                                                  ): void;
                                                                  getInputNode():
                                                                  | (import('../config-provider/types').ConfiguredComponent<
                                                                  import('../input').InputProps &
                                                                  import('../config-provider/types').ComponentCommonProps,
                                                                  import('../input/input').default<import('../input').InputProps>
                                                                  > &
                                                                  Pick<
                                                                  import('../input/input').default<
                                                                  import('../input').InputProps
                                                                  >,
                                                                  'focus' | 'getInputNode'
                                                                  >)
                                                                  | null;
                                                                  handleMouseDown(e: any): void;
                                                                  render(): any;
                                                                  context: any;
                                                                  setState<K extends keyof NumberPickerState>(
                                                                  state:
                                                                  | NumberPickerState
                                                                  | ((
                                                                  prevState: Readonly<import('./types').NumberPickerState>,
                                                                  props: Readonly<import('./types').NumberPickerProps>
                                                                  ) => NumberPickerState | Pick<NumberPickerState, K>)
                                                                  | Pick<NumberPickerState, K>,
                                                                  callback?: (() => void) | undefined
                                                                  ): void;
                                                                  forceUpdate(callback?: (() => void) | undefined): void;
                                                                  readonly props: Readonly<import('./types').NumberPickerProps> &
                                                                  Readonly<{ children?: import('react').ReactNode }>;
                                                                  state: Readonly<import('./types').NumberPickerState>;
                                                                  refs: { [key: string]: any };
                                                                  componentDidMount?(): void;
                                                                  shouldComponentUpdate?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextState: Readonly<import('./types').NumberPickerState>,
                                                                  nextContext: any
                                                                  ): boolean;
                                                                  componentWillUnmount?(): void;
                                                                  componentDidCatch?(error: Error, errorInfo: any): void;
                                                                  getSnapshotBeforeUpdate?(
                                                                  prevProps: Readonly<import('./types').NumberPickerProps>,
                                                                  prevState: Readonly<import('./types').NumberPickerState>
                                                                  ): any;
                                                                  componentDidUpdate?(
                                                                  prevProps: Readonly<import('./types').NumberPickerProps>,
                                                                  prevState: Readonly<import('./types').NumberPickerState>,
                                                                  snapshot?: any
                                                                  ): void;
                                                                  componentWillMount?(): void;
                                                                  UNSAFE_componentWillMount?(): void;
                                                                  componentWillReceiveProps?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  UNSAFE_componentWillReceiveProps?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  componentWillUpdate?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextState: Readonly<import('./types').NumberPickerState>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  UNSAFE_componentWillUpdate?(
                                                                  nextProps: Readonly<import('./types').NumberPickerProps>,
                                                                  nextState: Readonly<import('./types').NumberPickerState>,
                                                                  nextContext: any
                                                                  ): void;
                                                                  },
                                                                  'getInputNode'
                                                                  >
                                                                  >;

                                                                    variable Overlay

                                                                    const Overlay: ConfiguredComponentClass<
                                                                    OverlayProps & ComponentCommonProps,
                                                                    Overlay,
                                                                    Pick<Overlay, 'getContent' | 'getContentNode'>
                                                                    > & {
                                                                    Popup: import('../config-provider/types').ConfiguredComponentClass<
                                                                    PopupProps & import('../config-provider/types').ComponentCommonProps,
                                                                    Popup,
                                                                    Pick<Popup, 'overlay'>
                                                                    >;
                                                                    Gateway: {
                                                                    new (props: GatewayProps): {
                                                                    child: Element | null | undefined;
                                                                    componentDidMount(): void;
                                                                    componentDidUpdate(): void;
                                                                    updateContainer: () => void;
                                                                    getChildNode(): Element | Text | null;
                                                                    saveChildRef: (ref: HTMLDivElement) => void;
                                                                    render(): React.ReactPortal | null;
                                                                    context: any;
                                                                    setState<K extends 'containerNode'>(
                                                                    state:
                                                                    | GatewayState
                                                                    | ((
                                                                    prevState: Readonly<import('./types').GatewayState>,
                                                                    props: Readonly<GatewayProps>
                                                                    ) => GatewayState | Pick<GatewayState, K>)
                                                                    | Pick<GatewayState, K>,
                                                                    callback?: (() => void) | undefined
                                                                    ): void;
                                                                    forceUpdate(callback?: (() => void) | undefined): void;
                                                                    readonly props: Readonly<GatewayProps> &
                                                                    Readonly<{ children?: React.ReactNode }>;
                                                                    state: Readonly<import('./types').GatewayState>;
                                                                    refs: { [key: string]: React.ReactInstance };
                                                                    shouldComponentUpdate?(
                                                                    nextProps: Readonly<GatewayProps>,
                                                                    nextState: Readonly<import('./types').GatewayState>,
                                                                    nextContext: any
                                                                    ): boolean;
                                                                    componentWillUnmount?(): void;
                                                                    componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
                                                                    getSnapshotBeforeUpdate?(
                                                                    prevProps: Readonly<GatewayProps>,
                                                                    prevState: Readonly<import('./types').GatewayState>
                                                                    ): any;
                                                                    componentWillMount?(): void;
                                                                    UNSAFE_componentWillMount?(): void;
                                                                    componentWillReceiveProps?(
                                                                    nextProps: Readonly<GatewayProps>,
                                                                    nextContext: any
                                                                    ): void;
                                                                    UNSAFE_componentWillReceiveProps?(
                                                                    nextProps: Readonly<GatewayProps>,
                                                                    nextContext: any
                                                                    ): void;
                                                                    componentWillUpdate?(
                                                                    nextProps: Readonly<GatewayProps>,
                                                                    nextState: Readonly<import('./types').GatewayState>,
                                                                    nextContext: any
                                                                    ): void;
                                                                    UNSAFE_componentWillUpdate?(
                                                                    nextProps: Readonly<GatewayProps>,
                                                                    nextState: Readonly<import('./types').GatewayState>,
                                                                    nextContext: any
                                                                    ): void;
                                                                    };
                                                                    displayName: string;
                                                                    propTypes: {
                                                                    children: import('prop-types').Requireable<
                                                                    import('prop-types').ReactNodeLike
                                                                    >;
                                                                    container: import('prop-types').Requireable<any>;
                                                                    target: import('prop-types').Requireable<any>;
                                                                    };
                                                                    defaultProps: { container: () => HTMLElement };
                                                                    contextType?: React.Context<any> | undefined;
                                                                    };
                                                                    Position: typeof Position;
                                                                    };

                                                                      variable Pagination

                                                                      const Pagination: ConfiguredComponentClass<
                                                                      PaginationProps & ComponentCommonProps,
                                                                      Pagination,
                                                                      {}
                                                                      >;

                                                                        variable Paragraph

                                                                        const Paragraph: ConfiguredComponentClass<
                                                                        ParagraphProps & ComponentCommonProps,
                                                                        Paragraph,
                                                                        {}
                                                                        >;

                                                                          variable Progress

                                                                          const Progress: ConfiguredComponentClass<
                                                                          ProgressProps & ComponentCommonProps,
                                                                          Progress,
                                                                          {}
                                                                          >;

                                                                            variable Radio

                                                                            const Radio: ConfiguredComponentClass<
                                                                            RadioProps & ComponentCommonProps,
                                                                            WrappedRadio,
                                                                            {}
                                                                            > & {
                                                                            Group: import('../config-provider/types').ConfiguredComponentClass<
                                                                            import('./types').GroupProps &
                                                                            import('../config-provider/types').ComponentCommonProps,
                                                                            import('./radio-group').RadioGroup,
                                                                            {}
                                                                            >;
                                                                            };

                                                                              variable Range

                                                                              const Range: ConfiguredComponentClass<
                                                                              RangeProps & ComponentCommonProps,
                                                                              {
                                                                              _moving: {
                                                                              start: number;
                                                                              end: number;
                                                                              startValue: import('./types').RangeValueType | undefined;
                                                                              dragging?: 'lower' | 'upper' | undefined;
                                                                              } | null;
                                                                              dom: HTMLDivElement;
                                                                              isFixedWidth: boolean;
                                                                              lastPosition: number;
                                                                              oldDragging?: 'lower' | 'upper' | undefined;
                                                                              _onMouseMoveListener: { off: () => void } | null;
                                                                              _onMouseUpListener: { off: () => void } | null;
                                                                              _onContextMenuListener: { off: () => void } | null;
                                                                              _onTouchMoveListener: { off: () => void } | null;
                                                                              _onTouchEndListener: { off: () => void } | null;
                                                                              readonly props: Readonly<
                                                                              RequiredSome<
                                                                              RangeProps,
                                                                              | 'onChange'
                                                                              | 'prefix'
                                                                              | 'pure'
                                                                              | 'rtl'
                                                                              | 'disabled'
                                                                              | 'isPreview'
                                                                              | 'min'
                                                                              | 'max'
                                                                              | 'reverse'
                                                                              | 'slider'
                                                                              | 'step'
                                                                              | 'fixedWidth'
                                                                              | 'marks'
                                                                              | 'marksPosition'
                                                                              | 'onProcess'
                                                                              | 'hasTip'
                                                                              | 'tipRender'
                                                                              | 'tooltipVisible'
                                                                              >
                                                                              > &
                                                                              Readonly<
                                                                              Pick<
                                                                              {
                                                                              prefix: string;
                                                                              slider: string;
                                                                              min: number;
                                                                              max: number;
                                                                              step: number;
                                                                              marks: boolean;
                                                                              disabled: boolean;
                                                                              fixedWidth: boolean;
                                                                              tooltipVisible: boolean;
                                                                              hasTip: boolean;
                                                                              onChange: () => void;
                                                                              onProcess: () => void;
                                                                              tipRender: (
                                                                              value: import('./types').RangeValueType
                                                                              ) => import('./types').RangeValueType;
                                                                              reverse: boolean;
                                                                              pure: boolean;
                                                                              marksPosition: string;
                                                                              rtl: boolean;
                                                                              isPreview: boolean;
                                                                              },
                                                                              never
                                                                              >
                                                                              >;
                                                                              _marksToScales(
                                                                              marks: number | false | number[] | Record<number, string>
                                                                              ): number | false | number[];
                                                                              _calcScales(): number[];
                                                                              _calcMarks(): Record<number, string>;
                                                                              _onMouseDown(e: any): void;
                                                                              _onTouchStart(e: any): void;
                                                                              onKeyDown(e: any): void;
                                                                              _onContextMenu(e: any): void;
                                                                              _start(position: number): void;
                                                                              _end(): void;
                                                                              _move(
                                                                              e:
                                                                              | import('react').MouseEvent<Element, MouseEvent>
                                                                              | import('react').TouchEvent<Element>
                                                                              ): void;
                                                                              _onProcess(position: number, start?: boolean | undefined): void;
                                                                              _addDocumentMouseEvents(): void;
                                                                              _addDocumentTouchEvents(): void;
                                                                              _removeDocumentEvents(): void;
                                                                              _positionToCurrent(position: number): number;
                                                                              _currentToValue(
                                                                              current: number,
                                                                              preValue: number | [number, number],
                                                                              lastPosition: number,
                                                                              isFixedWidth: boolean
                                                                              ): import('./types').RangeValueType | undefined;
                                                                              handleLowerTooltipVisibleChange(visible: boolean): void;
                                                                              handleUpperTooltipVisibleChange(visible: boolean): void;
                                                                              render(): any;
                                                                              context: any;
                                                                              setState<K extends keyof RangeState>(
                                                                              state:
                                                                              | RangeState
                                                                              | ((
                                                                              prevState: Readonly<import('./types').RangeState>,
                                                                              props: Readonly<import('./types').RangeProps>
                                                                              ) => RangeState | Pick<RangeState, K>)
                                                                              | Pick<RangeState, K>,
                                                                              callback?: (() => void) | undefined
                                                                              ): void;
                                                                              forceUpdate(callback?: (() => void) | undefined): void;
                                                                              state: Readonly<import('./types').RangeState>;
                                                                              refs: { [key: string]: any };
                                                                              componentDidMount?(): void;
                                                                              shouldComponentUpdate?(
                                                                              nextProps: Readonly<import('./types').RangeProps>,
                                                                              nextState: Readonly<import('./types').RangeState>,
                                                                              nextContext: any
                                                                              ): boolean;
                                                                              componentWillUnmount?(): void;
                                                                              componentDidCatch?(error: Error, errorInfo: any): void;
                                                                              getSnapshotBeforeUpdate?(
                                                                              prevProps: Readonly<import('./types').RangeProps>,
                                                                              prevState: Readonly<import('./types').RangeState>
                                                                              ): any;
                                                                              componentDidUpdate?(
                                                                              prevProps: Readonly<import('./types').RangeProps>,
                                                                              prevState: Readonly<import('./types').RangeState>,
                                                                              snapshot?: any
                                                                              ): void;
                                                                              componentWillMount?(): void;
                                                                              UNSAFE_componentWillMount?(): void;
                                                                              componentWillReceiveProps?(
                                                                              nextProps: Readonly<import('./types').RangeProps>,
                                                                              nextContext: any
                                                                              ): void;
                                                                              UNSAFE_componentWillReceiveProps?(
                                                                              nextProps: Readonly<import('./types').RangeProps>,
                                                                              nextContext: any
                                                                              ): void;
                                                                              componentWillUpdate?(
                                                                              nextProps: Readonly<import('./types').RangeProps>,
                                                                              nextState: Readonly<import('./types').RangeState>,
                                                                              nextContext: any
                                                                              ): void;
                                                                              UNSAFE_componentWillUpdate?(
                                                                              nextProps: Readonly<import('./types').RangeProps>,
                                                                              nextState: Readonly<import('./types').RangeState>,
                                                                              nextContext: any
                                                                              ): void;
                                                                              },
                                                                              {}
                                                                              >;

                                                                                variable Rating

                                                                                const Rating: ConfiguredComponentClass<
                                                                                RatingProps & ComponentCommonProps,
                                                                                {
                                                                                [key: `refs-rating-icon-${number}`]: HTMLSpanElement;
                                                                                timer: NodeJS.Timeout | null;
                                                                                underlayNode: HTMLDivElement | null;
                                                                                readonly props: ClassPropsWithDefault<
                                                                                RatingProps,
                                                                                {
                                                                                prefix: string;
                                                                                size: string;
                                                                                disabled: boolean;
                                                                                readOnly: boolean;
                                                                                isPreview: boolean;
                                                                                count: number;
                                                                                showGrade: boolean;
                                                                                defaultValue: number;
                                                                                readAs: (val: number) => number;
                                                                                allowHalf: boolean;
                                                                                allowClear: boolean;
                                                                                onChange: () => void;
                                                                                onHoverChange: () => void;
                                                                                locale: Partial<{ description: string }> & {
                                                                                momentLocale?: string | undefined;
                                                                                };
                                                                                }
                                                                                >;
                                                                                componentDidMount(): void;
                                                                                componentWillUnmount(): void;
                                                                                clearTimer(): void;
                                                                                getRenderResult(): void;
                                                                                getValue(e: any): number;
                                                                                handleHover(e: any): void;
                                                                                handleLeave(): void;
                                                                                onKeyDown(e: any): true | void;
                                                                                handleChecked(index: number): void;
                                                                                handleClick(e: any): void;
                                                                                getOverlayWidth(): number | 'auto';
                                                                                getInfoLeft(): number;
                                                                                saveRef: (ref: HTMLSpanElement | null, i: number) => void;
                                                                                render(): any;
                                                                                context: any;
                                                                                setState<K extends keyof RatingState>(
                                                                                state:
                                                                                | RatingState
                                                                                | ((
                                                                                prevState: Readonly<import('./types').RatingState>,
                                                                                props: Readonly<import('./types').RatingProps>
                                                                                ) => RatingState | Pick<RatingState, K>)
                                                                                | Pick<RatingState, K>,
                                                                                callback?: (() => void) | undefined
                                                                                ): void;
                                                                                forceUpdate(callback?: (() => void) | undefined): void;
                                                                                state: Readonly<import('./types').RatingState>;
                                                                                refs: { [key: string]: any };
                                                                                shouldComponentUpdate?(
                                                                                nextProps: Readonly<import('./types').RatingProps>,
                                                                                nextState: Readonly<import('./types').RatingState>,
                                                                                nextContext: any
                                                                                ): boolean;
                                                                                componentDidCatch?(error: Error, errorInfo: any): void;
                                                                                getSnapshotBeforeUpdate?(
                                                                                prevProps: Readonly<import('./types').RatingProps>,
                                                                                prevState: Readonly<import('./types').RatingState>
                                                                                ): any;
                                                                                componentDidUpdate?(
                                                                                prevProps: Readonly<import('./types').RatingProps>,
                                                                                prevState: Readonly<import('./types').RatingState>,
                                                                                snapshot?: any
                                                                                ): void;
                                                                                componentWillMount?(): void;
                                                                                UNSAFE_componentWillMount?(): void;
                                                                                componentWillReceiveProps?(
                                                                                nextProps: Readonly<import('./types').RatingProps>,
                                                                                nextContext: any
                                                                                ): void;
                                                                                UNSAFE_componentWillReceiveProps?(
                                                                                nextProps: Readonly<import('./types').RatingProps>,
                                                                                nextContext: any
                                                                                ): void;
                                                                                componentWillUpdate?(
                                                                                nextProps: Readonly<import('./types').RatingProps>,
                                                                                nextState: Readonly<import('./types').RatingState>,
                                                                                nextContext: any
                                                                                ): void;
                                                                                UNSAFE_componentWillUpdate?(
                                                                                nextProps: Readonly<import('./types').RatingProps>,
                                                                                nextState: Readonly<import('./types').RatingState>,
                                                                                nextContext: any
                                                                                ): void;
                                                                                },
                                                                                {}
                                                                                > & {
                                                                                currentValue: (
                                                                                min: number,
                                                                                max: number,
                                                                                hoverValue: number,
                                                                                stateValue: number
                                                                                ) => number;
                                                                                };

                                                                                  variable ResponsiveGrid

                                                                                  const ResponsiveGrid: ConfiguredComponentClass<
                                                                                  ResponsiveGridProps & ComponentCommonProps,
                                                                                  ResponsiveGrid,
                                                                                  {}
                                                                                  > & {
                                                                                  _typeMark: string;
                                                                                  Cell: ConfiguredComponentClass<
                                                                                  CellProps & ComponentCommonProps,
                                                                                  {
                                                                                  render(): React.JSX.Element;
                                                                                  context: any;
                                                                                  setState<K extends never>(
                                                                                  state:
                                                                                  | {}
                                                                                  | ((
                                                                                  prevState: Readonly<{}>,
                                                                                  props: Readonly<CellProps>
                                                                                  ) => {} | Pick<{}, K>)
                                                                                  | Pick<{}, K>,
                                                                                  callback?: (() => void) | undefined
                                                                                  ): void;
                                                                                  forceUpdate(callback?: (() => void) | undefined): void;
                                                                                  readonly props: Readonly<CellProps> &
                                                                                  Readonly<{ children?: React.ReactNode }>;
                                                                                  state: Readonly<{}>;
                                                                                  refs: { [key: string]: React.ReactInstance };
                                                                                  componentDidMount?(): void;
                                                                                  shouldComponentUpdate?(
                                                                                  nextProps: Readonly<CellProps>,
                                                                                  nextState: Readonly<{}>,
                                                                                  nextContext: any
                                                                                  ): boolean;
                                                                                  componentWillUnmount?(): void;
                                                                                  componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
                                                                                  getSnapshotBeforeUpdate?(
                                                                                  prevProps: Readonly<CellProps>,
                                                                                  prevState: Readonly<{}>
                                                                                  ): any;
                                                                                  componentDidUpdate?(
                                                                                  prevProps: Readonly<CellProps>,
                                                                                  prevState: Readonly<{}>,
                                                                                  snapshot?: any
                                                                                  ): void;
                                                                                  componentWillMount?(): void;
                                                                                  UNSAFE_componentWillMount?(): void;
                                                                                  componentWillReceiveProps?(
                                                                                  nextProps: Readonly<CellProps>,
                                                                                  nextContext: any
                                                                                  ): void;
                                                                                  UNSAFE_componentWillReceiveProps?(
                                                                                  nextProps: Readonly<CellProps>,
                                                                                  nextContext: any
                                                                                  ): void;
                                                                                  componentWillUpdate?(
                                                                                  nextProps: Readonly<CellProps>,
                                                                                  nextState: Readonly<{}>,
                                                                                  nextContext: any
                                                                                  ): void;
                                                                                  UNSAFE_componentWillUpdate?(
                                                                                  nextProps: Readonly<CellProps>,
                                                                                  nextState: Readonly<{}>,
                                                                                  nextContext: any
                                                                                  ): void;
                                                                                  },
                                                                                  {}
                                                                                  > & { _typeMark: string };
                                                                                  };
                                                                                    const Search: ConfiguredComponentClass<
                                                                                    SearchProps & ComponentCommonProps,
                                                                                    {
                                                                                    highlightKey: unknown;
                                                                                    inputRef: {
                                                                                    isInputing: boolean;
                                                                                    componentDidUpdate(
                                                                                    prevProps: import('../select').AutoCompleteProps
                                                                                    ): void;
                                                                                    shouldControlPopup(
                                                                                    props:
                                                                                    | (Readonly<import('../select').AutoCompleteProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>)
                                                                                    | undefined,
                                                                                    type: import('../select').VisibleChangeType
                                                                                    ): void;
                                                                                    handleMenuSelect(keys: string[]): void;
                                                                                    handleItemClick(): void;
                                                                                    handleSelectEvent(
                                                                                    key: string,
                                                                                    item: import('../select').ObjectItem,
                                                                                    triggerType: import('../select').VisibleChangeType
                                                                                    ): void;
                                                                                    handleChange: (
                                                                                    value: string,
                                                                                    proxy:
                                                                                    | import('../select').VisibleChangeType
                                                                                    | import('react').ChangeEvent<HTMLElement>,
                                                                                    item?: import('../select').ObjectItem | undefined
                                                                                    ) => false | undefined;
                                                                                    handleVisibleChange(
                                                                                    visible: boolean,
                                                                                    type: import('../select').VisibleChangeType
                                                                                    ): void;
                                                                                    beforeClose(): void;
                                                                                    handleTriggerKeyDown(e: any): void;
                                                                                    chooseHighlightItem(): false | undefined;
                                                                                    hasClear(): boolean | '' | undefined;
                                                                                    renderSelect(
                                                                                    props?: Readonly<import('../select').AutoCompleteProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>
                                                                                    ): any;
                                                                                    render(): any;
                                                                                    dataStore: import('../select/data-store').default;
                                                                                    selectDOM: HTMLElement;
                                                                                    width: string | number;
                                                                                    popupRef: HTMLDivElement;
                                                                                    resizeTimeout: number;
                                                                                    highlightTimer: number | undefined;
                                                                                    menuRef:
                                                                                    | import('../config-provider/types').ConfiguredComponent<
                                                                                    import('../menu').MenuProps &
                                                                                    import('../config-provider/types').ComponentCommonProps,
                                                                                    import('../menu/view/menu').Menu
                                                                                    >
                                                                                    | null;
                                                                                    isAutoComplete: boolean;
                                                                                    inputRef: import('../input/input').default<
                                                                                    import('../input').InputProps
                                                                                    >;
                                                                                    valueDataSource: {
                                                                                    value?:
                                                                                    | string
                                                                                    | number
                                                                                    | boolean
                                                                                    | (string | number | boolean | null | undefined)[]
                                                                                    | null
                                                                                    | undefined;
                                                                                    valueDS?:
                                                                                    | import('../select').ObjectItem
                                                                                    | import('../select').ObjectItem[]
                                                                                    | undefined;
                                                                                    mapValueDS?:
                                                                                    | Record<string, import('../select').ObjectItem>
                                                                                    | undefined;
                                                                                    };
                                                                                    componentDidMount(): void;
                                                                                    componentWillUnmount(): void;
                                                                                    syncWidth(): void;
                                                                                    handleResize(): void;
                                                                                    setDataSource(
                                                                                    props: import('../select').AutoCompleteProps
                                                                                    ): import('../select/types').NormalizedObjectItem[];
                                                                                    setVisible(
                                                                                    visible: boolean,
                                                                                    type?: import('../select').VisibleChangeType | undefined
                                                                                    ): void;
                                                                                    setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                                                                                    handleMenuBodyClick(): void;
                                                                                    toggleHighlightItem(
                                                                                    dir: number
                                                                                    ): false | import('../select/types').NormalizedObjectItem | undefined;
                                                                                    scrollMenuIntoView(): void;
                                                                                    renderMenuHeader(): any;
                                                                                    handleSelect(): void;
                                                                                    handleMouseDown: (e: any) => void;
                                                                                    useDetailValue(): boolean;
                                                                                    renderMenu(): any;
                                                                                    renderMenuItem(
                                                                                    dataSource: import('../select/types').NormalizedObjectItem[]
                                                                                    ): import('react').ReactElement<
                                                                                    any,
                                                                                    string | import('react').JSXElementConstructor<any>
                                                                                    >[];
                                                                                    saveSelectRef: (ref: HTMLElement | null) => void;
                                                                                    saveInputRef: (
                                                                                    ref: import('../config-provider/types').ConfiguredComponent<
                                                                                    import('../input').InputProps &
                                                                                    import('../config-provider/types').ComponentCommonProps,
                                                                                    import('../input/input').default<import('../input').InputProps>
                                                                                    > &
                                                                                    Pick<
                                                                                    import('../input/input').default<
                                                                                    import('../input').InputProps
                                                                                    >,
                                                                                    'focus' | 'getInputNode'
                                                                                    >
                                                                                    ) => void;
                                                                                    focusInput(): void;
                                                                                    focus(
                                                                                    start?: number | undefined,
                                                                                    end?: number | undefined,
                                                                                    preventScroll?: boolean
                                                                                    ): void;
                                                                                    beforeOpen(): void;
                                                                                    afterClose(): void;
                                                                                    savePopupRef: (ref: HTMLDivElement) => void;
                                                                                    shouldAutoWidth(): boolean | undefined;
                                                                                    context: any;
                                                                                    setState<K extends keyof AutoCompleteState>(
                                                                                    state:
                                                                                    | AutoCompleteState
                                                                                    | ((
                                                                                    prevState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    props: Readonly<import('../select').AutoCompleteProps>
                                                                                    ) => AutoCompleteState | Pick<AutoCompleteState, K>)
                                                                                    | Pick<AutoCompleteState, K>,
                                                                                    callback?: (() => void) | undefined
                                                                                    ): void;
                                                                                    forceUpdate(callback?: (() => void) | undefined): void;
                                                                                    readonly props: Readonly<import('../select').AutoCompleteProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>;
                                                                                    state: Readonly<import('../select/auto-complete').AutoCompleteState>;
                                                                                    refs: { [key: string]: any };
                                                                                    shouldComponentUpdate?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    nextContext: any
                                                                                    ): boolean;
                                                                                    componentDidCatch?(error: Error, errorInfo: any): void;
                                                                                    getSnapshotBeforeUpdate?(
                                                                                    prevProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    prevState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >
                                                                                    ): any;
                                                                                    componentWillMount?(): void;
                                                                                    UNSAFE_componentWillMount?(): void;
                                                                                    componentWillReceiveProps?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    UNSAFE_componentWillReceiveProps?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    componentWillUpdate?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    UNSAFE_componentWillUpdate?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    };
                                                                                    onChange: (
                                                                                    value: string,
                                                                                    actionType: string,
                                                                                    item?: import('../select').ObjectItem | undefined
                                                                                    ) => void;
                                                                                    onPressEnter: () => void;
                                                                                    onSearch: () => void;
                                                                                    onFilterChange: (filterValue: string) => void;
                                                                                    onToggleHighlightItem: (
                                                                                    highlightKey?:
                                                                                    | string
                                                                                    | boolean
                                                                                    | import('../select/types').NormalizedObjectItem
                                                                                    | null
                                                                                    | undefined,
                                                                                    type?: import('../select/types').HighlightChangeType | undefined
                                                                                    ) => void;
                                                                                    onKeyDown: (e: any) => void;
                                                                                    saveInputRef: (
                                                                                    ref: ConfiguredComponent<
                                                                                    AutoCompleteProps & ComponentCommonProps,
                                                                                    {
                                                                                    isInputing: boolean;
                                                                                    componentDidUpdate(
                                                                                    prevProps: import('../select').AutoCompleteProps
                                                                                    ): void;
                                                                                    shouldControlPopup(
                                                                                    props:
                                                                                    | (Readonly<import('../select').AutoCompleteProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>)
                                                                                    | undefined,
                                                                                    type: import('../select').VisibleChangeType
                                                                                    ): void;
                                                                                    handleMenuSelect(keys: string[]): void;
                                                                                    handleItemClick(): void;
                                                                                    handleSelectEvent(
                                                                                    key: string,
                                                                                    item: import('../select').ObjectItem,
                                                                                    triggerType: import('../select').VisibleChangeType
                                                                                    ): void;
                                                                                    handleChange: (
                                                                                    value: string,
                                                                                    proxy:
                                                                                    | import('../select').VisibleChangeType
                                                                                    | import('react').ChangeEvent<HTMLElement>,
                                                                                    item?: import('../select').ObjectItem | undefined
                                                                                    ) => false | undefined;
                                                                                    handleVisibleChange(
                                                                                    visible: boolean,
                                                                                    type: import('../select').VisibleChangeType
                                                                                    ): void;
                                                                                    beforeClose(): void;
                                                                                    handleTriggerKeyDown(e: any): void;
                                                                                    chooseHighlightItem(): false | undefined;
                                                                                    hasClear(): boolean | '' | undefined;
                                                                                    renderSelect(
                                                                                    props?: Readonly<import('../select').AutoCompleteProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>
                                                                                    ): any;
                                                                                    render(): any;
                                                                                    dataStore: import('../select/data-store').default;
                                                                                    selectDOM: HTMLElement;
                                                                                    width: string | number;
                                                                                    popupRef: HTMLDivElement;
                                                                                    resizeTimeout: number;
                                                                                    highlightTimer: number | undefined;
                                                                                    menuRef:
                                                                                    | import('../config-provider/types').ConfiguredComponent<
                                                                                    import('../menu').MenuProps &
                                                                                    import('../config-provider/types').ComponentCommonProps,
                                                                                    import('../menu/view/menu').Menu
                                                                                    >
                                                                                    | null;
                                                                                    isAutoComplete: boolean;
                                                                                    inputRef: import('../input/input').default<
                                                                                    import('../input').InputProps
                                                                                    >;
                                                                                    valueDataSource: {
                                                                                    value?:
                                                                                    | string
                                                                                    | number
                                                                                    | boolean
                                                                                    | (string | number | boolean | null | undefined)[]
                                                                                    | null
                                                                                    | undefined;
                                                                                    valueDS?:
                                                                                    | import('../select').ObjectItem
                                                                                    | import('../select').ObjectItem[]
                                                                                    | undefined;
                                                                                    mapValueDS?:
                                                                                    | Record<string, import('../select').ObjectItem>
                                                                                    | undefined;
                                                                                    };
                                                                                    componentDidMount(): void;
                                                                                    componentWillUnmount(): void;
                                                                                    syncWidth(): void;
                                                                                    handleResize(): void;
                                                                                    setDataSource(
                                                                                    props: import('../select').AutoCompleteProps
                                                                                    ): import('../select/types').NormalizedObjectItem[];
                                                                                    setVisible(
                                                                                    visible: boolean,
                                                                                    type?: import('../select').VisibleChangeType | undefined
                                                                                    ): void;
                                                                                    setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                                                                                    handleMenuBodyClick(): void;
                                                                                    toggleHighlightItem(
                                                                                    dir: number
                                                                                    ):
                                                                                    | false
                                                                                    | import('../select/types').NormalizedObjectItem
                                                                                    | undefined;
                                                                                    scrollMenuIntoView(): void;
                                                                                    renderMenuHeader(): any;
                                                                                    handleSelect(): void;
                                                                                    handleMouseDown: (e: any) => void;
                                                                                    useDetailValue(): boolean;
                                                                                    renderMenu(): any;
                                                                                    renderMenuItem(
                                                                                    dataSource: import('../select/types').NormalizedObjectItem[]
                                                                                    ): import('react').ReactElement<
                                                                                    any,
                                                                                    string | import('react').JSXElementConstructor<any>
                                                                                    >[];
                                                                                    saveSelectRef: (ref: HTMLElement | null) => void;
                                                                                    saveInputRef: (
                                                                                    ref: import('../config-provider/types').ConfiguredComponent<
                                                                                    import('../input').InputProps &
                                                                                    import('../config-provider/types').ComponentCommonProps,
                                                                                    import('../input/input').default<
                                                                                    import('../input').InputProps
                                                                                    >
                                                                                    > &
                                                                                    Pick<
                                                                                    import('../input/input').default<
                                                                                    import('../input').InputProps
                                                                                    >,
                                                                                    'focus' | 'getInputNode'
                                                                                    >
                                                                                    ) => void;
                                                                                    focusInput(): void;
                                                                                    focus(
                                                                                    start?: number | undefined,
                                                                                    end?: number | undefined,
                                                                                    preventScroll?: boolean
                                                                                    ): void;
                                                                                    beforeOpen(): void;
                                                                                    afterClose(): void;
                                                                                    savePopupRef: (ref: HTMLDivElement) => void;
                                                                                    shouldAutoWidth(): boolean | undefined;
                                                                                    context: any;
                                                                                    setState<K extends keyof AutoCompleteState>(
                                                                                    state:
                                                                                    | AutoCompleteState
                                                                                    | ((
                                                                                    prevState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    props: Readonly<
                                                                                    import('../select').AutoCompleteProps
                                                                                    >
                                                                                    ) => AutoCompleteState | Pick<AutoCompleteState, K>)
                                                                                    | Pick<AutoCompleteState, K>,
                                                                                    callback?: (() => void) | undefined
                                                                                    ): void;
                                                                                    forceUpdate(callback?: (() => void) | undefined): void;
                                                                                    readonly props: Readonly<import('../select').AutoCompleteProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>;
                                                                                    state: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >;
                                                                                    refs: { [key: string]: any };
                                                                                    shouldComponentUpdate?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    nextContext: any
                                                                                    ): boolean;
                                                                                    componentDidCatch?(error: Error, errorInfo: any): void;
                                                                                    getSnapshotBeforeUpdate?(
                                                                                    prevProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    prevState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >
                                                                                    ): any;
                                                                                    componentWillMount?(): void;
                                                                                    UNSAFE_componentWillMount?(): void;
                                                                                    componentWillReceiveProps?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    UNSAFE_componentWillReceiveProps?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    componentWillUpdate?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    UNSAFE_componentWillUpdate?(
                                                                                    nextProps: Readonly<import('../select').AutoCompleteProps>,
                                                                                    nextState: Readonly<
                                                                                    import('../select/auto-complete').AutoCompleteState
                                                                                    >,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    }
                                                                                    >
                                                                                    ) => void;
                                                                                    focus: (
                                                                                    start?: number | undefined,
                                                                                    end?: number | undefined,
                                                                                    preventScroll?: boolean
                                                                                    ) => void;
                                                                                    handleFocus(args_0: any): void;
                                                                                    handleBlur(args_0: any): void;
                                                                                    render(): any;
                                                                                    context: any;
                                                                                    setState<K_1 extends keyof SearchState>(
                                                                                    state:
                                                                                    | SearchState
                                                                                    | ((
                                                                                    prevState: Readonly<import('./Search').SearchState>,
                                                                                    props: Readonly<import('./types').SearchProps>
                                                                                    ) => SearchState | Pick<SearchState, K_1>)
                                                                                    | Pick<SearchState, K_1>,
                                                                                    callback?: (() => void) | undefined
                                                                                    ): void;
                                                                                    forceUpdate(callback?: (() => void) | undefined): void;
                                                                                    readonly props: Readonly<import('./types').SearchProps> &
                                                                                    Readonly<{ children?: import('react').ReactNode }>;
                                                                                    state: Readonly<import('./Search').SearchState>;
                                                                                    refs: { [key: string]: any };
                                                                                    componentDidMount?(): void;
                                                                                    shouldComponentUpdate?(
                                                                                    nextProps: Readonly<import('./types').SearchProps>,
                                                                                    nextState: Readonly<import('./Search').SearchState>,
                                                                                    nextContext: any
                                                                                    ): boolean;
                                                                                    componentWillUnmount?(): void;
                                                                                    componentDidCatch?(error: Error, errorInfo: any): void;
                                                                                    getSnapshotBeforeUpdate?(
                                                                                    prevProps: Readonly<import('./types').SearchProps>,
                                                                                    prevState: Readonly<import('./Search').SearchState>
                                                                                    ): any;
                                                                                    componentDidUpdate?(
                                                                                    prevProps: Readonly<import('./types').SearchProps>,
                                                                                    prevState: Readonly<import('./Search').SearchState>,
                                                                                    snapshot?: any
                                                                                    ): void;
                                                                                    componentWillMount?(): void;
                                                                                    UNSAFE_componentWillMount?(): void;
                                                                                    componentWillReceiveProps?(
                                                                                    nextProps: Readonly<import('./types').SearchProps>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    UNSAFE_componentWillReceiveProps?(
                                                                                    nextProps: Readonly<import('./types').SearchProps>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    componentWillUpdate?(
                                                                                    nextProps: Readonly<import('./types').SearchProps>,
                                                                                    nextState: Readonly<import('./Search').SearchState>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    UNSAFE_componentWillUpdate?(
                                                                                    nextProps: Readonly<import('./types').SearchProps>,
                                                                                    nextState: Readonly<import('./Search').SearchState>,
                                                                                    nextContext: any
                                                                                    ): void;
                                                                                    },
                                                                                    {}
                                                                                    >;

                                                                                      variable Select

                                                                                      const Select: ConfiguredComponentClass<
                                                                                      SelectProps & ComponentCommonProps,
                                                                                      {
                                                                                      selectAllYet: boolean;
                                                                                      componentDidUpdate(
                                                                                      prevProps: SelectProps,
                                                                                      prevState: import('./base').BaseState
                                                                                      ): void;
                                                                                      componentDidMount(): void;
                                                                                      ie9Hack(): void;
                                                                                      useDetailValue(): boolean;
                                                                                      hasSearch(): boolean;
                                                                                      getTagSize(): 'small' | 'medium' | 'large' | undefined;
                                                                                      handleMenuSelect(
                                                                                      keys: string[],
                                                                                      item: { props: { _key: string } }
                                                                                      ): false | void;
                                                                                      handleItemClick(key: string): void;
                                                                                      handleSingleSelect(
                                                                                      key: string,
                                                                                      triggerType: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      handleMultipleSelect(
                                                                                      keys: import('./types').DataSourceItem[] | undefined,
                                                                                      triggerType: import('./types').VisibleChangeType,
                                                                                      key?: string | null | undefined,
                                                                                      keepSearchValue?: boolean | undefined
                                                                                      ): void;
                                                                                      updateSelectAllYet(value?: unknown): void;
                                                                                      handleSearchValue(value: string): void;
                                                                                      handleSearch(value: string, e: any): void;
                                                                                      handleSearchClear(triggerType?: string | undefined): void;
                                                                                      handleSearchKeyDown(e: any): void;
                                                                                      chooseMultipleItem(key: string): void;
                                                                                      chooseHighlightItem(proxy: unknown, e: any): false | undefined;
                                                                                      handleTagClose(item: import('./types').ObjectItem): boolean;
                                                                                      handleDeleteTag(e: any): false | undefined;
                                                                                      handleSelectAll(e: any): void;
                                                                                      handleVisibleChange(
                                                                                      visible: boolean,
                                                                                      type: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      afterClose(): void;
                                                                                      maxTagPlaceholder(
                                                                                      selectedValues: import('./types').ObjectItem[],
                                                                                      totalValues: import('./types').ObjectItem[]
                                                                                      ): string;
                                                                                      renderValues(): any;
                                                                                      handleWrapClick: (e: any) => void;
                                                                                      handleArrowClick: (e: any) => void;
                                                                                      handleClear: (e: any) => void;
                                                                                      hasClear(): boolean | undefined;
                                                                                      renderExtraNode(): import('react').ReactElement<
                                                                                      any,
                                                                                      string | import('react').JSXElementConstructor<any>
                                                                                      >[];
                                                                                      renderSelect(): any;
                                                                                      renderSearchInput(
                                                                                      valueNodes: any,
                                                                                      placeholder: string | undefined,
                                                                                      inputEl: any
                                                                                      ): any;
                                                                                      renderMenuHeader(): any;
                                                                                      render(): any;
                                                                                      dataStore: import('./data-store').default;
                                                                                      selectDOM: HTMLElement;
                                                                                      width: string | number;
                                                                                      popupRef: HTMLDivElement;
                                                                                      resizeTimeout: number;
                                                                                      highlightTimer: number | undefined;
                                                                                      menuRef:
                                                                                      | import('../config-provider/types').ConfiguredComponent<
                                                                                      import('../menu').MenuProps &
                                                                                      import('../config-provider/types').ComponentCommonProps,
                                                                                      import('../menu/view/menu').Menu
                                                                                      >
                                                                                      | null;
                                                                                      isAutoComplete: boolean;
                                                                                      inputRef: import('../input/input').default<import('../input').InputProps>;
                                                                                      valueDataSource: {
                                                                                      value?:
                                                                                      | string
                                                                                      | number
                                                                                      | boolean
                                                                                      | (string | number | boolean | null | undefined)[]
                                                                                      | null
                                                                                      | undefined;
                                                                                      valueDS?:
                                                                                      | import('./types').ObjectItem
                                                                                      | import('./types').ObjectItem[]
                                                                                      | undefined;
                                                                                      mapValueDS?: Record<string, import('./types').ObjectItem> | undefined;
                                                                                      };
                                                                                      componentWillUnmount(): void;
                                                                                      syncWidth(): void;
                                                                                      handleResize(): void;
                                                                                      setDataSource(props: SelectProps): import('./types').NormalizedObjectItem[];
                                                                                      setVisible(
                                                                                      visible: boolean,
                                                                                      type?: import('./types').VisibleChangeType | undefined
                                                                                      ): void;
                                                                                      setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                                                                                      handleChange(
                                                                                      value:
                                                                                      | import('./types').DataSourceItem
                                                                                      | import('./types').DataSourceItem[],
                                                                                      args_0: unknown,
                                                                                      args_1?:
                                                                                      | import('./types').ObjectItem
                                                                                      | import('./types').ObjectItem[]
                                                                                      | undefined
                                                                                      ): void;
                                                                                      handleMenuBodyClick(): void;
                                                                                      toggleHighlightItem(
                                                                                      dir: number
                                                                                      ): false | import('./types').NormalizedObjectItem | undefined;
                                                                                      scrollMenuIntoView(): void;
                                                                                      handleSelect(): void;
                                                                                      handleMouseDown: (e: any) => void;
                                                                                      renderMenu(): any;
                                                                                      renderMenuItem(
                                                                                      dataSource: import('./types').NormalizedObjectItem[]
                                                                                      ): import('react').ReactElement<
                                                                                      any,
                                                                                      string | import('react').JSXElementConstructor<any>
                                                                                      >[];
                                                                                      saveSelectRef: (ref: HTMLElement | null) => void;
                                                                                      saveInputRef: (
                                                                                      ref: import('../config-provider/types').ConfiguredComponent<
                                                                                      import('../input').InputProps &
                                                                                      import('../config-provider/types').ComponentCommonProps,
                                                                                      import('../input/input').default<import('../input').InputProps>
                                                                                      > &
                                                                                      Pick<
                                                                                      import('../input/input').default<import('../input').InputProps>,
                                                                                      'focus' | 'getInputNode'
                                                                                      >
                                                                                      ) => void;
                                                                                      focusInput(): void;
                                                                                      focus(
                                                                                      start?: number | undefined,
                                                                                      end?: number | undefined,
                                                                                      preventScroll?: boolean
                                                                                      ): void;
                                                                                      beforeOpen(): void;
                                                                                      beforeClose(): void;
                                                                                      savePopupRef: (ref: HTMLDivElement) => void;
                                                                                      shouldAutoWidth(): boolean | undefined;
                                                                                      context: any;
                                                                                      setState<K extends keyof SelectState>(
                                                                                      state:
                                                                                      | SelectState
                                                                                      | ((
                                                                                      prevState: Readonly<import('./select').SelectState>,
                                                                                      props: Readonly<SelectProps>
                                                                                      ) => SelectState | Pick<SelectState, K>)
                                                                                      | Pick<SelectState, K>,
                                                                                      callback?: (() => void) | undefined
                                                                                      ): void;
                                                                                      forceUpdate(callback?: (() => void) | undefined): void;
                                                                                      readonly props: Readonly<SelectProps> &
                                                                                      Readonly<{ children?: import('react').ReactNode }>;
                                                                                      state: Readonly<import('./select').SelectState>;
                                                                                      refs: { [key: string]: any };
                                                                                      shouldComponentUpdate?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextState: Readonly<import('./select').SelectState>,
                                                                                      nextContext: any
                                                                                      ): boolean;
                                                                                      componentDidCatch?(error: Error, errorInfo: any): void;
                                                                                      getSnapshotBeforeUpdate?(
                                                                                      prevProps: Readonly<SelectProps>,
                                                                                      prevState: Readonly<import('./select').SelectState>
                                                                                      ): any;
                                                                                      componentWillMount?(): void;
                                                                                      UNSAFE_componentWillMount?(): void;
                                                                                      componentWillReceiveProps?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      UNSAFE_componentWillReceiveProps?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      componentWillUpdate?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextState: Readonly<import('./select').SelectState>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      UNSAFE_componentWillUpdate?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextState: Readonly<import('./select').SelectState>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      },
                                                                                      Pick<
                                                                                      {
                                                                                      selectAllYet: boolean;
                                                                                      componentDidUpdate(
                                                                                      prevProps: SelectProps,
                                                                                      prevState: import('./base').BaseState
                                                                                      ): void;
                                                                                      componentDidMount(): void;
                                                                                      ie9Hack(): void;
                                                                                      useDetailValue(): boolean;
                                                                                      hasSearch(): boolean;
                                                                                      getTagSize(): 'small' | 'medium' | 'large' | undefined;
                                                                                      handleMenuSelect(
                                                                                      keys: string[],
                                                                                      item: { props: { _key: string } }
                                                                                      ): false | void;
                                                                                      handleItemClick(key: string): void;
                                                                                      handleSingleSelect(
                                                                                      key: string,
                                                                                      triggerType: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      handleMultipleSelect(
                                                                                      keys: import('./types').DataSourceItem[] | undefined,
                                                                                      triggerType: import('./types').VisibleChangeType,
                                                                                      key?: string | null | undefined,
                                                                                      keepSearchValue?: boolean | undefined
                                                                                      ): void;
                                                                                      updateSelectAllYet(value?: unknown): void;
                                                                                      handleSearchValue(value: string): void;
                                                                                      handleSearch(value: string, e: any): void;
                                                                                      handleSearchClear(triggerType?: string | undefined): void;
                                                                                      handleSearchKeyDown(e: any): void;
                                                                                      chooseMultipleItem(key: string): void;
                                                                                      chooseHighlightItem(proxy: unknown, e: any): false | undefined;
                                                                                      handleTagClose(item: import('./types').ObjectItem): boolean;
                                                                                      handleDeleteTag(e: any): false | undefined;
                                                                                      handleSelectAll(e: any): void;
                                                                                      handleVisibleChange(
                                                                                      visible: boolean,
                                                                                      type: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      afterClose(): void;
                                                                                      maxTagPlaceholder(
                                                                                      selectedValues: import('./types').ObjectItem[],
                                                                                      totalValues: import('./types').ObjectItem[]
                                                                                      ): string;
                                                                                      renderValues(): any;
                                                                                      handleWrapClick: (e: any) => void;
                                                                                      handleArrowClick: (e: any) => void;
                                                                                      handleClear: (e: any) => void;
                                                                                      hasClear(): boolean | undefined;
                                                                                      renderExtraNode(): import('react').ReactElement<
                                                                                      any,
                                                                                      string | import('react').JSXElementConstructor<any>
                                                                                      >[];
                                                                                      renderSelect(): any;
                                                                                      renderSearchInput(
                                                                                      valueNodes: any,
                                                                                      placeholder: string | undefined,
                                                                                      inputEl: any
                                                                                      ): any;
                                                                                      renderMenuHeader(): any;
                                                                                      render(): any;
                                                                                      dataStore: import('./data-store').default;
                                                                                      selectDOM: HTMLElement;
                                                                                      width: string | number;
                                                                                      popupRef: HTMLDivElement;
                                                                                      resizeTimeout: number;
                                                                                      highlightTimer: number | undefined;
                                                                                      menuRef:
                                                                                      | import('../config-provider/types').ConfiguredComponent<
                                                                                      import('../menu').MenuProps &
                                                                                      import('../config-provider/types').ComponentCommonProps,
                                                                                      import('../menu/view/menu').Menu
                                                                                      >
                                                                                      | null;
                                                                                      isAutoComplete: boolean;
                                                                                      inputRef: import('../input/input').default<
                                                                                      import('../input').InputProps
                                                                                      >;
                                                                                      valueDataSource: {
                                                                                      value?:
                                                                                      | string
                                                                                      | number
                                                                                      | boolean
                                                                                      | (string | number | boolean | null | undefined)[]
                                                                                      | null
                                                                                      | undefined;
                                                                                      valueDS?:
                                                                                      | import('./types').ObjectItem
                                                                                      | import('./types').ObjectItem[]
                                                                                      | undefined;
                                                                                      mapValueDS?:
                                                                                      | Record<string, import('./types').ObjectItem>
                                                                                      | undefined;
                                                                                      };
                                                                                      componentWillUnmount(): void;
                                                                                      syncWidth(): void;
                                                                                      handleResize(): void;
                                                                                      setDataSource(
                                                                                      props: SelectProps
                                                                                      ): import('./types').NormalizedObjectItem[];
                                                                                      setVisible(
                                                                                      visible: boolean,
                                                                                      type?: import('./types').VisibleChangeType | undefined
                                                                                      ): void;
                                                                                      setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                                                                                      handleChange(
                                                                                      value:
                                                                                      | import('./types').DataSourceItem
                                                                                      | import('./types').DataSourceItem[],
                                                                                      args_0: unknown,
                                                                                      args_1?:
                                                                                      | import('./types').ObjectItem
                                                                                      | import('./types').ObjectItem[]
                                                                                      | undefined
                                                                                      ): void;
                                                                                      handleMenuBodyClick(): void;
                                                                                      toggleHighlightItem(
                                                                                      dir: number
                                                                                      ): false | import('./types').NormalizedObjectItem | undefined;
                                                                                      scrollMenuIntoView(): void;
                                                                                      handleSelect(): void;
                                                                                      handleMouseDown: (e: any) => void;
                                                                                      renderMenu(): any;
                                                                                      renderMenuItem(
                                                                                      dataSource: import('./types').NormalizedObjectItem[]
                                                                                      ): import('react').ReactElement<
                                                                                      any,
                                                                                      string | import('react').JSXElementConstructor<any>
                                                                                      >[];
                                                                                      saveSelectRef: (ref: HTMLElement | null) => void;
                                                                                      saveInputRef: (
                                                                                      ref: import('../config-provider/types').ConfiguredComponent<
                                                                                      import('../input').InputProps &
                                                                                      import('../config-provider/types').ComponentCommonProps,
                                                                                      import('../input/input').default<import('../input').InputProps>
                                                                                      > &
                                                                                      Pick<
                                                                                      import('../input/input').default<
                                                                                      import('../input').InputProps
                                                                                      >,
                                                                                      'focus' | 'getInputNode'
                                                                                      >
                                                                                      ) => void;
                                                                                      focusInput(): void;
                                                                                      focus(
                                                                                      start?: number | undefined,
                                                                                      end?: number | undefined,
                                                                                      preventScroll?: boolean
                                                                                      ): void;
                                                                                      beforeOpen(): void;
                                                                                      beforeClose(): void;
                                                                                      savePopupRef: (ref: HTMLDivElement) => void;
                                                                                      shouldAutoWidth(): boolean | undefined;
                                                                                      context: any;
                                                                                      setState<K extends keyof SelectState>(
                                                                                      state:
                                                                                      | SelectState
                                                                                      | ((
                                                                                      prevState: Readonly<import('./select').SelectState>,
                                                                                      props: Readonly<SelectProps>
                                                                                      ) => SelectState | Pick<SelectState, K>)
                                                                                      | Pick<SelectState, K>,
                                                                                      callback?: (() => void) | undefined
                                                                                      ): void;
                                                                                      forceUpdate(callback?: (() => void) | undefined): void;
                                                                                      readonly props: Readonly<SelectProps> &
                                                                                      Readonly<{ children?: import('react').ReactNode }>;
                                                                                      state: Readonly<import('./select').SelectState>;
                                                                                      refs: { [key: string]: any };
                                                                                      shouldComponentUpdate?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextState: Readonly<import('./select').SelectState>,
                                                                                      nextContext: any
                                                                                      ): boolean;
                                                                                      componentDidCatch?(error: Error, errorInfo: any): void;
                                                                                      getSnapshotBeforeUpdate?(
                                                                                      prevProps: Readonly<SelectProps>,
                                                                                      prevState: Readonly<import('./select').SelectState>
                                                                                      ): any;
                                                                                      componentWillMount?(): void;
                                                                                      UNSAFE_componentWillMount?(): void;
                                                                                      componentWillReceiveProps?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      UNSAFE_componentWillReceiveProps?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      componentWillUpdate?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextState: Readonly<import('./select').SelectState>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      UNSAFE_componentWillUpdate?(
                                                                                      nextProps: Readonly<SelectProps>,
                                                                                      nextState: Readonly<import('./select').SelectState>,
                                                                                      nextContext: any
                                                                                      ): void;
                                                                                      },
                                                                                      'focusInput' | 'handleSearchClear'
                                                                                      >
                                                                                      > & {
                                                                                      Option: typeof Option;
                                                                                      OptionGroup: typeof OptionGroup;
                                                                                      AutoComplete: ConfiguredComponentClass<
                                                                                      AutoCompleteProps & ComponentCommonProps,
                                                                                      {
                                                                                      isInputing: boolean;
                                                                                      componentDidUpdate(prevProps: import('./types').AutoCompleteProps): void;
                                                                                      shouldControlPopup(
                                                                                      props:
                                                                                      | (Readonly<import('./types').AutoCompleteProps> &
                                                                                      Readonly<{ children?: import('react').ReactNode }>)
                                                                                      | undefined,
                                                                                      type: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      handleMenuSelect(keys: string[]): void;
                                                                                      handleItemClick(): void;
                                                                                      handleSelectEvent(
                                                                                      key: string,
                                                                                      item: import('./types').ObjectItem,
                                                                                      triggerType: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      handleChange: (
                                                                                      value: string,
                                                                                      proxy:
                                                                                      | import('./types').VisibleChangeType
                                                                                      | import('react').ChangeEvent<HTMLElement>,
                                                                                      item?: import('./types').ObjectItem | undefined
                                                                                      ) => false | undefined;
                                                                                      handleVisibleChange(
                                                                                      visible: boolean,
                                                                                      type: import('./types').VisibleChangeType
                                                                                      ): void;
                                                                                      beforeClose(): void;
                                                                                      handleTriggerKeyDown(e: any): void;
                                                                                      chooseHighlightItem(): false | undefined;
                                                                                      hasClear(): boolean | '' | undefined;
                                                                                      renderSelect(
                                                                                      props?: Readonly<import('./types').AutoCompleteProps> &
                                                                                      Readonly<{ children?: import('react').ReactNode }>
                                                                                      ): any;
                                                                                      render(): any;
                                                                                      dataStore: import('./data-store').default;
                                                                                      selectDOM: HTMLElement;
                                                                                      width: string | number;
                                                                                      popupRef: HTMLDivElement;
                                                                                      resizeTimeout: number;
                                                                                      highlightTimer: number | undefined;
                                                                                      menuRef:
                                                                                      | import('../config-provider/types').ConfiguredComponent<
                                                                                      import('../menu').MenuProps &
                                                                                      import('../config-provider/types').ComponentCommonProps,
                                                                                      import('../menu/view/menu').Menu
                                                                                      >
                                                                                      | null;
                                                                                      isAutoComplete: boolean;
                                                                                      inputRef: import('../input/input').default<
                                                                                      import('../input').InputProps
                                                                                      >;
                                                                                      valueDataSource: {
                                                                                      value?:
                                                                                      | string
                                                                                      | number
                                                                                      | boolean
                                                                                      | (string | number | boolean | null | undefined)[]
                                                                                      | null
                                                                                      | undefined;
                                                                                      valueDS?:
                                                                                      | import('./types').ObjectItem
                                                                                      | import('./types').ObjectItem[]
                                                                                      | undefined;
                                                                                      mapValueDS?:
                                                                                      | Record<string, import('./types').ObjectItem>
                                                                                      | undefined;
                                                                                      };
                                                                                      componentDidMount(): void;
                                                                                      componentWillUnmount(): void;
                                                                                      syncWidth(): void;
                                                                                      handleResize(): void;
                                                                                      setDataSource(
                                                                                      props: import('./types').AutoCompleteProps
                                                                                      ): import('./types').NormalizedObjectItem[];
                                                                                      setVisible(
                                                                                      visible: boolean,
                                                                                      type?: import('./types').VisibleChangeType | undefined
                                                                                      ): void;
                                                                                      setFirstHightLightKeyForMenu(searchValue?: unknown): void;
                                                                                      handleMenuBodyClick(): void;
                                                                                      toggleHighlightItem(
                                                                                      dir: number
                                                                                      ):