Components Typings (#3815)

* Trend

* TopNavHeader

* TagSelect

* SiderMenu

* SettingDrawer

* StandardTable

* StandardFormRow

* SelectLang

* Reault

* PageHeaderWrapper

* PageHeaderWrapper

* PageHeader

* NumberInfo

* NoticeIcon

* Login

* code style

* GlobalHeader Footer

* Exception

* Ellipsis

* EditableLinkGroup

* EditableItem

* DescriptionList

* AvticleList

* Update src/components/AvatarList/AvatarItem.d.ts
Co-Authored-By: xiaohuoni <xiaohuoni@users.noreply.github.com>

* Update src/components/Login/index.d.ts
Co-Authored-By: xiaohuoni <xiaohuoni@users.noreply.github.com>

* remove '* as'

* Update src/components/AvatarList/index.d.ts
Co-Authored-By: xiaohuoni <xiaohuoni@users.noreply.github.com>

* TagSelect

* SiderTheme CollapseType MenuMode

* Login

src/components/ArticleListContent/index.d.ts

+import React from 'react';
+
+export interface ApplicationsProps {
+  data: {
+    content?: string;
+    updatedAt?: any;
+    avatar?: string;
+    owner?: string;
+    href?: string;
+  };
+}
+
+export default class ArticleListContent extends React.Component<ApplicationsProps, any> {}

src/components/Authorized/AuthorizedRoute.d.ts

-import * as React from 'react';
+import React from 'react';
 import { RouteProps } from 'react-router';
 
 type authorityFN = (currentAuthority?: string) => boolean;

src/components/Authorized/index.d.ts

-import * as React from 'react';
+import React from 'react';
 import AuthorizedRoute, { authority } from './AuthorizedRoute';
 export type IReactComponent<P = any> =
   | React.StatelessComponent<P>

src/components/AvatarList/AvatarItem.d.ts

-import * as React from 'react';
-export interface IAvatarItemProps {
+import React from 'react';
+
+export declare type SizeType = number | 'small' | 'default' | 'large';
+
+export interface AvatarItemProps {
   tips: React.ReactNode;
   src: string;
+  size?: SizeType;
   style?: React.CSSProperties;
+  onClick?: () => void;
 }
 
-export default class AvatarItem extends React.Component<IAvatarItemProps, any> {
-  constructor(props: IAvatarItemProps);
+export default class AvatarItem extends React.Component<AvatarItemProps, any> {
+  constructor(props: AvatarItemProps);
 }

src/components/AvatarList/index.d.ts

-import * as React from 'react';
-import AvatarItem from './AvatarItem';
+import React from 'react';
+import AvatarItem, { AvatarItemProps, SizeType } from './AvatarItem';
 
-export interface IAvatarListProps {
-  size?: 'large' | 'small' | 'mini' | 'default';
+export interface AvatarListProps {
+  Item?: React.ReactElement<AvatarItemProps>;
+  size?: SizeType;
   maxLength?: number;
   excessItemsStyle?: React.CSSProperties;
   style?: React.CSSProperties;
-  children: React.ReactElement<AvatarItem> | Array<React.ReactElement<AvatarItem>>;
+  children: React.ReactElement<AvatarItemProps> | Array<React.ReactElement<AvatarItemProps>>;
 }
-
-export default class AvatarList extends React.Component<IAvatarListProps, any> {
+export default class AvatarList extends React.Component<AvatarListProps, any> {
   public static Item: typeof AvatarItem;
 }

src/components/Charts/Bar/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IBarProps {
   title: React.ReactNode;
   color?: string;

src/components/Charts/ChartCard/index.d.ts

 import { CardProps } from 'antd/lib/card';
-import * as React from 'react';
+import React from 'react';
 
 export interface IChartCardProps extends CardProps {
   title: React.ReactNode;

src/components/Charts/Field/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IFieldProps {
   label: React.ReactNode;
   value: React.ReactNode;

src/components/Charts/Gauge/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IGaugeProps {
   title: React.ReactNode;
   color?: string;

src/components/Charts/MiniArea/index.d.ts

-import * as React from 'react';
+import React from 'react';
 
 // g2已经更新到3.0
 // 不带的写了

src/components/Charts/MiniBar/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IMiniBarProps {
   color?: string;
   height: number;

src/components/Charts/MiniProgress/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IMiniProgressProps {
   target: number;
   color?: string;

src/components/Charts/Pie/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IPieProps {
   animate?: boolean;
   color?: string;

src/components/Charts/Radar/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IRadarProps {
   title?: React.ReactNode;
   height: number;

src/components/Charts/TagCloud/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface ITagCloudProps {
   data: Array<{
     name: string;

src/components/Charts/TimelineChart/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface ITimelineChartProps {
   data: Array<{
     x: number;

src/components/Charts/WaterWave/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface IWaterWaveProps {
   title: React.ReactNode;
   color?: string;

src/components/CountDown/index.d.ts

-import * as React from 'react';
+import React from 'react';
 export interface ICountDownProps {
   format?: (time: number) => void;
   target: Date | number;

src/components/DescriptionList/Description.d.ts

-import * as React from 'react';
+import React from 'react';
+import { ColProps } from 'antd/es/col';
 
-export default class Description extends React.Component<
-  {
-    term: React.ReactNode;
+export interface DescriptionProps extends ColProps {
+  column?: number;
+  key?: string | number;
   style?: React.CSSProperties;
-  },
-  any
-> {}
+  term?: React.ReactNode;
+}
+
+export default class Description extends React.Component<DescriptionProps, any> {}

src/components/DescriptionList/index.d.ts

-import * as React from 'react';
-import Description from './Description';
+import React from 'react';
+import Description, { DescriptionProps } from './Description';
 
-export interface IDescriptionListProps {
-  layout?: 'horizontal' | 'vertical';
+export interface DescriptionListProps {
+  className?: string;
   col?: number;
-  title: React.ReactNode;
+  description?: DescriptionProps[];
   gutter?: number;
+  layout?: 'horizontal' | 'vertical';
   size?: 'large' | 'small';
   style?: React.CSSProperties;
+  title?: React.ReactNode;
 }
 
-export default class DescriptionList extends React.Component<IDescriptionListProps, any> {
+export default class DescriptionList extends React.Component<DescriptionListProps, any> {
   public static Description: typeof Description;
 }

src/components/EditableItem/index.d.ts

+import React from 'react';
+
+export interface EditableItemProps {
+  onChange?: (value?: string | string[] | number) => void;
+}
+
+export default class EditableItem extends React.Component<EditableItemProps, any> {}

src/components/EditableLinkGroup/index.d.ts

+import React from 'react';
+
+export interface EditableLinkGroupProps {
+  links: any[];
+  onAdd: () => void;
+  linkElement: string;
+}
+
+export default class EditableLinkGroup extends React.Component<EditableLinkGroupProps, any> {}

src/components/Ellipsis/index.d.ts

-import * as React from 'react';
+import React from 'react';
 import { TooltipProps } from 'antd/lib/tooltip';
 
-export interface IEllipsisTooltipProps extends TooltipProps {
+export interface EllipsisTooltipProps extends TooltipProps {
   title?: undefined;
   overlayStyle?: undefined;
 }
 
-export interface IEllipsisProps {
-  tooltip?: boolean | IEllipsisTooltipProps;
+export interface EllipsisProps {
+  tooltip?: boolean | EllipsisTooltipProps;
   length?: number;
   lines?: number;
   style?: React.CSSProperties;
@@ -18,4 +18,4 @@ export interface IEllipsisProps {
 export function getStrFullLength(str: string): number;
 export function cutStrByFullLength(str: string, maxLength: number): string;
 
-export default class Ellipsis extends React.Component<IEllipsisProps, any> {}
+export default class Ellipsis extends React.Component<EllipsisProps, any> {}

src/components/Exception/index.d.ts

-import * as React from 'react';
-export interface IExceptionProps {
+import React from 'react';
+import * as H from 'history';
+
+export interface ExceptionProps<
+  L = {
+    to: H.LocationDescriptor;
+    href?: H.LocationDescriptor;
+    replace?: boolean;
+    innerRef?: (node: HTMLAnchorElement | null) => void;
+  }
+> {
   type?: '403' | '404' | '500';
   title?: React.ReactNode;
   desc?: React.ReactNode;
   img?: string;
   actions?: React.ReactNode;
-  linkElement?: string | React.ComponentType;
+  linkElement?: string | React.ComponentType<L>;
   style?: React.CSSProperties;
   className?: string;
   backText?: React.ReactNode;
   redirect?: string;
 }
-
-export default class Exception extends React.Component<IExceptionProps, any> {}
+export default class Exception extends React.Component<ExceptionProps, any> {}

src/components/FooterToolbar/index.d.ts

-import * as React from 'react';
-export interface IFooterToolbarProps {
+import React from 'react';
+export interface FooterToolbarProps {
   extra: React.ReactNode;
   style?: React.CSSProperties;
+  className?: string;
 }
 
-export default class FooterToolbar extends React.Component<IFooterToolbarProps, any> {}
+export default class FooterToolbar extends React.Component<FooterToolbarProps, any> {}

src/components/GlobalFooter/index.d.ts

-import * as React from 'react';
-export interface IGlobalFooterProps {
+import React from 'react';
+export interface GlobalFooterProps {
   links?: Array<{
     key?: string;
     title: React.ReactNode;
@@ -8,6 +8,7 @@ export interface IGlobalFooterProps {
   }>;
   copyright?: React.ReactNode;
   style?: React.CSSProperties;
+  className?: string;
 }
 
-export default class GlobalFooter extends React.Component<IGlobalFooterProps, any> {}
+export default class GlobalFooter extends React.Component<GlobalFooterProps, any> {}

src/components/GlobalHeader/RightContent.d.ts

+import React from 'react';
+import { DropDownProps } from 'antd/lib/dropdown';
+import { ClickParam } from 'antd/es/menu';
+import { SiderTheme } from 'antd/es/Layout/Sider';
+
+export interface GlobalHeaderRightProps {
+  notices?: any[];
+  dispatch?: (args: any) => void;
+  currentUser?: {
+    avatar?: string;
+    name?: string;
+    title?: string;
+    group?: string;
+    signature?: string;
+    geographic?: any;
+    tags?: any[];
+    unreadCount: number;
+  };
+  fetchingNotices?: boolean;
+  onNoticeVisibleChange?: (visible: boolean) => void;
+  onMenuClick?: (param: ClickParam) => void;
+  onNoticeClear?: (tabName: string) => void;
+  theme?: SiderTheme;
+}
+
+export default class GlobalHeaderRight extends React.Component<GlobalHeaderRightProps, any> {}

src/components/GlobalHeader/index.d.ts

+import React from 'react';
+
+export interface GlobalHeaderProps {
+  collapsed?: boolean;
+  onCollapse?: (collapsed: boolean) => void;
+  isMobile?: boolean;
+  logo?: string;
+  onNoticeClear?: (type: string) => void;
+  onMenuClick?: ({ key: string }) => void;
+  onNoticeVisibleChange?: (b: boolean) => void;
+}
+
+export default class GlobalHeader extends React.Component<GlobalHeaderProps, any> {}

src/components/HeaderDropdown/index.d.ts

-import * as React from 'react';
+import React from 'react';
 import { DropDownProps } from 'antd/lib/dropdown';
 
-export interface IHeaderDropdownProps extends DropDownProps {
+declare type OverlayFunc = () => React.ReactNode;
+
+export interface HeaderDropdownProps extends DropDownProps {
   overlayClassName?: string;
+  overlay: React.ReactNode | OverlayFunc;
+  placement?: 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topCenter' | 'topRight' | 'bottomCenter';
 }
 
-export default class HeaderDropdown extends React.Component<IHeaderDropdownProps, any> {}
+export default class HeaderDropdown extends React.Component<HeaderDropdownProps, any> {}

src/components/HeaderSearch/index.d.ts

-import * as React from 'react';
-export interface IHeaderSearchProps {
+import React from 'react';
+export interface HeaderSearchProps {
   placeholder?: string;
   dataSource?: string[];
   defaultOpen?: boolean;
@@ -12,4 +12,4 @@ export interface IHeaderSearchProps {
   className?: string;
 }
 
-export default class HeaderSearch extends React.Component<IHeaderSearchProps, any> {}
+export default class HeaderSearch extends React.Component<HeaderSearchProps, any> {}

src/components/Login/LoginItem.d.ts

-import * as React from 'react';
-export interface ILoginItemProps {
+import React from 'react';
+import { WrappedFormUtils } from 'antd/es/form/Form';
+import ItemMap from './map';
+import { Omit } from 'antd/es/_util/type';
+
+export type WrappedLoginItemProps = Omit<LoginItemProps, 'form' | 'type' | 'updateActive'>;
+export type LoginItemType = { [K in keyof typeof ItemMap]: React.FC<WrappedLoginItemProps> };
+
+export interface LoginItemProps {
   name?: string;
   rules?: any[];
   style?: React.CSSProperties;
-  onGetCaptcha?: () => void;
+  onGetCaptcha?: (event?: MouseEvent) => void;
   placeholder?: string;
   buttonText?: React.ReactNode;
+  onPressEnter?: (e: any) => void;
+  countDown?: number;
+  getCaptchaButtonText?: string;
+  getCaptchaSecondText?: string;
+  updateActive: (activeItem: any) => void;
+  form: WrappedFormUtils;
+  type: string;
+  defaultValue?: string;
+  customprops?: any;
+  onChange?: (e: any) => void;
 }
 
-export default class LoginItem extends React.Component<ILoginItemProps, any> {}
+export default class LoginItem extends React.Component<LoginItemProps, any> {}

src/components/Login/LoginTab.d.ts

-import * as React from 'react';
+import React from 'react';
 
-export interface ILoginTabProps {
+export interface LoginTabProps {
   key?: string;
   tab?: React.ReactNode;
+  tabUtil: {
+    addTab: (id: any) => void;
+    removeTab: (id: any) => void;
+  };
 }
-export default class LoginTab extends React.Component<ILoginTabProps, any> {}
+export default class LoginTab extends React.Component<LoginTabProps, any> {}

src/components/Login/index.d.ts

 import Button from 'antd/lib/button';
-import * as React from 'react';
-import LoginItem from './LoginItem';
+import React from 'react';
+import LoginItem, { LoginItemProps, LoginItemType } from './LoginItem';
 import LoginTab from './LoginTab';
+import { WrappedFormUtils } from 'antd/es/form/Form';
+import LoginSubmit from './LoginSubmit';
 
-export interface ILoginProps {
+export interface LoginProps {
   defaultActiveKey?: string;
   onTabChange?: (key: string) => void;
   style?: React.CSSProperties;
   onSubmit?: (error: any, values: any) => void;
+  className?: string;
 }
 
-export default class Login extends React.Component<ILoginProps, any> {
+interface Login extends WrappedFormUtils {}
+declare class Login extends React.Component<LoginProps, any> {
   public static Tab: typeof LoginTab;
-  public static UserName: typeof LoginItem;
-  public static Password: typeof LoginItem;
-  public static Mobile: typeof LoginItem;
-  public static Captcha: typeof LoginItem;
-  public static Submit: typeof Button;
+  public static UserName: React.FC<LoginItemProps>;
+  public static Password: React.FC<LoginItemProps>;
+  public static Mobile: React.FC<LoginItemProps>;
+  public static Captcha: React.FC<LoginItemProps>;
+  public static Submit: typeof LoginSubmit;
 }
+export default Login;

src/components/NoticeIcon/NoticeIconTab.d.ts

 import { SkeletonProps } from 'antd/lib/skeleton';
-import * as React from 'react';
+import React from 'react';
 
-export interface INoticeIconData {
+export interface NoticeIconData {
   avatar?: string | React.ReactNode;
   title?: React.ReactNode;
   description?: React.ReactNode;
@@ -10,16 +10,21 @@ export interface INoticeIconData {
   style?: React.CSSProperties;
 }
 
-export interface INoticeIconTabProps {
+export interface NoticeIconTabProps {
   count?: number;
   emptyText?: React.ReactNode;
   emptyImage?: string;
-  list?: INoticeIconData[];
+  list?: NoticeIconData[];
   name?: string;
   showClear?: boolean;
   showViewMore?: boolean;
   style?: React.CSSProperties;
   title?: string;
+  data?: any[];
+  onClick: (item: any) => void;
+  onClear: (item: any) => void;
+  locale: any;
+  onViewMore: (e: any) => void;
 }
 
-export default class NoticeIconTab extends React.Component<INoticeIconTabProps, any> {}
+export default class NoticeIconTab extends React.Component<NoticeIconTabProps, any> {}

src/components/NoticeIcon/index.d.ts

-import * as React from 'react';
-import NoticeIconTab, { INoticeIconData } from './NoticeIconTab';
+import React from 'react';
+import NoticeIconTab, { NoticeIconData } from './NoticeIconTab';
 
-export interface INoticeIconProps {
+export interface NoticeIconProps {
   count?: number;
   bell?: React.ReactNode;
   className?: string;
   loading?: boolean;
   onClear?: (tabName: string) => void;
-  onItemClick?: (item: INoticeIconData, tabProps: INoticeIconProps) => void;
-  onViewMore?: (tabProps: INoticeIconProps) => void;
+  onItemClick?: (item: NoticeIconData, tabProps: NoticeIconProps) => void;
+  onViewMore?: (tabProps: NoticeIconProps, e: MouseEvent) => void;
   onTabChange?: (tabTile: string) => void;
   style?: React.CSSProperties;
   onPopupVisibleChange?: (visible: boolean) => void;
@@ -22,6 +22,6 @@ export interface INoticeIconProps {
   clearClose?: boolean;
 }
 
-export default class NoticeIcon extends React.Component<INoticeIconProps, any> {
+export default class NoticeIcon extends React.Component<NoticeIconProps, any> {
   public static Tab: typeof NoticeIconTab;
 }

src/components/NumberInfo/index.d.ts

-import * as React from 'react';
-export interface INumberInfoProps {
+import React from 'react';
+export interface NumberInfoProps {
   title?: React.ReactNode | string;
   subTitle?: React.ReactNode | string;
   total?: React.ReactNode | string;
@@ -7,7 +7,8 @@ export interface INumberInfoProps {
   theme?: string;
   gap?: number;
   subTotal?: number;
+  suffix?: string;
   style?: React.CSSProperties;
 }
 
-export default class NumberInfo extends React.Component<INumberInfoProps, any> {}
+export default class NumberInfo extends React.Component<NumberInfoProps, any> {}

src/components/PageHeader/breadcrumb.d.ts

-import * as React from 'react';
-import { IPageHeaderProps } from './index';
+import React from 'react';
+import { PageHeaderProps } from './index';
 
-export default class BreadcrumbView extends React.Component<IPageHeaderProps, any> {}
+export default class BreadcrumbView extends React.Component<PageHeaderProps, any> {}
 
 export function getBreadcrumb(breadcrumbNameMap: object, url: string): object;

src/components/PageHeader/index.d.ts

-/// <reference types="history"  />
-import * as React from 'react';
+import React from 'react';
 import { Location } from 'history';
-export interface IPageHeaderProps {
-  title?: React.ReactNode | string;
+
+export interface PageHeaderProps {
+  title?: React.ReactNode | string | number;
   logo?: React.ReactNode | string;
   action?: React.ReactNode | string;
   content?: React.ReactNode;
   extraContent?: React.ReactNode;
   routes?: any[];
   params?: any;
-  breadcrumbList?: Array<{ title: React.ReactNode; href?: string }>;
+  breadcrumbList?: Array<{ title: string | number; href?: string }>;
   tabList?: Array<{ key: string; tab: React.ReactNode }>;
   tabActiveKey?: string;
   tabDefaultActiveKey?: string;
   onTabChange?: (key: string) => void;
   tabBarExtraContent?: React.ReactNode;
-  linkElement?: React.ReactNode;
+  linkElement?: React.ReactNode | string;
   style?: React.CSSProperties;
   home?: React.ReactNode;
   wide?: boolean;
   hiddenBreadcrumb?: boolean;
+  className?: string;
+  loading?: boolean;
+  breadcrumbSeparator?: React.ReactNode;
   location?: Location;
   itemRender: (menuItem: any) => React.ReactNode;
   breadcrumbNameMap?: any;
 }
 
-export default class PageHeader extends React.Component<IPageHeaderProps, any> {}
+export default class PageHeader extends React.Component<PageHeaderProps, any> {}

src/components/PageHeaderWrapper/GridContent.d.ts

+import React from 'react';
+
+export interface GridContentProps {
+  contentWidth: string;
+  children: React.ReactNode;
+}
+
+export default class GridContent extends React.Component<GridContentProps, any> {}

src/components/PageHeaderWrapper/index.d.ts

+import React from 'react';
+export interface ResultProps {
+  actions?: React.ReactNode;
+  className?: string;
+  description?: React.ReactNode;
+  extra?: React.ReactNode;
+  style?: React.CSSProperties;
+  title?: React.ReactNode;
+  type: 'success' | 'error';
+}
+
+export default class Result extends React.Component<ResultProps, any> {}

src/components/Result/index.d.ts

-import * as React from 'react';
-export interface IResultProps {
-  type: 'success' | 'error';
-  title: React.ReactNode;
+import React from 'react';
+export interface ResultProps {
+  actions?: React.ReactNode;
+  className?: string;
   description?: React.ReactNode;
   extra?: React.ReactNode;
-  actions?: React.ReactNode;
   style?: React.CSSProperties;
+  title?: React.ReactNode;
+  type: 'success' | 'error';
 }
 
-export default class Result extends React.Component<IResultProps, any> {}
+export default class Result extends React.Component<ResultProps, any> {}

src/components/SelectLang/index.d.ts

+import React from 'react';
+
+export interface SelectLangProps {
+  className?: string;
+}
+
+export default class SelectLang extends React.Component<SelectLangProps, any> {}

src/components/SettingDrawer/BlockCheckbox.d.ts

+import React from 'react';
+
+export interface BlockChecboxProps {
+  value: string;
+  onChange: (key: string) => void;
+  list: any[];
+}
+
+export default class BlockChecbox extends React.Component<BlockChecboxProps, any> {}

src/components/SettingDrawer/ThemeColor.d.ts

+import React from 'react';
+
+export interface TagProps {
+  color: string;
+  check: boolean;
+  className?: string;
+  onClick?: () => void;
+}
+
+export default class ThemeColor extends React.Component<TagProps, any> {}

src/components/SettingDrawer/index.d.ts

+import React from 'react';
+import { SiderTheme } from 'antd/es/Layout/Sider';
+
+export interface SettingModelState {
+  navTheme: string | SiderTheme;
+  primaryColor: string;
+  layout: string;
+  contentWidth: string;
+  fixedHeader: boolean;
+  autoHideHeader: boolean;
+  fixSiderbar: boolean;
+  menu: { disableLocal: boolean };
+  title: string;
+  pwa: boolean;
+  iconfontUrl: string;
+  colorWeak: boolean;
+}
+
+export interface SettingDrawerProps {
+  setting?: SettingModelState;
+  dispatch?: (args: any) => void;
+}
+
+export default class SettingDrawer extends React.Component<SettingDrawerProps, any> {}

src/components/SiderMenu/BaseMenu.d.ts

+import React from 'react';
+import * as H from 'history';
+import { SiderTheme, CollapseType } from 'antd/es/Layout/Sider';
+
+import { MenuMode } from 'antd/es/menu';
+
+export interface BaseMenuProps {
+  flatMenuKeys?: any[];
+  location?: H.Location;
+  onCollapse?: (collapsed: boolean, type?: CollapseType) => void;
+  isMobile?: boolean;
+  openKeys?: any;
+  theme?: SiderTheme;
+  mode?: MenuMode;
+  className?: string;
+  collapsed?: boolean;
+  handleOpenChange?: (openKeys: any[]) => void;
+  menuData?: any[];
+  style?: React.CSSProperties;
+  onOpenChange?: (openKeys: string[]) => void;
+}
+
+export default class BaseMenu extends React.Component<BaseMenuProps, any> {}

src/components/SiderMenu/SiderMenu.d.ts

+import React from 'react';
+import * as H from 'history';
+import { BaseMenuProps } from './BaseMenu';
+import { SiderTheme } from 'antd/es/Layout/Sider';
+
+export interface SiderMenuProps extends BaseMenuProps {
+  logo?: string;
+  fixSiderbar?: boolean;
+}
+
+export default class SiderMenu extends React.Component<SiderMenuProps, any> {}

src/components/SiderMenu/index.d.ts

+import React from 'react';
+import { SiderTheme } from 'antd/es/Layout/Sider';
+
+export interface SiderMenuProps {
+  isMobile: boolean;
+  menuData: any[];
+  collapsed: boolean;
+  logo?: string;
+  theme?: SiderTheme;
+  onCollapse: (payload: boolean) => void;
+}
+
+export default class SiderMenuWrapper extends React.Component<SiderMenuProps, any> {}

src/components/StandardFormRow/index.d.ts

+import React from 'react';
+
+export interface StandardFormRowProps {
+  title: string;
+  last?: boolean;
+  block?: boolean;
+  grid?: boolean;
+  style?: React.CSSProperties;
+}
+
+export default class StandardFormRow extends React.Component<StandardFormRowProps, any> {}

src/components/StandardTable/index.d.ts

+import React from 'react';
+import { PaginationConfig, SorterResult, TableCurrentDataSource } from 'antd/lib/table';
+
+export interface StandardTableProps {
+  columns: any;
+  onSelectRow: (row: any) => void;
+  data: any;
+  rowKey?: string;
+  selectedRows: any[];
+  onChange?: (
+    pagination: PaginationConfig,
+    filters: Record<keyof any, string[]>,
+    sorter: SorterResult<any>,
+    extra?: TableCurrentDataSource<any>
+  ) => void;
+  loading?: boolean;
+}
+
+export default class StandardTable extends React.Component<StandardTableProps, any> {}

src/components/TagSelect/TagSelectOption.d.ts

-import * as React from 'react';
+import React from 'react';
 
-export interface ITagSelectOptionProps {
-  value: string | number;
+export interface TagSelectOptionProps {
+  value?: string | number;
   style?: React.CSSProperties;
+  checked?: boolean;
+  onChange?: (value: string | number, state: boolean) => void;
 }
 
-export default class TagSelectOption extends React.Component<ITagSelectOptionProps, any> {}
+export default class TagSelectOption extends React.Component<TagSelectOptionProps, any> {
+  public static isTagSelectOption?: boolean;
+}

src/components/TagSelect/index.d.ts

-import * as React from 'react';
-import TagSelectOption from './TagSelectOption';
+import React from 'react';
+import TagSelectOption, { TagSelectOptionProps } from './TagSelectOption';
 
-export interface ITagSelectProps {
+export interface TagSelectProps {
   onChange?: (value: string[]) => void;
   expandable?: boolean;
   value?: string[] | number[];
   style?: React.CSSProperties;
   hideCheckAll?: boolean;
-  actionsText?: { expandText?: string; collapseText?: string; selectAllText?: string };
+  actionsText?: {
+    expandText?: React.ReactNode;
+    collapseText?: React.ReactNode;
+    selectAllText?: React.ReactNode;
+  };
+  className: string;
+  Option: TagSelectOptionProps;
+  children: React.ReactElement<TagSelectOption> | Array<React.ReactElement<TagSelectOption>>;
 }
 
-export default class TagSelect extends React.Component<ITagSelectProps, any> {
+export default class TagSelect extends React.Component<TagSelectProps, any> {
   public static Option: typeof TagSelectOption;
   private children:
     | React.ReactElement<TagSelectOption>

src/components/TopNavHeader/index.d.ts

+import React from 'react';
+import { SiderTheme, CollapseType } from 'antd/es/Layout/Sider';
+import { MenuMode } from 'antd/es/menu';
+
+export interface TopNavHeaderProps {
+  theme: SiderTheme;
+  contentWidth?: string;
+  menuData?: any[];
+  logo?: string;
+  mode?: MenuMode;
+  flatMenuKeys?: any[];
+  onCollapse?: (collapsed: boolean, type?: CollapseType) => void;
+  isMobile?: boolean;
+  openKeys?: any;
+  className?: string;
+  collapsed?: boolean;
+  handleOpenChange?: (openKeys: any[]) => void;
+  style?: React.CSSProperties;
+  onOpenChange?: (openKeys: string[]) => void;
+  onNoticeClear?: (type: string) => void;
+  onMenuClick?: ({ key: string }) => void;
+  onNoticeVisibleChange?: (b: boolean) => void;
+}
+
+export default class TopNavHeader extends React.Component<TopNavHeaderProps, any> {}

src/components/Trend/index.d.ts

-import * as React from 'react';
+import React from 'react';
 
 export interface ITrendProps {
   colorful?: boolean;
   flag: 'up' | 'down';
   style?: React.CSSProperties;
   reverseColor?: boolean;
+  className?: string;
 }
 
 export default class Trend extends React.Component<ITrendProps, any> {}