@alifd/next

  • Version 1.27.11
  • Published
  • 35.7 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 Box

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

            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 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 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 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 };
                      success: (config: ShowConfig) => { hide: () => void };
                      notice: (config: ShowConfig) => { hide: () => void };
                      Inner: typeof Inner;
                      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>;
                          };

                            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 List

                              const List: ConfiguredComponentClass<
                              ListProps<unknown> & ComponentCommonProps,
                              List<unknown>,
                              {}
                              > & {
                              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 Nav: ConfiguredComponentClass<
                                  NavProps & ComponentCommonProps,
                                  {
                                  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').Divider;
                                  };

                                    variable Notification

                                    const Notification: INotification;

                                      variable Paragraph

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

                                        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 Rating

                                          const Rating: ConfiguredComponentClass<
                                          RatingProps & ComponentCommonProps,
                                          {
                                          [key: `refs-rating-icon-${number}`]: HTMLSpanElement;
                                          timer: NodeJS.Timeout | null;
                                          underlayNode: HTMLDivElement | null;
                                          readonly props: import('../util').ClassPropsWithDefault<
                                          import('./types').RatingProps,
                                          | 'size'
                                          | 'disabled'
                                          | 'prefix'
                                          | 'locale'
                                          | 'defaultValue'
                                          | 'onChange'
                                          | 'count'
                                          | 'readOnly'
                                          | 'isPreview'
                                          | 'showGrade'
                                          | 'allowHalf'
                                          | 'allowClear'
                                          | 'onHoverChange'
                                          | 'readAs'
                                          >;
                                          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;
                                          };
                                            const Search: ConfiguredComponentClass<
                                            SearchProps & ComponentCommonProps,
                                            {
                                            highlightKey: unknown;
                                            inputRef: import('../select').AutoComplete | null;
                                            onChange: (value: any, actionType: string, item: any) => void;
                                            onPressEnter: () => void;
                                            onSearch: () => void;
                                            onFilterChange: (filterValue: string) => void;
                                            onToggleHighlightItem: (highlightKey: unknown, ...args: unknown[]) => void;
                                            onKeyDown: (e: any) => void;
                                            saveInputRef: (ref: import('../select').AutoComplete) => void;
                                            focus: (e: any) => void;
                                            handleFocus(args_0: any): void;
                                            handleBlur(args_0: any): void;
                                            render(): any;
                                            context: any;
                                            setState<K extends keyof SearchState>(
                                            state:
                                            | SearchState
                                            | ((
                                            prevState: Readonly<import('./Search').SearchState>,
                                            props: Readonly<import('./types').SearchProps>
                                            ) => SearchState | Pick<SearchState, K>)
                                            | Pick<SearchState, K>,
                                            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 SplitButton

                                              const SplitButton: ConfiguredComponentClass<
                                              SplitButtonProps & ComponentCommonProps,
                                              SplitButton,
                                              {}
                                              > & {
                                              Group: typeof import('../menu').Group;
                                              Item: typeof import('../menu').Item;
                                              Divider: typeof import('../menu').Divider;
                                              };

                                                variable Step

                                                const Step: ConfiguredComponentClass<
                                                StepProps & ComponentCommonProps,
                                                {
                                                step: HTMLOListElement | null;
                                                componentDidMount(): void;
                                                componentDidUpdate(): void;
                                                componentWillUnmount(): void;
                                                adjustHeight(): void;
                                                resize(): void;
                                                _getValidChildren(
                                                children: any
                                                ): import('react').ReactElement<
                                                any,
                                                string | import('react').JSXElementConstructor<any>
                                                >[];
                                                _stepRefHandler: (ref: HTMLOListElement | null) => void;
                                                render(): any;
                                                context: any;
                                                setState<K extends keyof StepState>(
                                                state:
                                                | StepState
                                                | ((
                                                prevState: Readonly<import('./types').StepState>,
                                                props: Readonly<StepProps>
                                                ) => StepState | Pick<StepState, K>)
                                                | Pick<StepState, K>,
                                                callback?: (() => void) | undefined
                                                ): void;
                                                forceUpdate(callback?: (() => void) | undefined): void;
                                                readonly props: Readonly<StepProps> &
                                                Readonly<{ children?: import('react').ReactNode }>;
                                                state: Readonly<import('./types').StepState>;
                                                refs: { [key: string]: any };
                                                shouldComponentUpdate?(
                                                nextProps: Readonly<StepProps>,
                                                nextState: Readonly<import('./types').StepState>,
                                                nextContext: any
                                                ): boolean;
                                                componentDidCatch?(error: Error, errorInfo: any): void;
                                                getSnapshotBeforeUpdate?(
                                                prevProps: Readonly<StepProps>,
                                                prevState: Readonly<import('./types').StepState>
                                                ): any;
                                                componentWillMount?(): void;
                                                UNSAFE_componentWillMount?(): void;
                                                componentWillReceiveProps?(
                                                nextProps: Readonly<StepProps>,
                                                nextContext: any
                                                ): void;
                                                UNSAFE_componentWillReceiveProps?(
                                                nextProps: Readonly<StepProps>,
                                                nextContext: any
                                                ): void;
                                                componentWillUpdate?(
                                                nextProps: Readonly<StepProps>,
                                                nextState: Readonly<import('./types').StepState>,
                                                nextContext: any
                                                ): void;
                                                UNSAFE_componentWillUpdate?(
                                                nextProps: Readonly<StepProps>,
                                                nextState: Readonly<import('./types').StepState>,
                                                nextContext: any
                                                ): void;
                                                },
                                                {}
                                                > & {
                                                Item: ConfiguredComponentClass<
                                                ItemProps<HTMLElement> & ComponentCommonProps,
                                                {
                                                ro: any;
                                                container: HTMLDivElement;
                                                stepNode: HTMLDivElement;
                                                step: HTMLLIElement;
                                                body: HTMLDivElement;
                                                title: HTMLDivElement;
                                                tail: HTMLDivElement;
                                                eventHandler: { off: () => void } | undefined;
                                                componentDidMount(): void;
                                                componentDidUpdate(): void;
                                                componentWillUnmount(): void;
                                                adjustItemWidth(): void;
                                                adjustTail(): void;
                                                resize(): void;
                                                _getNode():
                                                | {}
                                                | import('react').ReactElement<
                                                any,
                                                string | import('react').JSXElementConstructor<any>
                                                >
                                                | null;
                                                getNode(args: {
                                                stepCls: string;
                                                overlayCls: { width: string } | null;
                                                others: Omit<
                                                ItemProps<HTMLElement>,
                                                | 'animation'
                                                | 'content'
                                                | 'direction'
                                                | 'title'
                                                | 'stretch'
                                                | 'rtl'
                                                | 'icon'
                                                | 'disabled'
                                                | 'total'
                                                | 'popupContainer'
                                                | 'prefix'
                                                | 'locale'
                                                | 'pure'
                                                | 'device'
                                                | 'errorBoundary'
                                                | 'warning'
                                                | 'children'
                                                | 'defaultPropsConfig'
                                                | 'className'
                                                | 'status'
                                                | 'onClick'
                                                | 'shape'
                                                | 'itemRender'
                                                | 'readOnly'
                                                | 'percent'
                                                | 'labelPlacement'
                                                | 'parentWidth'
                                                | 'parentHeight'
                                                | 'index'
                                                | 'onResize'
                                                >;
                                                }): any;
                                                getStyle(): { width: string | number };
                                                onClick: () => false | undefined;
                                                removeClickedCls(): void;
                                                _itemRender(index: number, status: import('./types').StepStatus): any;
                                                _refHandlerCreator<
                                                Name extends
                                                | 'title'
                                                | 'container'
                                                | 'body'
                                                | 'step'
                                                | 'stepNode'
                                                | 'tail'
                                                >(
                                                refName: Name
                                                ): (ref: any) => void;
                                                render(): any;
                                                context: any;
                                                setState<K_1 extends never>(
                                                state:
                                                | {}
                                                | ((
                                                prevState: Readonly<{}>,
                                                props: Readonly<ItemProps<HTMLElement>>
                                                ) => {} | Pick<{}, K_1>)
                                                | Pick<{}, K_1>,
                                                callback?: (() => void) | undefined
                                                ): void;
                                                forceUpdate(callback?: (() => void) | undefined): void;
                                                readonly props: Readonly<ItemProps<HTMLElement>> &
                                                Readonly<{ children?: import('react').ReactNode }>;
                                                state: Readonly<{}>;
                                                refs: { [key: string]: any };
                                                shouldComponentUpdate?(
                                                nextProps: Readonly<ItemProps<HTMLElement>>,
                                                nextState: Readonly<{}>,
                                                nextContext: any
                                                ): boolean;
                                                componentDidCatch?(error: Error, errorInfo: any): void;
                                                getSnapshotBeforeUpdate?(
                                                prevProps: Readonly<ItemProps<HTMLElement>>,
                                                prevState: Readonly<{}>
                                                ): any;
                                                componentWillMount?(): void;
                                                UNSAFE_componentWillMount?(): void;
                                                componentWillReceiveProps?(
                                                nextProps: Readonly<ItemProps<HTMLElement>>,
                                                nextContext: any
                                                ): void;
                                                UNSAFE_componentWillReceiveProps?(
                                                nextProps: Readonly<ItemProps<HTMLElement>>,
                                                nextContext: any
                                                ): void;
                                                componentWillUpdate?(
                                                nextProps: Readonly<ItemProps<HTMLElement>>,
                                                nextState: Readonly<{}>,
                                                nextContext: any
                                                ): void;
                                                UNSAFE_componentWillUpdate?(
                                                nextProps: Readonly<ItemProps<HTMLElement>>,
                                                nextState: Readonly<{}>,
                                                nextContext: any
                                                ): void;
                                                },
                                                {}
                                                >;
                                                };

                                                  variable Switch

                                                  const Switch: ConfiguredComponentClass<
                                                  SwitchProps & ComponentCommonProps,
                                                  Switch,
                                                  {}
                                                  >;

                                                    variable Tag

                                                    const Tag: ConfiguredComponentClass<
                                                    (TagProps & ComponentCommonProps) & ComponentCommonProps,
                                                    ConfiguredComponent<
                                                    TagProps & ComponentCommonProps,
                                                    {
                                                    __destroyed: boolean;
                                                    tagNode: HTMLDivElement | null;
                                                    componentWillUnmount(): void;
                                                    handleClose(from: import('./types').CloseArea): void;
                                                    handleBodyClick(e: any): void;
                                                    onKeyDown: (e: any) => void;
                                                    handleTailClick(e: any): void;
                                                    handleAnimationInit(node: HTMLElement): void;
                                                    handleAnimationEnd(node: HTMLElement): void;
                                                    renderAnimatedTag(children: any, animationName: string): any;
                                                    renderTailNode(): import('react').JSX.Element | null;
                                                    isPresetColor(): boolean;
                                                    getTagStyle(): {
                                                    accentColor?: import('csstype').Property.AccentColor | undefined;
                                                    alignContent?: import('csstype').Property.AlignContent | undefined;
                                                    alignItems?: import('csstype').Property.AlignItems | undefined;
                                                    alignSelf?: import('csstype').Property.AlignSelf | undefined;
                                                    alignTracks?: import('csstype').Property.AlignTracks | undefined;
                                                    animationComposition?:
                                                    | import('csstype').Property.AnimationComposition
                                                    | undefined;
                                                    animationDelay?:
                                                    | import('csstype').Property.AnimationDelay<string & {}>
                                                    | undefined;
                                                    animationDirection?:
                                                    | import('csstype').Property.AnimationDirection
                                                    | undefined;
                                                    animationDuration?:
                                                    | import('csstype').Property.AnimationDuration<string & {}>
                                                    | undefined;
                                                    animationFillMode?:
                                                    | import('csstype').Property.AnimationFillMode
                                                    | undefined;
                                                    animationIterationCount?:
                                                    | import('csstype').Property.AnimationIterationCount
                                                    | undefined;
                                                    animationName?: import('csstype').Property.AnimationName | undefined;
                                                    animationPlayState?:
                                                    | import('csstype').Property.AnimationPlayState
                                                    | undefined;
                                                    animationRangeEnd?:
                                                    | import('csstype').Property.AnimationRangeEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    animationRangeStart?:
                                                    | import('csstype').Property.AnimationRangeStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    animationTimeline?:
                                                    | import('csstype').Property.AnimationTimeline
                                                    | undefined;
                                                    animationTimingFunction?:
                                                    | import('csstype').Property.AnimationTimingFunction
                                                    | undefined;
                                                    appearance?: import('csstype').Property.Appearance | undefined;
                                                    aspectRatio?: import('csstype').Property.AspectRatio | undefined;
                                                    backdropFilter?:
                                                    | import('csstype').Property.BackdropFilter
                                                    | undefined;
                                                    backfaceVisibility?:
                                                    | import('csstype').Property.BackfaceVisibility
                                                    | undefined;
                                                    backgroundAttachment?:
                                                    | import('csstype').Property.BackgroundAttachment
                                                    | undefined;
                                                    backgroundBlendMode?:
                                                    | import('csstype').Property.BackgroundBlendMode
                                                    | undefined;
                                                    backgroundClip?:
                                                    | import('csstype').Property.BackgroundClip
                                                    | undefined;
                                                    backgroundColor?: string | undefined;
                                                    backgroundImage?:
                                                    | import('csstype').Property.BackgroundImage
                                                    | undefined;
                                                    backgroundOrigin?:
                                                    | import('csstype').Property.BackgroundOrigin
                                                    | undefined;
                                                    backgroundPositionX?:
                                                    | import('csstype').Property.BackgroundPositionX<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    backgroundPositionY?:
                                                    | import('csstype').Property.BackgroundPositionY<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    backgroundRepeat?:
                                                    | import('csstype').Property.BackgroundRepeat
                                                    | undefined;
                                                    backgroundSize?:
                                                    | import('csstype').Property.BackgroundSize<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    blockOverflow?: import('csstype').Property.BlockOverflow | undefined;
                                                    blockSize?:
                                                    | import('csstype').Property.BlockSize<number | (string & {})>
                                                    | undefined;
                                                    borderBlockColor?:
                                                    | import('csstype').Property.BorderBlockColor
                                                    | undefined;
                                                    borderBlockEndColor?:
                                                    | import('csstype').Property.BorderBlockEndColor
                                                    | undefined;
                                                    borderBlockEndStyle?:
                                                    | import('csstype').Property.BorderBlockEndStyle
                                                    | undefined;
                                                    borderBlockEndWidth?:
                                                    | import('csstype').Property.BorderBlockEndWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBlockStartColor?:
                                                    | import('csstype').Property.BorderBlockStartColor
                                                    | undefined;
                                                    borderBlockStartStyle?:
                                                    | import('csstype').Property.BorderBlockStartStyle
                                                    | undefined;
                                                    borderBlockStartWidth?:
                                                    | import('csstype').Property.BorderBlockStartWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBlockStyle?:
                                                    | import('csstype').Property.BorderBlockStyle
                                                    | undefined;
                                                    borderBlockWidth?:
                                                    | import('csstype').Property.BorderBlockWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBottomColor?:
                                                    | import('csstype').Property.BorderBottomColor
                                                    | undefined;
                                                    borderBottomLeftRadius?:
                                                    | import('csstype').Property.BorderBottomLeftRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBottomRightRadius?:
                                                    | import('csstype').Property.BorderBottomRightRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBottomStyle?:
                                                    | import('csstype').Property.BorderBottomStyle
                                                    | undefined;
                                                    borderBottomWidth?:
                                                    | import('csstype').Property.BorderBottomWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderCollapse?:
                                                    | import('csstype').Property.BorderCollapse
                                                    | undefined;
                                                    borderEndEndRadius?:
                                                    | import('csstype').Property.BorderEndEndRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderEndStartRadius?:
                                                    | import('csstype').Property.BorderEndStartRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderImageOutset?:
                                                    | import('csstype').Property.BorderImageOutset<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderImageRepeat?:
                                                    | import('csstype').Property.BorderImageRepeat
                                                    | undefined;
                                                    borderImageSlice?:
                                                    | import('csstype').Property.BorderImageSlice
                                                    | undefined;
                                                    borderImageSource?:
                                                    | import('csstype').Property.BorderImageSource
                                                    | undefined;
                                                    borderImageWidth?:
                                                    | import('csstype').Property.BorderImageWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderInlineColor?:
                                                    | import('csstype').Property.BorderInlineColor
                                                    | undefined;
                                                    borderInlineEndColor?:
                                                    | import('csstype').Property.BorderInlineEndColor
                                                    | undefined;
                                                    borderInlineEndStyle?:
                                                    | import('csstype').Property.BorderInlineEndStyle
                                                    | undefined;
                                                    borderInlineEndWidth?:
                                                    | import('csstype').Property.BorderInlineEndWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderInlineStartColor?:
                                                    | import('csstype').Property.BorderInlineStartColor
                                                    | undefined;
                                                    borderInlineStartStyle?:
                                                    | import('csstype').Property.BorderInlineStartStyle
                                                    | undefined;
                                                    borderInlineStartWidth?:
                                                    | import('csstype').Property.BorderInlineStartWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderInlineStyle?:
                                                    | import('csstype').Property.BorderInlineStyle
                                                    | undefined;
                                                    borderInlineWidth?:
                                                    | import('csstype').Property.BorderInlineWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderLeftColor?:
                                                    | import('csstype').Property.BorderLeftColor
                                                    | undefined;
                                                    borderLeftStyle?:
                                                    | import('csstype').Property.BorderLeftStyle
                                                    | undefined;
                                                    borderLeftWidth?:
                                                    | import('csstype').Property.BorderLeftWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderRightColor?:
                                                    | import('csstype').Property.BorderRightColor
                                                    | undefined;
                                                    borderRightStyle?:
                                                    | import('csstype').Property.BorderRightStyle
                                                    | undefined;
                                                    borderRightWidth?:
                                                    | import('csstype').Property.BorderRightWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderSpacing?:
                                                    | import('csstype').Property.BorderSpacing<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderStartEndRadius?:
                                                    | import('csstype').Property.BorderStartEndRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderStartStartRadius?:
                                                    | import('csstype').Property.BorderStartStartRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderTopColor?:
                                                    | import('csstype').Property.BorderTopColor
                                                    | undefined;
                                                    borderTopLeftRadius?:
                                                    | import('csstype').Property.BorderTopLeftRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderTopRightRadius?:
                                                    | import('csstype').Property.BorderTopRightRadius<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderTopStyle?:
                                                    | import('csstype').Property.BorderTopStyle
                                                    | undefined;
                                                    borderTopWidth?:
                                                    | import('csstype').Property.BorderTopWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    bottom?:
                                                    | import('csstype').Property.Bottom<number | (string & {})>
                                                    | undefined;
                                                    boxDecorationBreak?:
                                                    | import('csstype').Property.BoxDecorationBreak
                                                    | undefined;
                                                    boxShadow?: import('csstype').Property.BoxShadow | undefined;
                                                    boxSizing?: import('csstype').Property.BoxSizing | undefined;
                                                    breakAfter?: import('csstype').Property.BreakAfter | undefined;
                                                    breakBefore?: import('csstype').Property.BreakBefore | undefined;
                                                    breakInside?: import('csstype').Property.BreakInside | undefined;
                                                    captionSide?: import('csstype').Property.CaptionSide | undefined;
                                                    caretColor?: import('csstype').Property.CaretColor | undefined;
                                                    caretShape?: import('csstype').Property.CaretShape | undefined;
                                                    clear?: import('csstype').Property.Clear | undefined;
                                                    clipPath?: import('csstype').Property.ClipPath | undefined;
                                                    color?: string | undefined;
                                                    colorAdjust?:
                                                    | import('csstype').Property.PrintColorAdjust
                                                    | undefined;
                                                    colorScheme?: import('csstype').Property.ColorScheme | undefined;
                                                    columnCount?: import('csstype').Property.ColumnCount | undefined;
                                                    columnFill?: import('csstype').Property.ColumnFill | undefined;
                                                    columnGap?:
                                                    | import('csstype').Property.ColumnGap<number | (string & {})>
                                                    | undefined;
                                                    columnRuleColor?:
                                                    | import('csstype').Property.ColumnRuleColor
                                                    | undefined;
                                                    columnRuleStyle?:
                                                    | import('csstype').Property.ColumnRuleStyle
                                                    | undefined;
                                                    columnRuleWidth?:
                                                    | import('csstype').Property.ColumnRuleWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    columnSpan?: import('csstype').Property.ColumnSpan | undefined;
                                                    columnWidth?:
                                                    | import('csstype').Property.ColumnWidth<number | (string & {})>
                                                    | undefined;
                                                    contain?: import('csstype').Property.Contain | undefined;
                                                    containIntrinsicBlockSize?:
                                                    | import('csstype').Property.ContainIntrinsicBlockSize<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    containIntrinsicHeight?:
                                                    | import('csstype').Property.ContainIntrinsicHeight<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    containIntrinsicInlineSize?:
                                                    | import('csstype').Property.ContainIntrinsicInlineSize<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    containIntrinsicWidth?:
                                                    | import('csstype').Property.ContainIntrinsicWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    containerName?: import('csstype').Property.ContainerName | undefined;
                                                    containerType?: import('csstype').Property.ContainerType | undefined;
                                                    content?: import('csstype').Property.Content | undefined;
                                                    contentVisibility?:
                                                    | import('csstype').Property.ContentVisibility
                                                    | undefined;
                                                    counterIncrement?:
                                                    | import('csstype').Property.CounterIncrement
                                                    | undefined;
                                                    counterReset?: import('csstype').Property.CounterReset | undefined;
                                                    counterSet?: import('csstype').Property.CounterSet | undefined;
                                                    cursor?: import('csstype').Property.Cursor | undefined;
                                                    direction?: import('csstype').Property.Direction | undefined;
                                                    display?: import('csstype').Property.Display | undefined;
                                                    emptyCells?: import('csstype').Property.EmptyCells | undefined;
                                                    filter?: import('csstype').Property.Filter | undefined;
                                                    flexBasis?:
                                                    | import('csstype').Property.FlexBasis<number | (string & {})>
                                                    | undefined;
                                                    flexDirection?: import('csstype').Property.FlexDirection | undefined;
                                                    flexGrow?: import('csstype').Property.FlexGrow | undefined;
                                                    flexShrink?: import('csstype').Property.FlexShrink | undefined;
                                                    flexWrap?: import('csstype').Property.FlexWrap | undefined;
                                                    float?: import('csstype').Property.Float | undefined;
                                                    fontFamily?: import('csstype').Property.FontFamily | undefined;
                                                    fontFeatureSettings?:
                                                    | import('csstype').Property.FontFeatureSettings
                                                    | undefined;
                                                    fontKerning?: import('csstype').Property.FontKerning | undefined;
                                                    fontLanguageOverride?:
                                                    | import('csstype').Property.FontLanguageOverride
                                                    | undefined;
                                                    fontOpticalSizing?:
                                                    | import('csstype').Property.FontOpticalSizing
                                                    | undefined;
                                                    fontPalette?: import('csstype').Property.FontPalette | undefined;
                                                    fontSize?:
                                                    | import('csstype').Property.FontSize<number | (string & {})>
                                                    | undefined;
                                                    fontSizeAdjust?:
                                                    | import('csstype').Property.FontSizeAdjust
                                                    | undefined;
                                                    fontSmooth?:
                                                    | import('csstype').Property.FontSmooth<number | (string & {})>
                                                    | undefined;
                                                    fontStretch?: import('csstype').Property.FontStretch | undefined;
                                                    fontStyle?: import('csstype').Property.FontStyle | undefined;
                                                    fontSynthesis?: import('csstype').Property.FontSynthesis | undefined;
                                                    fontSynthesisPosition?:
                                                    | import('csstype').Property.FontSynthesisPosition
                                                    | undefined;
                                                    fontSynthesisSmallCaps?:
                                                    | import('csstype').Property.FontSynthesisSmallCaps
                                                    | undefined;
                                                    fontSynthesisStyle?:
                                                    | import('csstype').Property.FontSynthesisStyle
                                                    | undefined;
                                                    fontSynthesisWeight?:
                                                    | import('csstype').Property.FontSynthesisWeight
                                                    | undefined;
                                                    fontVariant?: import('csstype').Property.FontVariant | undefined;
                                                    fontVariantAlternates?:
                                                    | import('csstype').Property.FontVariantAlternates
                                                    | undefined;
                                                    fontVariantCaps?:
                                                    | import('csstype').Property.FontVariantCaps
                                                    | undefined;
                                                    fontVariantEastAsian?:
                                                    | import('csstype').Property.FontVariantEastAsian
                                                    | undefined;
                                                    fontVariantEmoji?:
                                                    | import('csstype').Property.FontVariantEmoji
                                                    | undefined;
                                                    fontVariantLigatures?:
                                                    | import('csstype').Property.FontVariantLigatures
                                                    | undefined;
                                                    fontVariantNumeric?:
                                                    | import('csstype').Property.FontVariantNumeric
                                                    | undefined;
                                                    fontVariantPosition?:
                                                    | import('csstype').Property.FontVariantPosition
                                                    | undefined;
                                                    fontVariationSettings?:
                                                    | import('csstype').Property.FontVariationSettings
                                                    | undefined;
                                                    fontWeight?: import('csstype').Property.FontWeight | undefined;
                                                    forcedColorAdjust?:
                                                    | import('csstype').Property.ForcedColorAdjust
                                                    | undefined;
                                                    gridAutoColumns?:
                                                    | import('csstype').Property.GridAutoColumns<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    gridAutoFlow?: import('csstype').Property.GridAutoFlow | undefined;
                                                    gridAutoRows?:
                                                    | import('csstype').Property.GridAutoRows<number | (string & {})>
                                                    | undefined;
                                                    gridColumnEnd?: import('csstype').Property.GridColumnEnd | undefined;
                                                    gridColumnStart?:
                                                    | import('csstype').Property.GridColumnStart
                                                    | undefined;
                                                    gridRowEnd?: import('csstype').Property.GridRowEnd | undefined;
                                                    gridRowStart?: import('csstype').Property.GridRowStart | undefined;
                                                    gridTemplateAreas?:
                                                    | import('csstype').Property.GridTemplateAreas
                                                    | undefined;
                                                    gridTemplateColumns?:
                                                    | import('csstype').Property.GridTemplateColumns<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    gridTemplateRows?:
                                                    | import('csstype').Property.GridTemplateRows<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    hangingPunctuation?:
                                                    | import('csstype').Property.HangingPunctuation
                                                    | undefined;
                                                    height?:
                                                    | import('csstype').Property.Height<number | (string & {})>
                                                    | undefined;
                                                    hyphenateCharacter?:
                                                    | import('csstype').Property.HyphenateCharacter
                                                    | undefined;
                                                    hyphenateLimitChars?:
                                                    | import('csstype').Property.HyphenateLimitChars
                                                    | undefined;
                                                    hyphens?: import('csstype').Property.Hyphens | undefined;
                                                    imageOrientation?:
                                                    | import('csstype').Property.ImageOrientation
                                                    | undefined;
                                                    imageRendering?:
                                                    | import('csstype').Property.ImageRendering
                                                    | undefined;
                                                    imageResolution?:
                                                    | import('csstype').Property.ImageResolution
                                                    | undefined;
                                                    initialLetter?: import('csstype').Property.InitialLetter | undefined;
                                                    inlineSize?:
                                                    | import('csstype').Property.InlineSize<number | (string & {})>
                                                    | undefined;
                                                    inputSecurity?: import('csstype').Property.InputSecurity | undefined;
                                                    insetBlockEnd?:
                                                    | import('csstype').Property.InsetBlockEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    insetBlockStart?:
                                                    | import('csstype').Property.InsetBlockStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    insetInlineEnd?:
                                                    | import('csstype').Property.InsetInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    insetInlineStart?:
                                                    | import('csstype').Property.InsetInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    isolation?: import('csstype').Property.Isolation | undefined;
                                                    justifyContent?:
                                                    | import('csstype').Property.JustifyContent
                                                    | undefined;
                                                    justifyItems?: import('csstype').Property.JustifyItems | undefined;
                                                    justifySelf?: import('csstype').Property.JustifySelf | undefined;
                                                    justifyTracks?: import('csstype').Property.JustifyTracks | undefined;
                                                    left?:
                                                    | import('csstype').Property.Left<number | (string & {})>
                                                    | undefined;
                                                    letterSpacing?:
                                                    | import('csstype').Property.LetterSpacing<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    lineBreak?: import('csstype').Property.LineBreak | undefined;
                                                    lineHeight?:
                                                    | import('csstype').Property.LineHeight<number | (string & {})>
                                                    | undefined;
                                                    lineHeightStep?:
                                                    | import('csstype').Property.LineHeightStep<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    listStyleImage?:
                                                    | import('csstype').Property.ListStyleImage
                                                    | undefined;
                                                    listStylePosition?:
                                                    | import('csstype').Property.ListStylePosition
                                                    | undefined;
                                                    listStyleType?: import('csstype').Property.ListStyleType | undefined;
                                                    marginBlockEnd?:
                                                    | import('csstype').Property.MarginBlockEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    marginBlockStart?:
                                                    | import('csstype').Property.MarginBlockStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    marginBottom?:
                                                    | import('csstype').Property.MarginBottom<number | (string & {})>
                                                    | undefined;
                                                    marginInlineEnd?:
                                                    | import('csstype').Property.MarginInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    marginInlineStart?:
                                                    | import('csstype').Property.MarginInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    marginLeft?:
                                                    | import('csstype').Property.MarginLeft<number | (string & {})>
                                                    | undefined;
                                                    marginRight?:
                                                    | import('csstype').Property.MarginRight<number | (string & {})>
                                                    | undefined;
                                                    marginTop?:
                                                    | import('csstype').Property.MarginTop<number | (string & {})>
                                                    | undefined;
                                                    marginTrim?: import('csstype').Property.MarginTrim | undefined;
                                                    maskBorderMode?:
                                                    | import('csstype').Property.MaskBorderMode
                                                    | undefined;
                                                    maskBorderOutset?:
                                                    | import('csstype').Property.MaskBorderOutset<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    maskBorderRepeat?:
                                                    | import('csstype').Property.MaskBorderRepeat
                                                    | undefined;
                                                    maskBorderSlice?:
                                                    | import('csstype').Property.MaskBorderSlice
                                                    | undefined;
                                                    maskBorderSource?:
                                                    | import('csstype').Property.MaskBorderSource
                                                    | undefined;
                                                    maskBorderWidth?:
                                                    | import('csstype').Property.MaskBorderWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    maskClip?: import('csstype').Property.MaskClip | undefined;
                                                    maskComposite?: import('csstype').Property.MaskComposite | undefined;
                                                    maskImage?: import('csstype').Property.MaskImage | undefined;
                                                    maskMode?: import('csstype').Property.MaskMode | undefined;
                                                    maskOrigin?: import('csstype').Property.MaskOrigin | undefined;
                                                    maskPosition?:
                                                    | import('csstype').Property.MaskPosition<number | (string & {})>
                                                    | undefined;
                                                    maskRepeat?: import('csstype').Property.MaskRepeat | undefined;
                                                    maskSize?:
                                                    | import('csstype').Property.MaskSize<number | (string & {})>
                                                    | undefined;
                                                    maskType?: import('csstype').Property.MaskType | undefined;
                                                    masonryAutoFlow?:
                                                    | import('csstype').Property.MasonryAutoFlow
                                                    | undefined;
                                                    mathDepth?: import('csstype').Property.MathDepth | undefined;
                                                    mathShift?: import('csstype').Property.MathShift | undefined;
                                                    mathStyle?: import('csstype').Property.MathStyle | undefined;
                                                    maxBlockSize?:
                                                    | import('csstype').Property.MaxBlockSize<number | (string & {})>
                                                    | undefined;
                                                    maxHeight?:
                                                    | import('csstype').Property.MaxHeight<number | (string & {})>
                                                    | undefined;
                                                    maxInlineSize?:
                                                    | import('csstype').Property.MaxInlineSize<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    maxLines?: import('csstype').Property.MaxLines | undefined;
                                                    maxWidth?:
                                                    | import('csstype').Property.MaxWidth<number | (string & {})>
                                                    | undefined;
                                                    minBlockSize?:
                                                    | import('csstype').Property.MinBlockSize<number | (string & {})>
                                                    | undefined;
                                                    minHeight?:
                                                    | import('csstype').Property.MinHeight<number | (string & {})>
                                                    | undefined;
                                                    minInlineSize?:
                                                    | import('csstype').Property.MinInlineSize<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    minWidth?:
                                                    | import('csstype').Property.MinWidth<number | (string & {})>
                                                    | undefined;
                                                    mixBlendMode?: import('csstype').Property.MixBlendMode | undefined;
                                                    motionDistance?:
                                                    | import('csstype').Property.OffsetDistance<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    motionPath?: import('csstype').Property.OffsetPath | undefined;
                                                    motionRotation?: import('csstype').Property.OffsetRotate | undefined;
                                                    objectFit?: import('csstype').Property.ObjectFit | undefined;
                                                    objectPosition?:
                                                    | import('csstype').Property.ObjectPosition<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    offsetAnchor?:
                                                    | import('csstype').Property.OffsetAnchor<number | (string & {})>
                                                    | undefined;
                                                    offsetDistance?:
                                                    | import('csstype').Property.OffsetDistance<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    offsetPath?: import('csstype').Property.OffsetPath | undefined;
                                                    offsetPosition?:
                                                    | import('csstype').Property.OffsetPosition<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    offsetRotate?: import('csstype').Property.OffsetRotate | undefined;
                                                    offsetRotation?: import('csstype').Property.OffsetRotate | undefined;
                                                    opacity?: import('csstype').Property.Opacity | undefined;
                                                    order?: import('csstype').Property.Order | undefined;
                                                    orphans?: import('csstype').Property.Orphans | undefined;
                                                    outlineColor?: import('csstype').Property.OutlineColor | undefined;
                                                    outlineOffset?:
                                                    | import('csstype').Property.OutlineOffset<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    outlineStyle?: import('csstype').Property.OutlineStyle | undefined;
                                                    outlineWidth?:
                                                    | import('csstype').Property.OutlineWidth<number | (string & {})>
                                                    | undefined;
                                                    overflowAnchor?:
                                                    | import('csstype').Property.OverflowAnchor
                                                    | undefined;
                                                    overflowBlock?: import('csstype').Property.OverflowBlock | undefined;
                                                    overflowClipBox?:
                                                    | import('csstype').Property.OverflowClipBox
                                                    | undefined;
                                                    overflowClipMargin?:
                                                    | import('csstype').Property.OverflowClipMargin<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    overflowInline?:
                                                    | import('csstype').Property.OverflowInline
                                                    | undefined;
                                                    overflowWrap?: import('csstype').Property.OverflowWrap | undefined;
                                                    overflowX?: import('csstype').Property.OverflowX | undefined;
                                                    overflowY?: import('csstype').Property.OverflowY | undefined;
                                                    overlay?: import('csstype').Property.Overlay | undefined;
                                                    overscrollBehaviorBlock?:
                                                    | import('csstype').Property.OverscrollBehaviorBlock
                                                    | undefined;
                                                    overscrollBehaviorInline?:
                                                    | import('csstype').Property.OverscrollBehaviorInline
                                                    | undefined;
                                                    overscrollBehaviorX?:
                                                    | import('csstype').Property.OverscrollBehaviorX
                                                    | undefined;
                                                    overscrollBehaviorY?:
                                                    | import('csstype').Property.OverscrollBehaviorY
                                                    | undefined;
                                                    paddingBlockEnd?:
                                                    | import('csstype').Property.PaddingBlockEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    paddingBlockStart?:
                                                    | import('csstype').Property.PaddingBlockStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    paddingBottom?:
                                                    | import('csstype').Property.PaddingBottom<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    paddingInlineEnd?:
                                                    | import('csstype').Property.PaddingInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    paddingInlineStart?:
                                                    | import('csstype').Property.PaddingInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    paddingLeft?:
                                                    | import('csstype').Property.PaddingLeft<number | (string & {})>
                                                    | undefined;
                                                    paddingRight?:
                                                    | import('csstype').Property.PaddingRight<number | (string & {})>
                                                    | undefined;
                                                    paddingTop?:
                                                    | import('csstype').Property.PaddingTop<number | (string & {})>
                                                    | undefined;
                                                    page?: import('csstype').Property.Page | undefined;
                                                    pageBreakAfter?:
                                                    | import('csstype').Property.PageBreakAfter
                                                    | undefined;
                                                    pageBreakBefore?:
                                                    | import('csstype').Property.PageBreakBefore
                                                    | undefined;
                                                    pageBreakInside?:
                                                    | import('csstype').Property.PageBreakInside
                                                    | undefined;
                                                    paintOrder?: import('csstype').Property.PaintOrder | undefined;
                                                    perspective?:
                                                    | import('csstype').Property.Perspective<number | (string & {})>
                                                    | undefined;
                                                    perspectiveOrigin?:
                                                    | import('csstype').Property.PerspectiveOrigin<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    pointerEvents?: import('csstype').Property.PointerEvents | undefined;
                                                    position?: import('csstype').Property.Position | undefined;
                                                    printColorAdjust?:
                                                    | import('csstype').Property.PrintColorAdjust
                                                    | undefined;
                                                    quotes?: import('csstype').Property.Quotes | undefined;
                                                    resize?: import('csstype').Property.Resize | undefined;
                                                    right?:
                                                    | import('csstype').Property.Right<number | (string & {})>
                                                    | undefined;
                                                    rotate?: import('csstype').Property.Rotate | undefined;
                                                    rowGap?:
                                                    | import('csstype').Property.RowGap<number | (string & {})>
                                                    | undefined;
                                                    rubyAlign?: import('csstype').Property.RubyAlign | undefined;
                                                    rubyMerge?: import('csstype').Property.RubyMerge | undefined;
                                                    rubyPosition?: import('csstype').Property.RubyPosition | undefined;
                                                    scale?: import('csstype').Property.Scale | undefined;
                                                    scrollBehavior?:
                                                    | import('csstype').Property.ScrollBehavior
                                                    | undefined;
                                                    scrollMarginBlockEnd?:
                                                    | import('csstype').Property.ScrollMarginBlockEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginBlockStart?:
                                                    | import('csstype').Property.ScrollMarginBlockStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginBottom?:
                                                    | import('csstype').Property.ScrollMarginBottom<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginInlineEnd?:
                                                    | import('csstype').Property.ScrollMarginInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginInlineStart?:
                                                    | import('csstype').Property.ScrollMarginInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginLeft?:
                                                    | import('csstype').Property.ScrollMarginLeft<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginRight?:
                                                    | import('csstype').Property.ScrollMarginRight<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginTop?:
                                                    | import('csstype').Property.ScrollMarginTop<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingBlockEnd?:
                                                    | import('csstype').Property.ScrollPaddingBlockEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingBlockStart?:
                                                    | import('csstype').Property.ScrollPaddingBlockStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingBottom?:
                                                    | import('csstype').Property.ScrollPaddingBottom<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingInlineEnd?:
                                                    | import('csstype').Property.ScrollPaddingInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingInlineStart?:
                                                    | import('csstype').Property.ScrollPaddingInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingLeft?:
                                                    | import('csstype').Property.ScrollPaddingLeft<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingRight?:
                                                    | import('csstype').Property.ScrollPaddingRight<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingTop?:
                                                    | import('csstype').Property.ScrollPaddingTop<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollSnapAlign?:
                                                    | import('csstype').Property.ScrollSnapAlign
                                                    | undefined;
                                                    scrollSnapMarginBottom?:
                                                    | import('csstype').Property.ScrollMarginBottom<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollSnapMarginLeft?:
                                                    | import('csstype').Property.ScrollMarginLeft<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollSnapMarginRight?:
                                                    | import('csstype').Property.ScrollMarginRight<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollSnapMarginTop?:
                                                    | import('csstype').Property.ScrollMarginTop<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollSnapStop?:
                                                    | import('csstype').Property.ScrollSnapStop
                                                    | undefined;
                                                    scrollSnapType?:
                                                    | import('csstype').Property.ScrollSnapType
                                                    | undefined;
                                                    scrollTimelineAxis?:
                                                    | import('csstype').Property.ScrollTimelineAxis
                                                    | undefined;
                                                    scrollTimelineName?:
                                                    | import('csstype').Property.ScrollTimelineName
                                                    | undefined;
                                                    scrollbarColor?:
                                                    | import('csstype').Property.ScrollbarColor
                                                    | undefined;
                                                    scrollbarGutter?:
                                                    | import('csstype').Property.ScrollbarGutter
                                                    | undefined;
                                                    scrollbarWidth?:
                                                    | import('csstype').Property.ScrollbarWidth
                                                    | undefined;
                                                    shapeImageThreshold?:
                                                    | import('csstype').Property.ShapeImageThreshold
                                                    | undefined;
                                                    shapeMargin?:
                                                    | import('csstype').Property.ShapeMargin<number | (string & {})>
                                                    | undefined;
                                                    shapeOutside?: import('csstype').Property.ShapeOutside | undefined;
                                                    tabSize?:
                                                    | import('csstype').Property.TabSize<number | (string & {})>
                                                    | undefined;
                                                    tableLayout?: import('csstype').Property.TableLayout | undefined;
                                                    textAlign?: import('csstype').Property.TextAlign | undefined;
                                                    textAlignLast?: import('csstype').Property.TextAlignLast | undefined;
                                                    textCombineUpright?:
                                                    | import('csstype').Property.TextCombineUpright
                                                    | undefined;
                                                    textDecorationColor?:
                                                    | import('csstype').Property.TextDecorationColor
                                                    | undefined;
                                                    textDecorationLine?:
                                                    | import('csstype').Property.TextDecorationLine
                                                    | undefined;
                                                    textDecorationSkip?:
                                                    | import('csstype').Property.TextDecorationSkip
                                                    | undefined;
                                                    textDecorationSkipInk?:
                                                    | import('csstype').Property.TextDecorationSkipInk
                                                    | undefined;
                                                    textDecorationStyle?:
                                                    | import('csstype').Property.TextDecorationStyle
                                                    | undefined;
                                                    textDecorationThickness?:
                                                    | import('csstype').Property.TextDecorationThickness<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    textEmphasisColor?:
                                                    | import('csstype').Property.TextEmphasisColor
                                                    | undefined;
                                                    textEmphasisPosition?:
                                                    | import('csstype').Property.TextEmphasisPosition
                                                    | undefined;
                                                    textEmphasisStyle?:
                                                    | import('csstype').Property.TextEmphasisStyle
                                                    | undefined;
                                                    textIndent?:
                                                    | import('csstype').Property.TextIndent<number | (string & {})>
                                                    | undefined;
                                                    textJustify?: import('csstype').Property.TextJustify | undefined;
                                                    textOrientation?:
                                                    | import('csstype').Property.TextOrientation
                                                    | undefined;
                                                    textOverflow?: import('csstype').Property.TextOverflow | undefined;
                                                    textRendering?: import('csstype').Property.TextRendering | undefined;
                                                    textShadow?: import('csstype').Property.TextShadow | undefined;
                                                    textSizeAdjust?:
                                                    | import('csstype').Property.TextSizeAdjust
                                                    | undefined;
                                                    textTransform?: import('csstype').Property.TextTransform | undefined;
                                                    textUnderlineOffset?:
                                                    | import('csstype').Property.TextUnderlineOffset<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    textUnderlinePosition?:
                                                    | import('csstype').Property.TextUnderlinePosition
                                                    | undefined;
                                                    textWrap?: import('csstype').Property.TextWrap | undefined;
                                                    timelineScope?: import('csstype').Property.TimelineScope | undefined;
                                                    top?:
                                                    | import('csstype').Property.Top<number | (string & {})>
                                                    | undefined;
                                                    touchAction?: import('csstype').Property.TouchAction | undefined;
                                                    transform?: import('csstype').Property.Transform | undefined;
                                                    transformBox?: import('csstype').Property.TransformBox | undefined;
                                                    transformOrigin?:
                                                    | import('csstype').Property.TransformOrigin<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    transformStyle?:
                                                    | import('csstype').Property.TransformStyle
                                                    | undefined;
                                                    transitionBehavior?:
                                                    | import('csstype').Property.TransitionBehavior
                                                    | undefined;
                                                    transitionDelay?:
                                                    | import('csstype').Property.TransitionDelay<string & {}>
                                                    | undefined;
                                                    transitionDuration?:
                                                    | import('csstype').Property.TransitionDuration<string & {}>
                                                    | undefined;
                                                    transitionProperty?:
                                                    | import('csstype').Property.TransitionProperty
                                                    | undefined;
                                                    transitionTimingFunction?:
                                                    | import('csstype').Property.TransitionTimingFunction
                                                    | undefined;
                                                    translate?:
                                                    | import('csstype').Property.Translate<number | (string & {})>
                                                    | undefined;
                                                    unicodeBidi?: import('csstype').Property.UnicodeBidi | undefined;
                                                    userSelect?: import('csstype').Property.UserSelect | undefined;
                                                    verticalAlign?:
                                                    | import('csstype').Property.VerticalAlign<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    viewTimelineAxis?:
                                                    | import('csstype').Property.ViewTimelineAxis
                                                    | undefined;
                                                    viewTimelineInset?:
                                                    | import('csstype').Property.ViewTimelineInset<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    viewTimelineName?:
                                                    | import('csstype').Property.ViewTimelineName
                                                    | undefined;
                                                    viewTransitionName?:
                                                    | import('csstype').Property.ViewTransitionName
                                                    | undefined;
                                                    visibility?: import('csstype').Property.Visibility | undefined;
                                                    whiteSpace?: import('csstype').Property.WhiteSpace | undefined;
                                                    whiteSpaceCollapse?:
                                                    | import('csstype').Property.WhiteSpaceCollapse
                                                    | undefined;
                                                    whiteSpaceTrim?:
                                                    | import('csstype').Property.WhiteSpaceTrim
                                                    | undefined;
                                                    widows?: import('csstype').Property.Widows | undefined;
                                                    width?:
                                                    | import('csstype').Property.Width<number | (string & {})>
                                                    | undefined;
                                                    willChange?: import('csstype').Property.WillChange | undefined;
                                                    wordBreak?: import('csstype').Property.WordBreak | undefined;
                                                    wordSpacing?:
                                                    | import('csstype').Property.WordSpacing<number | (string & {})>
                                                    | undefined;
                                                    wordWrap?: import('csstype').Property.WordWrap | undefined;
                                                    writingMode?: import('csstype').Property.WritingMode | undefined;
                                                    zIndex?: import('csstype').Property.ZIndex | undefined;
                                                    zoom?: import('csstype').Property.Zoom | undefined;
                                                    all?: import('csstype').Globals | undefined;
                                                    animation?:
                                                    | import('csstype').Property.Animation<string & {}>
                                                    | undefined;
                                                    animationRange?:
                                                    | import('csstype').Property.AnimationRange<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    background?:
                                                    | import('csstype').Property.Background<number | (string & {})>
                                                    | undefined;
                                                    backgroundPosition?:
                                                    | import('csstype').Property.BackgroundPosition<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    border?:
                                                    | import('csstype').Property.Border<number | (string & {})>
                                                    | undefined;
                                                    borderBlock?:
                                                    | import('csstype').Property.BorderBlock<number | (string & {})>
                                                    | undefined;
                                                    borderBlockEnd?:
                                                    | import('csstype').Property.BorderBlockEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBlockStart?:
                                                    | import('csstype').Property.BorderBlockStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderBottom?:
                                                    | import('csstype').Property.BorderBottom<number | (string & {})>
                                                    | undefined;
                                                    borderColor?: string | undefined;
                                                    borderImage?: import('csstype').Property.BorderImage | undefined;
                                                    borderInline?:
                                                    | import('csstype').Property.BorderInline<number | (string & {})>
                                                    | undefined;
                                                    borderInlineEnd?:
                                                    | import('csstype').Property.BorderInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderInlineStart?:
                                                    | import('csstype').Property.BorderInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    borderLeft?:
                                                    | import('csstype').Property.BorderLeft<number | (string & {})>
                                                    | undefined;
                                                    borderRadius?:
                                                    | import('csstype').Property.BorderRadius<number | (string & {})>
                                                    | undefined;
                                                    borderRight?:
                                                    | import('csstype').Property.BorderRight<number | (string & {})>
                                                    | undefined;
                                                    borderStyle?: import('csstype').Property.BorderStyle | undefined;
                                                    borderTop?:
                                                    | import('csstype').Property.BorderTop<number | (string & {})>
                                                    | undefined;
                                                    borderWidth?:
                                                    | import('csstype').Property.BorderWidth<number | (string & {})>
                                                    | undefined;
                                                    caret?: import('csstype').Property.Caret | undefined;
                                                    columnRule?:
                                                    | import('csstype').Property.ColumnRule<number | (string & {})>
                                                    | undefined;
                                                    columns?:
                                                    | import('csstype').Property.Columns<number | (string & {})>
                                                    | undefined;
                                                    containIntrinsicSize?:
                                                    | import('csstype').Property.ContainIntrinsicSize<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    container?: import('csstype').Property.Container | undefined;
                                                    flex?:
                                                    | import('csstype').Property.Flex<number | (string & {})>
                                                    | undefined;
                                                    flexFlow?: import('csstype').Property.FlexFlow | undefined;
                                                    font?: import('csstype').Property.Font | undefined;
                                                    gap?:
                                                    | import('csstype').Property.Gap<number | (string & {})>
                                                    | undefined;
                                                    grid?: import('csstype').Property.Grid | undefined;
                                                    gridArea?: import('csstype').Property.GridArea | undefined;
                                                    gridColumn?: import('csstype').Property.GridColumn | undefined;
                                                    gridRow?: import('csstype').Property.GridRow | undefined;
                                                    gridTemplate?: import('csstype').Property.GridTemplate | undefined;
                                                    inset?:
                                                    | import('csstype').Property.Inset<number | (string & {})>
                                                    | undefined;
                                                    insetBlock?:
                                                    | import('csstype').Property.InsetBlock<number | (string & {})>
                                                    | undefined;
                                                    insetInline?:
                                                    | import('csstype').Property.InsetInline<number | (string & {})>
                                                    | undefined;
                                                    lineClamp?: import('csstype').Property.LineClamp | undefined;
                                                    listStyle?: import('csstype').Property.ListStyle | undefined;
                                                    margin?:
                                                    | import('csstype').Property.Margin<number | (string & {})>
                                                    | undefined;
                                                    marginBlock?:
                                                    | import('csstype').Property.MarginBlock<number | (string & {})>
                                                    | undefined;
                                                    marginInline?:
                                                    | import('csstype').Property.MarginInline<number | (string & {})>
                                                    | undefined;
                                                    mask?:
                                                    | import('csstype').Property.Mask<number | (string & {})>
                                                    | undefined;
                                                    maskBorder?: import('csstype').Property.MaskBorder | undefined;
                                                    motion?:
                                                    | import('csstype').Property.Offset<number | (string & {})>
                                                    | undefined;
                                                    offset?:
                                                    | import('csstype').Property.Offset<number | (string & {})>
                                                    | undefined;
                                                    outline?:
                                                    | import('csstype').Property.Outline<number | (string & {})>
                                                    | undefined;
                                                    overflow?: import('csstype').Property.Overflow | undefined;
                                                    overscrollBehavior?:
                                                    | import('csstype').Property.OverscrollBehavior
                                                    | undefined;
                                                    padding?:
                                                    | import('csstype').Property.Padding<number | (string & {})>
                                                    | undefined;
                                                    paddingBlock?:
                                                    | import('csstype').Property.PaddingBlock<number | (string & {})>
                                                    | undefined;
                                                    paddingInline?:
                                                    | import('csstype').Property.PaddingInline<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    placeContent?: import('csstype').Property.PlaceContent | undefined;
                                                    placeItems?: import('csstype').Property.PlaceItems | undefined;
                                                    placeSelf?: import('csstype').Property.PlaceSelf | undefined;
                                                    scrollMargin?:
                                                    | import('csstype').Property.ScrollMargin<number | (string & {})>
                                                    | undefined;
                                                    scrollMarginBlock?:
                                                    | import('csstype').Property.ScrollMarginBlock<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollMarginInline?:
                                                    | import('csstype').Property.ScrollMarginInline<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPadding?:
                                                    | import('csstype').Property.ScrollPadding<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingBlock?:
                                                    | import('csstype').Property.ScrollPaddingBlock<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollPaddingInline?:
                                                    | import('csstype').Property.ScrollPaddingInline<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    scrollSnapMargin?:
                                                    | import('csstype').Property.ScrollMargin<number | (string & {})>
                                                    | undefined;
                                                    scrollTimeline?:
                                                    | import('csstype').Property.ScrollTimeline
                                                    | undefined;
                                                    textDecoration?:
                                                    | import('csstype').Property.TextDecoration<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    textEmphasis?: import('csstype').Property.TextEmphasis | undefined;
                                                    transition?:
                                                    | import('csstype').Property.Transition<string & {}>
                                                    | undefined;
                                                    viewTimeline?: import('csstype').Property.ViewTimeline | undefined;
                                                    MozAnimationDelay?:
                                                    | import('csstype').Property.AnimationDelay<string & {}>
                                                    | undefined;
                                                    MozAnimationDirection?:
                                                    | import('csstype').Property.AnimationDirection
                                                    | undefined;
                                                    MozAnimationDuration?:
                                                    | import('csstype').Property.AnimationDuration<string & {}>
                                                    | undefined;
                                                    MozAnimationFillMode?:
                                                    | import('csstype').Property.AnimationFillMode
                                                    | undefined;
                                                    MozAnimationIterationCount?:
                                                    | import('csstype').Property.AnimationIterationCount
                                                    | undefined;
                                                    MozAnimationName?:
                                                    | import('csstype').Property.AnimationName
                                                    | undefined;
                                                    MozAnimationPlayState?:
                                                    | import('csstype').Property.AnimationPlayState
                                                    | undefined;
                                                    MozAnimationTimingFunction?:
                                                    | import('csstype').Property.AnimationTimingFunction
                                                    | undefined;
                                                    MozAppearance?: import('csstype').Property.MozAppearance | undefined;
                                                    MozBinding?: import('csstype').Property.MozBinding | undefined;
                                                    MozBorderBottomColors?:
                                                    | import('csstype').Property.MozBorderBottomColors
                                                    | undefined;
                                                    MozBorderEndColor?:
                                                    | import('csstype').Property.BorderInlineEndColor
                                                    | undefined;
                                                    MozBorderEndStyle?:
                                                    | import('csstype').Property.BorderInlineEndStyle
                                                    | undefined;
                                                    MozBorderEndWidth?:
                                                    | import('csstype').Property.BorderInlineEndWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozBorderLeftColors?:
                                                    | import('csstype').Property.MozBorderLeftColors
                                                    | undefined;
                                                    MozBorderRightColors?:
                                                    | import('csstype').Property.MozBorderRightColors
                                                    | undefined;
                                                    MozBorderStartColor?:
                                                    | import('csstype').Property.BorderInlineStartColor
                                                    | undefined;
                                                    MozBorderStartStyle?:
                                                    | import('csstype').Property.BorderInlineStartStyle
                                                    | undefined;
                                                    MozBorderTopColors?:
                                                    | import('csstype').Property.MozBorderTopColors
                                                    | undefined;
                                                    MozBoxSizing?: import('csstype').Property.BoxSizing | undefined;
                                                    MozColumnCount?: import('csstype').Property.ColumnCount | undefined;
                                                    MozColumnFill?: import('csstype').Property.ColumnFill | undefined;
                                                    MozColumnRuleColor?:
                                                    | import('csstype').Property.ColumnRuleColor
                                                    | undefined;
                                                    MozColumnRuleStyle?:
                                                    | import('csstype').Property.ColumnRuleStyle
                                                    | undefined;
                                                    MozColumnRuleWidth?:
                                                    | import('csstype').Property.ColumnRuleWidth<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozColumnWidth?:
                                                    | import('csstype').Property.ColumnWidth<number | (string & {})>
                                                    | undefined;
                                                    MozContextProperties?:
                                                    | import('csstype').Property.MozContextProperties
                                                    | undefined;
                                                    MozFontFeatureSettings?:
                                                    | import('csstype').Property.FontFeatureSettings
                                                    | undefined;
                                                    MozFontLanguageOverride?:
                                                    | import('csstype').Property.FontLanguageOverride
                                                    | undefined;
                                                    MozHyphens?: import('csstype').Property.Hyphens | undefined;
                                                    MozImageRegion?:
                                                    | import('csstype').Property.MozImageRegion
                                                    | undefined;
                                                    MozMarginEnd?:
                                                    | import('csstype').Property.MarginInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozMarginStart?:
                                                    | import('csstype').Property.MarginInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozOrient?: import('csstype').Property.MozOrient | undefined;
                                                    MozOsxFontSmoothing?:
                                                    | import('csstype').Property.FontSmooth<number | (string & {})>
                                                    | undefined;
                                                    MozOutlineRadiusBottomleft?:
                                                    | import('csstype').Property.MozOutlineRadiusBottomleft<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozOutlineRadiusBottomright?:
                                                    | import('csstype').Property.MozOutlineRadiusBottomright<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozOutlineRadiusTopleft?:
                                                    | import('csstype').Property.MozOutlineRadiusTopleft<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozOutlineRadiusTopright?:
                                                    | import('csstype').Property.MozOutlineRadiusTopright<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozPaddingEnd?:
                                                    | import('csstype').Property.PaddingInlineEnd<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozPaddingStart?:
                                                    | import('csstype').Property.PaddingInlineStart<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    MozStackSizing?:
                                                    | import('csstype').Property.MozStackSizing
                                                    | undefined;
                                                    MozTabSize?:
                                                    | import('csstype').Property.TabSize<number | (string & {})>
                                                    | undefined;
                                                    MozTextBlink?: import('csstype').Property.MozTextBlink | undefined;
                                                    MozTextSizeAdjust?:
                                                    | import('csstype').Property.TextSizeAdjust
                                                    | undefined;
                                                    MozUserFocus?: import('csstype').Property.MozUserFocus | undefined;
                                                    MozUserModify?: import('csstype').Property.MozUserModify | undefined;
                                                    MozUserSelect?: import('csstype').Property.UserSelect | undefined;
                                                    MozWindowDragging?:
                                                    | import('csstype').Property.MozWindowDragging
                                                    | undefined;
                                                    MozWindowShadow?:
                                                    | import('csstype').Property.MozWindowShadow
                                                    | undefined;
                                                    msAccelerator?: import('csstype').Property.MsAccelerator | undefined;
                                                    msBlockProgression?:
                                                    | import('csstype').Property.MsBlockProgression
                                                    | undefined;
                                                    msContentZoomChaining?:
                                                    | import('csstype').Property.MsContentZoomChaining
                                                    | undefined;
                                                    msContentZoomLimitMax?:
                                                    | import('csstype').Property.MsContentZoomLimitMax
                                                    | undefined;
                                                    msContentZoomLimitMin?:
                                                    | import('csstype').Property.MsContentZoomLimitMin
                                                    | undefined;
                                                    msContentZoomSnapPoints?:
                                                    | import('csstype').Property.MsContentZoomSnapPoints
                                                    | undefined;
                                                    msContentZoomSnapType?:
                                                    | import('csstype').Property.MsContentZoomSnapType
                                                    | undefined;
                                                    msContentZooming?:
                                                    | import('csstype').Property.MsContentZooming
                                                    | undefined;
                                                    msFilter?: import('csstype').Property.MsFilter | undefined;
                                                    msFlexDirection?:
                                                    | import('csstype').Property.FlexDirection
                                                    | undefined;
                                                    msFlexPositive?: import('csstype').Property.FlexGrow | undefined;
                                                    msFlowFrom?: import('csstype').Property.MsFlowFrom | undefined;
                                                    msFlowInto?: import('csstype').Property.MsFlowInto | undefined;
                                                    msGridColumns?:
                                                    | import('csstype').Property.MsGridColumns<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    msGridRows?:
                                                    | import('csstype').Property.MsGridRows<number | (string & {})>
                                                    | undefined;
                                                    msHighContrastAdjust?:
                                                    | import('csstype').Property.MsHighContrastAdjust
                                                    | undefined;
                                                    msHyphenateLimitChars?:
                                                    | import('csstype').Property.MsHyphenateLimitChars
                                                    | undefined;
                                                    msHyphenateLimitLines?:
                                                    | import('csstype').Property.MsHyphenateLimitLines
                                                    | undefined;
                                                    msHyphenateLimitZone?:
                                                    | import('csstype').Property.MsHyphenateLimitZone<
                                                    number | (string & {})
                                                    >
                                                    | undefined;
                                                    msHyphens?: import('csstype').Property.Hyphens | undefined;
                                                    msImeAlign?: import('csstype').Property.MsImeAlign | undefined;
                                                    msLineBreak?: import('csstype').Property.LineBreak | undefined;
                                                    msOrder?: import('csstype').Property.Order |